implement infobars and delegates placeholders for translate feature.

Review URL: http://codereview.chromium.org/546132

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@37281 0039d316-1c4b-4281-b951-d872f2087c98

8 files changed, 662 insertions, 0 deletions

diff --git a/chrome/browser/translate/languages_menu_model.cc b/chrome/browser/translate/languages_menu_model.cc
new file mode 100644
index 0000000..3f26d58
--- /dev/null
+++ b/chrome/browser/translate/languages_menu_model.cc
@@ -0,0 +1,33 @@
+// Copyright (c) 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.
+
+#include "chrome/browser/translate/languages_menu_model.h"
+
+#include "base/string_util.h"
+#include "chrome/app/chrome_dll_resource.h"
+#include "chrome/browser/translate/translate_infobars_delegates.h"
+
+LanguagesMenuModel::LanguagesMenuModel(
+    menus::SimpleMenuModel::Delegate* menu_delegate,
+    TranslateInfoBarDelegate* translate_delegate,
+    bool original_language)
+    : menus::SimpleMenuModel(menu_delegate) {
+  std::vector<std::string> languages;
+  int base_command_id = 0;
+  if (original_language) {
+    base_command_id = IDC_TRANSLATE_ORIGINAL_LANGUAGE_BASE;
+    translate_delegate->GetAvailableOriginalLanguages(&languages);
+  } else {
+    base_command_id = IDC_TRANSLATE_TARGET_LANGUAGE_BASE;
+    translate_delegate->GetAvailableTargetLanguages(&languages);
+  }
+  std::vector<std::string>::const_iterator iter = languages.begin();
+  for (int i = base_command_id; iter != languages.end(); ++i, ++iter) {
+    AddItem(i, ASCIIToUTF16(*iter));
+  }
+}
+
+LanguagesMenuModel::~LanguagesMenuModel() {
+}
+
diff --git a/chrome/browser/translate/languages_menu_model.h b/chrome/browser/translate/languages_menu_model.h
new file mode 100644
index 0000000..00780e9
--- /dev/null
+++ b/chrome/browser/translate/languages_menu_model.h
@@ -0,0 +1,24 @@
+// Copyright (c) 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_LANGUAGES_MENU_MODEL_H_
+#define CHROME_BROWSER_TRANSLATE_LANGUAGES_MENU_MODEL_H_
+
+#include "app/menus/simple_menu_model.h"
+
+class TranslateInfoBarDelegate;
+
+// A menu model that builds the contents of the language menus in the translate
+// infobar, i.e. the original and target languages.
+class LanguagesMenuModel : public menus::SimpleMenuModel {
+ public:
+  explicit LanguagesMenuModel(menus::SimpleMenuModel::Delegate* menu_delegate,
+      TranslateInfoBarDelegate* translate_delegate, bool original_language);
+  virtual ~LanguagesMenuModel();
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(LanguagesMenuModel);
+};
+
+#endif  // CHROME_BROWSER_TRANSLATE_LANGUAGES_MENU_MODEL_H_
diff --git a/chrome/browser/translate/options_menu_model.cc b/chrome/browser/translate/options_menu_model.cc
new file mode 100644
index 0000000..4dfd631
--- /dev/null
+++ b/chrome/browser/translate/options_menu_model.cc
@@ -0,0 +1,37 @@
+// Copyright (c) 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.
+
+#include "chrome/browser/translate/options_menu_model.h"
+
+#include "app/l10n_util.h"
+#include "chrome/app/chrome_dll_resource.h"
+#include "chrome/browser/translate/translate_infobars_delegates.h"
+#include "grit/generated_resources.h"
+
+OptionsMenuModel::OptionsMenuModel(menus::SimpleMenuModel::Delegate* delegate,
+    TranslateInfoBarDelegate* translate_delegate, bool before_translate)
+    : menus::SimpleMenuModel(delegate) {
+  string16 original_language =
+      ASCIIToUTF16(translate_delegate->original_language());
+  if (before_translate) {
+    AddCheckItem(IDC_TRANSLATE_OPTIONS_NEVER_TRANSLATE_LANG,
+        l10n_util::GetStringFUTF16(
+            IDS_TRANSLATE_INFOBAR_OPTIONS_NEVER_TRANSLATE_LANG,
+            original_language));
+    AddCheckItem(IDC_TRANSLATE_OPTIONS_NEVER_TRANSLATE_SITE,
+        l10n_util::GetStringUTF16(
+            IDS_TRANSLATE_INFOBAR_OPTIONS_NEVER_TRANSLATE_SITE));
+  } else {
+    AddCheckItem(IDC_TRANSLATE_OPTIONS_ALWAYS,
+        l10n_util::GetStringFUTF16(IDS_TRANSLATE_INFOBAR_OPTIONS_ALWAYS,
+            original_language,
+            ASCIIToUTF16(translate_delegate->target_language())));
+  }
+  AddItemWithStringId(IDC_TRANSLATE_OPTIONS_ABOUT,
+      IDS_TRANSLATE_INFOBAR_OPTIONS_ABOUT);
+}
+
+OptionsMenuModel::~OptionsMenuModel() {
+}
+
diff --git a/chrome/browser/translate/options_menu_model.h b/chrome/browser/translate/options_menu_model.h
new file mode 100644
index 0000000..e335059
--- /dev/null
+++ b/chrome/browser/translate/options_menu_model.h
@@ -0,0 +1,24 @@
+// Copyright (c) 2009 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_OPTIONS_MENU_MODEL_H_
+#define CHROME_BROWSER_TRANSLATE_OPTIONS_MENU_MODEL_H_
+
+#include "app/menus/simple_menu_model.h"
+
+class TranslateInfoBarDelegate;
+
+// A menu model that builds the contents of the options menu in the translate
+// infobar. This menu has only one level (no submenus).
+class OptionsMenuModel : public menus::SimpleMenuModel {
+ public:
+  explicit OptionsMenuModel(menus::SimpleMenuModel::Delegate* menu_delegate,
+      TranslateInfoBarDelegate* translate_delegate, bool before_translate);
+  virtual ~OptionsMenuModel();
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(OptionsMenuModel);
+};
+
+#endif  // CHROME_BROWSER_TRANSLATE_OPTIONS_MENU_MODEL_H_
diff --git a/chrome/browser/translate/translate_infobars_delegates.cc b/chrome/browser/translate/translate_infobars_delegates.cc
new file mode 100644
index 0000000..a80506f
--- /dev/null
+++ b/chrome/browser/translate/translate_infobars_delegates.cc
@@ -0,0 +1,214 @@
+// Copyright (c) 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.
+
+#include "chrome/browser/translate/translate_infobars_delegates.h"
+
+#include "app/l10n_util.h"
+#include "app/resource_bundle.h"
+#include "chrome/browser/tab_contents/tab_contents.h"
+#include "grit/generated_resources.h"
+#include "grit/theme_resources.h"
+
+// TranslateInfoBarDelegate: InfoBarDelegate overrides: ------------------------
+
+SkBitmap* TranslateInfoBarDelegate::GetIcon() const {
+  return ResourceBundle::GetSharedInstance().GetBitmapNamed(
+      IDR_INFOBAR_TRANSLATE);
+}
+
+bool TranslateInfoBarDelegate::EqualsDelegate(InfoBarDelegate* delegate) const {
+  TranslateInfoBarDelegate* translate_delegate =
+      delegate->AsTranslateInfoBarDelegate();
+  // There can be only 1 translate infobar at any one time.
+  return (!!translate_delegate);
+}
+
+void TranslateInfoBarDelegate::InfoBarClosed() {
+  delete this;
+}
+
+// TranslateInfoBarDelegate: public: -------------------------------------------
+
+void TranslateInfoBarDelegate::ModifyOriginalLanguage(
+    const std::string& original_language) {
+  original_language_ = original_language;
+  // TODO(kuan): Send stats to Google Translate that original language has been
+  // modified.
+}
+
+void TranslateInfoBarDelegate::ModifyTargetLanguage(
+    const std::string& target_language) {
+  NOTREACHED() << "Subclass should override";
+}
+
+void TranslateInfoBarDelegate::GetAvailableOriginalLanguages(
+    std::vector<std::string>* languages) {
+  // TODO(kuan): Call backend when it's ready; hardcode a list for now.
+  languages->push_back("Arabic");
+  languages->push_back("Bengali");
+  languages->push_back("Bulgarian");
+  languages->push_back("Chinese (Simplified Han)");
+  languages->push_back("Chinese (Traditional Han)");
+  languages->push_back("Croatian");
+  languages->push_back("Czech");
+  languages->push_back("Danish");
+  languages->push_back("Dutch");
+  languages->push_back("English");
+  languages->push_back("Estonian");
+  languages->push_back("Filipino");
+  languages->push_back("Finnish");
+  languages->push_back("French");
+  languages->push_back("German");
+  languages->push_back("Greek");
+  languages->push_back("Hebrew");
+  languages->push_back("Hindi");
+  languages->push_back("Hungarian");
+  languages->push_back("Indonesian");
+  languages->push_back("Italian");
+  languages->push_back("Japanese");
+  languages->push_back("Korean");
+  languages->push_back("Latvian");
+  languages->push_back("Lithuanian");
+  languages->push_back("Norwegian");
+  languages->push_back("Polish");
+  languages->push_back("Portuguese");
+  languages->push_back("Romanian");
+  languages->push_back("Russian");
+  languages->push_back("Serbian");
+  languages->push_back("Slovak");
+  languages->push_back("Slovenian");
+  languages->push_back("Spanish");
+  languages->push_back("Swedish");
+  languages->push_back("Tamil");
+  languages->push_back("Thai");
+  languages->push_back("Turkish");
+  languages->push_back("Ukrainian");
+  languages->push_back("Vietnamese");
+}
+
+void TranslateInfoBarDelegate::GetAvailableTargetLanguages(
+    std::vector<std::string>* languages) {
+  NOTREACHED() << "Subclass should override";
+}
+
+void TranslateInfoBarDelegate::Translate() {
+  // TODO(kuan): Call actual Translate method.
+/*
+  Translate(WideToUTF8(original_language()), WideToUTF8(target_language()));
+*/
+}
+
+bool TranslateInfoBarDelegate::IsLanguageBlacklisted() {
+  NOTREACHED() << "Subclass should override";
+  return false;
+}
+
+bool TranslateInfoBarDelegate::IsSiteBlacklisted() {
+  NOTREACHED() << "Subclass should override";
+  return false;
+}
+
+bool TranslateInfoBarDelegate::ShouldAlwaysTranslate() {
+  NOTREACHED() << "Subclass should override";
+  return false;
+}
+
+void TranslateInfoBarDelegate::ToggleLanguageBlacklist() {
+  NOTREACHED() << "Subclass should override";
+}
+
+void TranslateInfoBarDelegate::ToggleSiteBlacklist() {
+  NOTREACHED() << "Subclass should override";
+}
+
+void TranslateInfoBarDelegate::ToggleAlwaysTranslate() {
+  NOTREACHED() << "Subclass should override";
+}
+
+// TranslateInfoBarDelegate: protected: ----------------------------------------
+
+TranslateInfoBarDelegate::TranslateInfoBarDelegate(TabContents* tab_contents,
+    PrefService* user_prefs, const std::string& original_language,
+    const std::string& target_language)
+    : InfoBarDelegate(tab_contents),
+      tab_contents_(tab_contents),
+      original_language_(original_language),
+      target_language_(target_language),
+      prefs_(user_prefs) {
+}
+
+// BeforeTranslateInfoBarDelegate: public: -------------------------------------
+
+BeforeTranslateInfoBarDelegate::BeforeTranslateInfoBarDelegate(
+    TabContents* tab_contents, PrefService* user_prefs, const GURL& url,
+    const std::string& original_language, const std::string& target_language)
+    : TranslateInfoBarDelegate(tab_contents, user_prefs, original_language,
+          target_language),
+      site_(url.HostNoBrackets()),
+      never_translate_language_(false),
+      never_translate_site_(false) {
+}
+
+bool BeforeTranslateInfoBarDelegate::IsLanguageBlacklisted() {
+  never_translate_language_ =
+    prefs_.IsLanguageBlacklisted(original_language());
+  return never_translate_language_;
+}
+
+void BeforeTranslateInfoBarDelegate::ToggleLanguageBlacklist() {
+  never_translate_language_ = !never_translate_language_;
+  if (never_translate_language_)
+    prefs_.BlacklistLanguage(original_language());
+  else
+    prefs_.RemoveLanguageFromBlacklist(original_language());
+}
+
+bool BeforeTranslateInfoBarDelegate::IsSiteBlacklisted() {
+  never_translate_site_ = prefs_.IsSiteBlacklisted(site_);
+  return never_translate_site_;
+}
+
+void BeforeTranslateInfoBarDelegate::ToggleSiteBlacklist() {
+  never_translate_site_ = !never_translate_site_;
+  if (never_translate_site_)
+    prefs_.BlacklistSite(site_);
+  else
+    prefs_.RemoveSiteFromBlacklist(site_);
+}
+
+// AfterTranslateInfoBarDelegate: public: --------------------------------------
+
+AfterTranslateInfoBarDelegate::AfterTranslateInfoBarDelegate(
+    TabContents* tab_contents, PrefService* user_prefs,
+    const std::string& original_language, const std::string& target_language)
+    : TranslateInfoBarDelegate(tab_contents, user_prefs, original_language,
+          target_language),
+      always_translate_(false) {
+}
+
+void AfterTranslateInfoBarDelegate::GetAvailableTargetLanguages(
+    std::vector<std::string>* languages) {
+  // TODO(kuan): Call backend when it's ready; hardcode a list for now.
+  GetAvailableOriginalLanguages(languages);
+}
+
+void AfterTranslateInfoBarDelegate::ModifyTargetLanguage(
+    const std::string& target_language) {
+  target_language_ = target_language;
+}
+
+bool AfterTranslateInfoBarDelegate::ShouldAlwaysTranslate() {
+  always_translate_ = prefs_.IsLanguagePairWhitelisted(original_language(),
+      target_language());
+  return always_translate_;
+}
+
+void AfterTranslateInfoBarDelegate::ToggleAlwaysTranslate() {
+  always_translate_ = !always_translate_;
+  if (always_translate_)
+    prefs_.WhitelistLanguagePair(original_language(), target_language());
+  else
+    prefs_.RemoveLanguagePairFromWhitelist(original_language(),
+        target_language());
+}
diff --git a/chrome/browser/translate/translate_infobars_delegates.h b/chrome/browser/translate/translate_infobars_delegates.h
new file mode 100644
index 0000000..80bada0
--- /dev/null
+++ b/chrome/browser/translate/translate_infobars_delegates.h
@@ -0,0 +1,108 @@
+// Copyright (c) 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_INFOBARS_DELEGATES_H_
+#define CHROME_BROWSER_TRANSLATE_TRANSLATE_INFOBARS_DELEGATES_H_
+
+#include "chrome/browser/tab_contents/infobar_delegate.h"
+#include "chrome/browser/translate/translate_prefs.h"
+
+class SkBitmap;
+
+// An interface derived from InfoBarDelegate to form the base interface for
+// translate infobars.
+class TranslateInfoBarDelegate : public InfoBarDelegate {
+ public:
+  virtual void GetAvailableOriginalLanguages(
+      std::vector<std::string>* languages);
+  virtual void GetAvailableTargetLanguages(
+      std::vector<std::string>* languages);
+  virtual void ModifyOriginalLanguage(const std::string& original_language);
+  virtual void ModifyTargetLanguage(const std::string& target_language);
+  virtual void Translate();
+  virtual bool IsLanguageBlacklisted();
+  virtual void ToggleLanguageBlacklist();
+  virtual bool IsSiteBlacklisted();
+  virtual void ToggleSiteBlacklist();
+  virtual bool ShouldAlwaysTranslate();
+  virtual void ToggleAlwaysTranslate();
+
+  const std::string& original_language() const {
+    return original_language_;
+  }
+  const std::string& target_language() const {
+    return target_language_;
+  }
+  TabContents* tab_contents() const {
+    return tab_contents_;
+  }
+
+  // Overridden from InfoBarDelegate.
+  virtual Type GetInfoBarType() {
+    return PAGE_ACTION_TYPE;
+  }
+  virtual SkBitmap* GetIcon() const;
+  virtual bool EqualsDelegate(InfoBarDelegate* delegate) const;
+  virtual TranslateInfoBarDelegate* AsTranslateInfoBarDelegate() {
+    return this;
+  }
+  virtual void InfoBarClosed();
+
+ protected:
+  TranslateInfoBarDelegate(TabContents* contents, PrefService* user_prefs,
+      const std::string& original_language, const std::string& target_language);
+
+  TabContents* tab_contents_;  // Weak.
+  std::string original_language_;
+  std::string target_language_;
+  TranslatePrefs prefs_;
+
+  DISALLOW_COPY_AND_ASSIGN(TranslateInfoBarDelegate);
+};
+
+class BeforeTranslateInfoBarDelegate : public TranslateInfoBarDelegate {
+ public:
+  BeforeTranslateInfoBarDelegate(TabContents* contents, PrefService* user_prefs,
+      const GURL& url, const std::string& original_language,
+      const std::string& target_language);
+
+  // Overriden from TranslateInfoBarDelegate:
+  virtual bool IsLanguageBlacklisted();
+  virtual void ToggleLanguageBlacklist();
+  virtual bool IsSiteBlacklisted();
+  virtual void ToggleSiteBlacklist();
+
+  // Overridden from InfoBarDelegate:
+  virtual InfoBar* CreateInfoBar();
+
+ private:
+  std::string site_;
+  bool never_translate_language_;
+  bool never_translate_site_;
+
+  DISALLOW_COPY_AND_ASSIGN(BeforeTranslateInfoBarDelegate);
+};
+
+class AfterTranslateInfoBarDelegate : public TranslateInfoBarDelegate {
+ public:
+  AfterTranslateInfoBarDelegate(TabContents* contents, PrefService* user_prefs,
+      const std::string& original_language, const std::string& target_language);
+
+  // Overriden from TranslateInfoBar:
+  virtual void GetAvailableTargetLanguages(
+      std::vector<std::string>* languages);
+  virtual void ModifyTargetLanguage(const std::string& target_language);
+  virtual bool ShouldAlwaysTranslate();
+  virtual void ToggleAlwaysTranslate();
+
+  // Overridden from InfoBarDelegate:
+  virtual InfoBar* CreateInfoBar();
+
+ private:
+  bool always_translate_;
+
+  DISALLOW_COPY_AND_ASSIGN(AfterTranslateInfoBarDelegate);
+};
+
+#endif  // CHROME_BROWSER_TRANSLATE_TRANSLATE_INFOBARS_DELEGATES_H_
diff --git a/chrome/browser/translate/translate_prefs.cc b/chrome/browser/translate/translate_prefs.cc
new file mode 100644
index 0000000..ab69058
--- /dev/null
+++ b/chrome/browser/translate/translate_prefs.cc
@@ -0,0 +1,171 @@
+// Copyright (c) 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.
+
+#include "chrome/browser/translate/translate_prefs.h"
+
+#include "base/string_util.h"
+#include "chrome/common/pref_service.h"
+
+static const wchar_t kPrefTranslateLanguageBlacklist[] =
+    L"translate_language_blacklist";
+static const wchar_t kPrefTranslateSiteBlacklist[] =
+    L"translate_site_blacklist";
+static const wchar_t kPrefTranslateWhitelists[] = L"translate_whitelists";
+
+// TranslatePrefs: public: -----------------------------------------------------
+
+TranslatePrefs::TranslatePrefs(PrefService* user_prefs)
+    : prefs_(user_prefs) {
+  Register();
+}
+
+bool TranslatePrefs::IsLanguageBlacklisted(
+    const std::string& original_language) {
+  return IsValueBlacklisted(kPrefTranslateLanguageBlacklist, original_language);
+}
+
+void TranslatePrefs::BlacklistLanguage(const std::string& original_language) {
+  BlacklistValue(kPrefTranslateLanguageBlacklist, original_language);
+}
+
+void TranslatePrefs::RemoveLanguageFromBlacklist(
+    const std::string& original_language) {
+  RemoveValueFromBlacklist(kPrefTranslateLanguageBlacklist, original_language);
+}
+
+bool TranslatePrefs::IsSiteBlacklisted(const std::string& site) {
+  return IsValueBlacklisted(kPrefTranslateSiteBlacklist, site);
+}
+
+void TranslatePrefs::BlacklistSite(const std::string& site) {
+  BlacklistValue(kPrefTranslateSiteBlacklist, site);
+}
+
+void TranslatePrefs::RemoveSiteFromBlacklist(const std::string& site) {
+  RemoveValueFromBlacklist(kPrefTranslateSiteBlacklist, site);
+}
+
+bool TranslatePrefs::IsLanguagePairWhitelisted(
+    const std::string& original_language,
+    const std::string& target_language) {
+  const DictionaryValue* dict = prefs_->GetDictionary(kPrefTranslateWhitelists);
+  if (dict && !dict->empty()) {
+    ListValue* whitelist = NULL;
+    if (dict->GetList(ASCIIToWide(original_language), &whitelist) &&
+        whitelist && !whitelist->empty() &&
+        IsValueInList(whitelist, target_language))
+      return true;
+  }
+  return false;
+}
+
+void TranslatePrefs::WhitelistLanguagePair(
+    const std::string& original_language,
+    const std::string& target_language) {
+  DictionaryValue* dict = prefs_->GetMutableDictionary(
+      kPrefTranslateWhitelists);
+  if (!dict) {
+    NOTREACHED() << "Unregistered translate whitelist pref";
+    return;
+  }
+  std::wstring wide_original(ASCIIToWide(original_language));
+  StringValue* language = new StringValue(target_language);
+  ListValue* whitelist = NULL;
+  if (dict->GetList(wide_original, &whitelist) && whitelist) {
+    whitelist->Append(language);
+  } else {
+    ListValue new_whitelist;
+    new_whitelist.Append(language);
+    dict->Set(wide_original, new_whitelist.DeepCopy());
+  }
+  prefs_->ScheduleSavePersistentPrefs();
+}
+
+void TranslatePrefs::RemoveLanguagePairFromWhitelist(
+    const std::string& original_language,
+    const std::string& target_language) {
+  DictionaryValue* dict = prefs_->GetMutableDictionary(
+      kPrefTranslateWhitelists);
+  if (!dict) {
+    NOTREACHED() << "Unregistered translate whitelist pref";
+    return;
+  }
+  ListValue* whitelist = NULL;
+  std::wstring wide_original(ASCIIToWide(original_language));
+  if (dict->GetList(wide_original, &whitelist) && whitelist) {
+    StringValue language(target_language);
+    if (whitelist->Remove(language) != -1) {
+      if (whitelist->empty())  // If list is empty, remove key from dict.
+        dict->Remove(wide_original, NULL);
+      prefs_->ScheduleSavePersistentPrefs();
+    }
+  }
+}
+
+// TranslatePrefs: static: -----------------------------------------------------
+
+bool TranslatePrefs::CanTranslate(PrefService* user_prefs,
+    const std::string& original_language, const GURL& url) {
+  TranslatePrefs prefs(user_prefs);
+  if (prefs.IsSiteBlacklisted(url.HostNoBrackets()))
+    return false;
+  return (!prefs.IsLanguageBlacklisted(original_language));
+}
+
+bool TranslatePrefs::ShouldAutoTranslate(PrefService* user_prefs,
+    const std::string& original_language,
+    const std::string& target_language) {
+  TranslatePrefs prefs(user_prefs);
+  return prefs.IsLanguagePairWhitelisted(original_language, target_language);
+}
+
+// TranslatePrefs: private: ----------------------------------------------------
+
+void TranslatePrefs::Register() {
+  if (!prefs_->FindPreference(kPrefTranslateLanguageBlacklist))
+    prefs_->RegisterListPref(kPrefTranslateLanguageBlacklist);
+  if (!prefs_->FindPreference(kPrefTranslateSiteBlacklist))
+    prefs_->RegisterListPref(kPrefTranslateSiteBlacklist);
+  if (!prefs_->FindPreference(kPrefTranslateWhitelists))
+    prefs_->RegisterDictionaryPref(kPrefTranslateWhitelists);
+}
+
+bool TranslatePrefs::IsValueInList(const ListValue* list,
+    const std::string& in_value) {
+  for (size_t i = 0; i < list->GetSize(); ++i) {
+    std::string value;
+    if (list->GetString(i, &value) && value == in_value)
+      return true;
+  }
+  return false;
+}
+
+bool TranslatePrefs::IsValueBlacklisted(const wchar_t* pref_id,
+    const std::string& value) {
+  const ListValue* blacklist = prefs_->GetList(pref_id);
+  return (blacklist && !blacklist->empty() && IsValueInList(blacklist, value));
+}
+
+void TranslatePrefs::BlacklistValue(const wchar_t* pref_id,
+    const std::string& value) {
+  ListValue* blacklist = prefs_->GetMutableList(pref_id);
+  if (!blacklist) {
+    NOTREACHED() << "Unregistered translate blacklist pref";
+    return;
+  }
+  blacklist->Append(new StringValue(value));
+  prefs_->ScheduleSavePersistentPrefs();
+}
+
+void TranslatePrefs::RemoveValueFromBlacklist(const wchar_t* pref_id,
+    const std::string& value) {
+  ListValue* blacklist = prefs_->GetMutableList(pref_id);
+  if (!blacklist) {
+    NOTREACHED() << "Unregistered translate blacklist pref";
+    return;
+  }
+  StringValue string_value(value);
+  if (blacklist->Remove(string_value) != -1)
+    prefs_->ScheduleSavePersistentPrefs();
+}
diff --git a/chrome/browser/translate/translate_prefs.h b/chrome/browser/translate/translate_prefs.h
new file mode 100644
index 0000000..542dacc
--- /dev/null
+++ b/chrome/browser/translate/translate_prefs.h
@@ -0,0 +1,51 @@
+// Copyright (c) 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_
+
+#include <vector>
+
+#include "googleurl/src/gurl.h"
+
+class ListValue;
+class PrefService;
+
+class TranslatePrefs {
+ public:
+  explicit TranslatePrefs(PrefService* user_prefs);
+
+  bool IsLanguageBlacklisted(const std::string& original_language);
+  void BlacklistLanguage(const std::string& original_language);
+  void RemoveLanguageFromBlacklist(const std::string& original_language);
+
+  bool IsSiteBlacklisted(const std::string& site);
+  void BlacklistSite(const std::string& site);
+  void RemoveSiteFromBlacklist(const std::string& site);
+
+  bool IsLanguagePairWhitelisted(const std::string& original_language,
+      const std::string& target_language);
+  void WhitelistLanguagePair(const std::string& original_language,
+      const std::string& target_language);
+  void RemoveLanguagePairFromWhitelist(const std::string& original_language,
+      const std::string& target_language);
+
+  static bool CanTranslate(PrefService* user_prefs,
+      const std::string& original_language, const GURL& url);
+  static bool ShouldAutoTranslate(PrefService* user_prefs,
+      const std::string& original_language,
+      const std::string& target_language);
+
+ private:
+  void Register();
+  bool IsValueBlacklisted(const wchar_t* pref_id, const std::string& value);
+  void BlacklistValue(const wchar_t* pref_id, const std::string& value);
+  void RemoveValueFromBlacklist(const wchar_t* pref_id,
+      const std::string& value);
+  bool IsValueInList(const ListValue* list, const std::string& value);
+
+  PrefService* prefs_;  // Weak.
+};
+
+#endif  // CHROME_BROWSER_TRANSLATE_TRANSLATE_PREFS_H_