Move TranslatePrefs to the Translate component

components/translate/core/browser/translate_prefs.h

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// Copyright 2010 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.
 
-#ifndef CHROME_BROWSER_TRANSLATE_TRANSLATE_PREFS_H_
-#define CHROME_BROWSER_TRANSLATE_TRANSLATE_PREFS_H_
+#ifndef COMPONENTS_TRANSLATE_CORE_BROWSER_TRANSLATE_PREFS_H_
+#define COMPONENTS_TRANSLATE_CORE_BROWSER_TRANSLATE_PREFS_H_
 
 #include <string>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "url/gurl.h"
 
 class PrefService;
 class Profile;
+class TranslateAcceptLanguages;
 
 namespace base {
 class DictionaryValue;
 class ListValue;
 }
 
 namespace user_prefs {
 class PrefRegistrySyncable;
 }
 
 // The wrapper of PrefService object for Translate.
 //
 // It is assumed that |prefs_| is alive while this instance is alive.
 class TranslatePrefs {
  public:
   static const char kPrefTranslateLanguageBlacklist[];
   static const char kPrefTranslateSiteBlacklist[];
   static const char kPrefTranslateWhitelists[];
   static const char kPrefTranslateDeniedCount[];
   static const char kPrefTranslateAcceptedCount[];
   static const char kPrefTranslateBlockedLanguages[];
 
-  explicit TranslatePrefs(PrefService* user_prefs);
+  TranslatePrefs(PrefService* user_prefs,
+#if defined(OS_CHROMEOS)

[MAD, 2014/02/13 03:11:11]

I don't really like this idea of a different signature on different platforms. I
would prefer we pass NULL on non-CrOS platforms, or have a second constructor
for CrOS...

[droger, 2014/02/13 09:38:39]

Done.

+                 const char* preferred_languages_pref,
+#endif
+                 const char* accept_languages_pref);
 
   // Resets the blocked languages list, the sites blacklist, the languages
   // whitelist, and the accepted/denied counts.
   void ResetToDefaults();
 
   bool IsBlockedLanguage(const std::string& original_language) const;
   void BlockLanguage(const std::string& original_language);
   void UnblockLanguage(const std::string& original_language);
 
-  // Removes a language from the old blacklist. This method is for
-  // chrome://translate-internals/.  Don't use this if there is no special
-  // reason.
+  // Removes a language from the old blacklist. Only used internally for
+  // diagnostics. Don't use this if there is no special reason.
   void RemoveLanguageFromLegacyBlacklist(const std::string& original_language);
 
   bool IsSiteBlacklisted(const std::string& site) const;
   void BlacklistSite(const std::string& site);
   void RemoveSiteFromBlacklist(const std::string& site);
 
   bool HasWhitelistedLanguagePairs() const;
 
   bool IsLanguagePairWhitelisted(const std::string& original_language,
-      const std::string& target_language);
+                                 const std::string& target_language);
   void WhitelistLanguagePair(const std::string& original_language,
-      const std::string& target_language);
+                             const std::string& target_language);
   void RemoveLanguagePairFromWhitelist(const std::string& original_language,
-      const std::string& target_language);
+                                       const std::string& target_language);
 
   // Will return true if at least one language has been blacklisted.
   bool HasBlockedLanguages() const;
 
   // Will return true if at least one site has been blacklisted.
   bool HasBlacklistedSites() const;
 
   // These methods are used to track how many times the user has denied the
   // translation for a specific language. (So we can present a UI to black-list
   // that language if the user keeps denying translations).
   int GetTranslationDeniedCount(const std::string& language) const;
   void IncrementTranslationDeniedCount(const std::string& language);
   void ResetTranslationDeniedCount(const std::string& language);
 
   // These methods are used to track how many times the user has accepted the
   // translation for a specific language. (So we can present a UI to white-list
   // that language if the user keeps accepting translations).
   int GetTranslationAcceptedCount(const std::string& language);
   void IncrementTranslationAcceptedCount(const std::string& language);
   void ResetTranslationAcceptedCount(const std::string& language);
 
-  // Sets the language list of chrome://settings/languages.
+  // Gets the language list of the language settings.
   void GetLanguageList(std::vector<std::string>* languages);
 
-  // Updates the language list of chrome://settings/languages.
+  // Updates the language list of the language settings.
   void UpdateLanguageList(const std::vector<std::string>& languages);
 
-  static bool CanTranslateLanguage(
-      Profile* profile, const std::string& language);
-  static bool ShouldAutoTranslate(PrefService* user_prefs,
-      const std::string& original_language, std::string* target_language);
+  bool CanTranslateLanguage(TranslateAcceptLanguages* accept_languages,
+                            const std::string& language);
+  bool ShouldAutoTranslate(const std::string& original_language,
+                           std::string* target_language);
   static void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry);
-  static void MigrateUserPrefs(PrefService* user_prefs);
+  static void MigrateUserPrefs(PrefService* user_prefs,
+                               const char* accept_languages_pref);
 
   // Converts the language code for Translate. This removes the sub code (like
   // -US) except for Chinese, and converts the synonyms.
   // The same logic exists at language_options.js, and please keep consistency
   // with the JavaScript file.
-  static std::string ConvertLangCodeForTranslation(const std::string &lang);
+  static std::string ConvertLangCodeForTranslation(const std::string& lang);
 
  private:
   friend class TranslatePrefsTest;
   FRIEND_TEST_ALL_PREFIXES(TranslatePrefsTest, CreateBlockedLanguages);
   FRIEND_TEST_ALL_PREFIXES(TranslatePrefsTest,
                            CreateBlockedLanguagesNonEnglishUI);
 
   // Merges two language sets to migrate to the language setting UI.
   static void CreateBlockedLanguages(
       std::vector<std::string>* blocked_languages,
       const std::vector<std::string>& blacklisted_languages,
       const std::vector<std::string>& accept_languages);
 
   void ClearBlockedLanguages();
   void ClearBlacklistedSites();
   void ClearWhitelistedLanguagePairs();
   bool IsValueBlacklisted(const char* pref_id, const std::string& value) const;
   void BlacklistValue(const char* pref_id, const std::string& value);
   void RemoveValueFromBlacklist(const char* pref_id, const std::string& value);
-  bool IsValueInList(
-      const base::ListValue* list, const std::string& value) const;
-  bool IsLanguageWhitelisted(const std::string& original_language,
-      std::string* target_language) const;
+  bool IsValueInList(const base::ListValue* list,
+                     const std::string& value) const;
   bool IsListEmpty(const char* pref_id) const;
   bool IsDictionaryEmpty(const char* pref_id) const;
 
+  // Path to the preference storing the accept languages.
+  const std::string accept_languages_pref_;
+#if defined(OS_CHROMEOS)
+  // Path to the preference storing the preferred languages.
+  // Only used on ChromeOS.
+  const std::string preferred_languages_pref_;
+#endif
+
   // Retrieves the dictionary mapping the number of times translation has been
   // denied for a language, creating it if necessary.
   base::DictionaryValue* GetTranslationDeniedCountDictionary();
 
   // Retrieves the dictionary mapping the number of times translation has been
   // accepted for a language, creating it if necessary.
   base::DictionaryValue* GetTranslationAcceptedCountDictionary() const;
 
   PrefService* prefs_;  // Weak.
 
   DISALLOW_COPY_AND_ASSIGN(TranslatePrefs);
 };
 
-#endif  // CHROME_BROWSER_TRANSLATE_TRANSLATE_PREFS_H_
+#endif  // COMPONENTS_TRANSLATE_CORE_BROWSER_TRANSLATE_PREFS_H_