Translate: Remove --enable-translate-settings

chrome/browser/translate/translate_prefs.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/translate/translate_prefs.h"
 
-#include "base/command_line.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/translate/translate_accept_languages.h"
 #include "chrome/browser/translate/translate_manager.h"
-#include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/translate/translate_util.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 
 const char TranslatePrefs::kPrefTranslateLanguageBlacklist[] =
     "translate_language_blacklist";
 const char TranslatePrefs::kPrefTranslateSiteBlacklist[] =
     "translate_site_blacklist";
 const char TranslatePrefs::kPrefTranslateWhitelists[] =
     "translate_whitelists";
@@ skipping 46 matching lines @@
 }  // namespace
 
 // TranslatePrefs: public: -----------------------------------------------------
 
 TranslatePrefs::TranslatePrefs(PrefService* user_prefs)
     : prefs_(user_prefs) {
 }
 
 bool TranslatePrefs::IsBlockedLanguage(
     const std::string& original_language) const {
-  CommandLine* command_line = CommandLine::ForCurrentProcess();
-  if (command_line->HasSwitch(switches::kEnableTranslateSettings)) {
-    return IsValueBlacklisted(kPrefTranslateBlockedLanguages,
-                              original_language);
-  } else {
-    return IsValueBlacklisted(kPrefTranslateLanguageBlacklist,
-                              original_language);
-  }
+  return IsValueBlacklisted(kPrefTranslateBlockedLanguages,
+                            original_language);
 }
 
 void TranslatePrefs::BlockLanguage(
     const std::string& original_language) {
-  CommandLine* command_line = CommandLine::ForCurrentProcess();
-  if (command_line->HasSwitch(switches::kEnableTranslateSettings)) {
-    BlacklistValue(kPrefTranslateBlockedLanguages, original_language);
-    AppendLanguageToAcceptLanguages(prefs_, original_language);
-  } else {
-    BlacklistValue(kPrefTranslateLanguageBlacklist, original_language);
-  }
+  BlacklistValue(kPrefTranslateBlockedLanguages, original_language);
+  AppendLanguageToAcceptLanguages(prefs_, original_language);
 }
 
 void TranslatePrefs::UnblockLanguage(
     const std::string& original_language) {
-  CommandLine* command_line = CommandLine::ForCurrentProcess();
-  if (command_line->HasSwitch(switches::kEnableTranslateSettings)) {
-    RemoveValueFromBlacklist(kPrefTranslateBlockedLanguages,
-                             original_language);
-  } else {
-    RemoveValueFromBlacklist(kPrefTranslateLanguageBlacklist,
-                             original_language);
-  }
+  RemoveValueFromBlacklist(kPrefTranslateBlockedLanguages,
+                           original_language);
 }
 
 void TranslatePrefs::RemoveLanguageFromLegacyBlacklist(
     const std::string& original_language) {
   RemoveValueFromBlacklist(kPrefTranslateLanguageBlacklist,
                            original_language);
 }
 
 bool TranslatePrefs::IsSiteBlacklisted(const std::string& site) const {
   return IsValueBlacklisted(kPrefTranslateSiteBlacklist, site);
@@ skipping 38 matching lines @@
   DictionaryPrefUpdate update(prefs_, kPrefTranslateWhitelists);
   DictionaryValue* dict = update.Get();
   if (!dict) {
     NOTREACHED() << "Unregistered translate whitelist pref";
     return;
   }
   dict->Remove(original_language, NULL);
 }
 
 bool TranslatePrefs::HasBlacklistedLanguages() const {
-  CommandLine* command_line = CommandLine::ForCurrentProcess();
-  if (command_line->HasSwitch(switches::kEnableTranslateSettings))
-    return !IsListEmpty(kPrefTranslateBlockedLanguages);
-  else
-    return !IsListEmpty(kPrefTranslateLanguageBlacklist);
+  return !IsListEmpty(kPrefTranslateBlockedLanguages);
 }
 
 void TranslatePrefs::ClearBlacklistedLanguages() {
-  CommandLine* command_line = CommandLine::ForCurrentProcess();
-  if (command_line->HasSwitch(switches::kEnableTranslateSettings))
-    prefs_->ClearPref(kPrefTranslateBlockedLanguages);
-  else
-    prefs_->ClearPref(kPrefTranslateLanguageBlacklist);
+  prefs_->ClearPref(kPrefTranslateBlockedLanguages);
 }
 
 bool TranslatePrefs::HasBlacklistedSites() const {
   return !IsListEmpty(kPrefTranslateSiteBlacklist);
 }
 
 void TranslatePrefs::ClearBlacklistedSites() {
   prefs_->ClearPref(kPrefTranslateSiteBlacklist);
 }
 
