Added translation policy API.

components/translate/core/browser/translate_ui_delegate.cc

Index: components/translate/core/browser/translate_ui_delegate.cc
diff --git a/components/translate/core/browser/translate_ui_delegate.cc b/components/translate/core/browser/translate_ui_delegate.cc
index 8a09121282aad8f1cb9e73f5011ac99e25c7d7ee..6b8944066ab77367e30106af5c362b443f59efc8 100644
--- a/components/translate/core/browser/translate_ui_delegate.cc
+++ b/components/translate/core/browser/translate_ui_delegate.cc
@@ -189,6 +189,15 @@ std::string TranslateUIDelegate::GetLanguageCodeAt(size_t index) const {
   return languages_[index].first;
 }
 
+size_t TranslateUIDelegate::GetLanguageIndex(const std::string& language_code) {
+  for (size_t i = 0; i < languages_.size(); ++i) {

[Eugene But (OOO till 7-30), 2017/05/11 15:48:58]

Do you want to use std::find instead?

[jzw1, 2017/05/12 03:46:45]

Can you check this for me? I'm not sure if it's 100% right.

+    if (languages_[i].first == language_code) {
+      return i;
+    }
+  }
+  return kNoIndex;
+}
+
 base::string16 TranslateUIDelegate::GetLanguageNameAt(size_t index) const {
   if (index == kNoIndex)
     return base::string16();
@@ -264,12 +273,21 @@ void TranslateUIDelegate::TranslationDeclined(bool explicitly_closed) {
 }
 
 bool TranslateUIDelegate::IsLanguageBlocked() {
-  return prefs_->IsBlockedLanguage(GetOriginalLanguageCode());
+  return IsLanguageBlocked(GetOriginalLanguageCode());
+}
+
+bool TranslateUIDelegate::IsLanguageBlocked(const std::string& language_code) {
+  return prefs_->IsBlockedLanguage(language_code);
 }
 
 void TranslateUIDelegate::SetLanguageBlocked(bool value) {
+  SetLanguageBlocked(value, GetOriginalLanguageCode());
+}
+
+void TranslateUIDelegate::SetLanguageBlocked(bool value,
+                                             const std::string& language_code) {
   if (value) {
-    prefs_->BlockLanguage(GetOriginalLanguageCode());
+    prefs_->BlockLanguage(language_code);
     if (translate_manager_) {
       translate_manager_->GetLanguageState().SetTranslateEnabled(false);
       // Translation has been blocked for this language. Capture that in the
@@ -279,24 +297,31 @@ void TranslateUIDelegate::SetLanguageBlocked(bool value) {
           metrics::TranslateEventProto::USER_NEVER_TRANSLATE_LANGUAGE);
     }
   } else {
-    prefs_->UnblockLanguage(GetOriginalLanguageCode());
+    prefs_->UnblockLanguage(language_code);
   }
 
   UMA_HISTOGRAM_BOOLEAN(kNeverTranslateLang, value);
 }
 
 bool TranslateUIDelegate::IsSiteBlacklisted() {
-  std::string host = GetPageHost();
-  return !host.empty() && prefs_->IsSiteBlacklisted(host);
+  return IsSiteBlacklisted(GetPageHost());
+}
+
+bool TranslateUIDelegate::IsSiteBlacklisted(const std::string& page_host) {
+  return !page_host.empty() && prefs_->IsSiteBlacklisted(page_host);
 }
 
 void TranslateUIDelegate::SetSiteBlacklist(bool value) {
-  std::string host = GetPageHost();
-  if (host.empty())
+  SetSiteBlacklist(value, GetPageHost());
+}
+
+void TranslateUIDelegate::SetSiteBlacklist(bool value,
+                                           const std::string& page_host) {
+  if (page_host.empty())

[Eugene But (OOO till 7-30), 2017/05/11 15:48:59]

Should this be DCHECK instead? Is it reasonable for clients to pass an empty
string?

[jzw1, 2017/05/12 03:46:45]

I just adapted the original implementation, so I'm not sure. 

[Eugene But (OOO till 7-30), 2017/05/12 14:39:19]

What would be the value to accept empty strings? The downside is potentially
hiding bugs.

     return;
 
   if (value) {
-    prefs_->BlacklistSite(host);
+    prefs_->BlacklistSite(page_host);
     if (translate_manager_) {
       translate_manager_->GetLanguageState().SetTranslateEnabled(false);
       // Translation has been blocked for this site. Capture that in the metrics
@@ -306,7 +331,7 @@ void TranslateUIDelegate::SetSiteBlacklist(bool value) {
           metrics::TranslateEventProto::USER_NEVER_TRANSLATE_SITE);
     }
   } else {
-    prefs_->RemoveSiteFromBlacklist(host);
+    prefs_->RemoveSiteFromBlacklist(page_host);
   }
 
   UMA_HISTOGRAM_BOOLEAN(kNeverTranslateSite, value);
@@ -317,6 +342,16 @@ bool TranslateUIDelegate::ShouldAlwaysTranslate() {
                                            GetTargetLanguageCode());
 }
 
+std::string TranslateUIDelegate::GetAlwaysTranslateToLanguage(
+    const std::string& from_language) {
+  std::string auto_target_lang;
+  if (prefs_->ShouldAutoTranslate(from_language, &auto_target_lang)) {
+    return auto_target_lang;
+  } else {
+    return std::string();
+  }
+}
+
 bool TranslateUIDelegate::ShouldAlwaysTranslateBeCheckedByDefault() {
   if (ShouldAlwaysTranslate())
     return true;
@@ -344,8 +379,14 @@ bool TranslateUIDelegate::ShouldAlwaysTranslateBeCheckedByDefault() {
 void TranslateUIDelegate::SetAlwaysTranslate(bool value) {
   const std::string& original_lang = GetOriginalLanguageCode();
   const std::string& target_lang = GetTargetLanguageCode();
+  SetAlwaysTranslate(value, original_lang, target_lang);
+}
+
+void TranslateUIDelegate::SetAlwaysTranslate(bool value,
+                                             const std::string& from_language,
+                                             const std::string& to_language) {
   if (value) {
-    prefs_->WhitelistLanguagePair(original_lang, target_lang);
+    prefs_->WhitelistLanguagePair(from_language, to_language);
     // A default translation mapping has been accepted for this language.
     // Capture that in the metrics. Note that we don't capture a language being
     // unmapped... which is not the same as accepting some other translation
@@ -355,7 +396,7 @@ void TranslateUIDelegate::SetAlwaysTranslate(bool value) {
           metrics::TranslateEventProto::USER_ALWAYS_TRANSLATE_LANGUAGE);
     }
   } else {
-    prefs_->RemoveLanguagePairFromWhitelist(original_lang, target_lang);
+    prefs_->RemoveLanguagePairFromWhitelist(from_language, to_language);
   }
 
   UMA_HISTOGRAM_BOOLEAN(kAlwaysTranslateLang, value);