@@ skipping 51 matching lines @@
 }
 
 // TranslatePrefs: public, static: ---------------------------------------------
 
 // static
 bool TranslatePrefs::CanTranslateLanguage(Profile* profile,
                                           const std::string& language) {
   TranslatePrefs translate_prefs(profile->GetPrefs());
   bool blocked = translate_prefs.IsBlockedLanguage(language);
 
-  CommandLine* command_line = CommandLine::ForCurrentProcess();
-  if (command_line->HasSwitch(switches::kEnableTranslateSettings)) {
-    bool is_accept_language =
-        TranslateManager::IsAcceptLanguage(profile, language);
-    bool can_be_accept_language =
-        TranslateAcceptLanguages::CanBeAcceptLanguage(language);
+  bool is_accept_language =
+      TranslateManager::IsAcceptLanguage(profile, language);
+  bool can_be_accept_language =
+      TranslateAcceptLanguages::CanBeAcceptLanguage(language);
 
-    // Don't translate any user black-listed languages. Checking
-    // |is_accept_language| is necessary because if the user eliminates the
-    // language from the preference, it is natural to forget whether or not
-    // the language should be translated. Checking |cannot_be_accept_language|
-    // is also necessary because some minor languages can't be selected in the
-    // language preference even though the language is available in Translate
-    // server.
-    if (blocked && (is_accept_language || !can_be_accept_language))
-      return false;
-  } else {
-    // Don't translate any user user selected language.
-    if (blocked)
-      return false;
-  }
+  // Don't translate any user black-listed languages. Checking
+  // |is_accept_language| is necessary because if the user eliminates the
+  // language from the preference, it is natural to forget whether or not
+  // the language should be translated. Checking |cannot_be_accept_language|
+  // is also necessary because some minor languages can't be selected in the
+  // language preference even though the language is available in Translate
+  // server.
+  if (blocked && (is_accept_language || !can_be_accept_language))
+    return false;
 
   return true;
 }
 
 // static
 bool TranslatePrefs::ShouldAutoTranslate(PrefService* user_prefs,
     const std::string& original_language, std::string* target_language) {
   TranslatePrefs prefs(user_prefs);
   return prefs.IsLanguageWhitelisted(original_language, target_language);
 }
@@ skipping 60 matching lines @@
 
   // Get the union of the blacklist and the Accept languages, and set this to
   // the new language set 'translate_blocked_languages'. This is used for the
   // settings UI for Translate and configration to determine which langauage
   // should be translated instead of the blacklist. The blacklist is no longer
   // used after launching the settings UI.
   // After that, Set 'translate_languages_not_translate' to Accept languages to
   // enable settings for users.
   bool merged = user_prefs->HasPrefPath(kPrefTranslateBlockedLanguages);
 
-  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
-  bool enabled_translate_settings =
-      command_line.HasSwitch(switches::kEnableTranslateSettings);
-
-  if (!merged && enabled_translate_settings) {
+  if (!merged) {
     std::vector<std::string> blacklisted_languages;
     GetBlacklistedLanguages(user_prefs, &blacklisted_languages);
 
     std::string accept_languages_str =
         user_prefs->GetString(prefs::kAcceptLanguages);
     std::vector<std::string> accept_languages;
     base::SplitString(accept_languages_str, ',', &accept_languages);
 
     std::vector<std::string> blocked_languages;
     CreateBlockedLanguages(&blocked_languages,
@@ skipping 124 matching lines @@
 
 bool TranslatePrefs::IsListEmpty(const char* pref_id) const {
   const ListValue* blacklist = prefs_->GetList(pref_id);
   return (blacklist == NULL || blacklist->empty());
 }
 
 bool TranslatePrefs::IsDictionaryEmpty(const char* pref_id) const {
   const DictionaryValue* dict = prefs_->GetDictionary(pref_id);
   return (dict == NULL || dict->empty());
 }