Added translation policy API.

components/translate/core/browser/translate_ui_delegate.cc

 // Copyright 2014 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 "components/translate/core/browser/translate_ui_delegate.h"
 
 #include "base/i18n/string_compare.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "components/metrics/proto/translate_event.pb.h"
@@ skipping 171 matching lines @@
       return;
     }
   }
 }
 
 std::string TranslateUIDelegate::GetLanguageCodeAt(size_t index) const {
   DCHECK_LT(index, GetNumberOfLanguages());
   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();
   DCHECK_LT(index, GetNumberOfLanguages());
   return languages_[index].second;
 }
 
 std::string TranslateUIDelegate::GetOriginalLanguageCode() const {
   return (GetOriginalLanguageIndex() == kNoIndex)
              ? translate::kUnknownLanguageCode
@@ skipping 55 matching lines @@
   }
 
   if (explicitly_closed) {
     UMA_HISTOGRAM_BOOLEAN(kDeclineTranslate, true);
   } else {
     UMA_HISTOGRAM_BOOLEAN(kDeclineTranslateDismissUI, true);
   }
 }
 
 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
       // metrics. Note that we don't capture a language being unblocked... which
       // is not the same as accepting a given translation for this language.
       translate_manager_->RecordTranslateEvent(
           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
       // Note that we don't capture a language being unblocked... which is not
       // the same as accepting a given translation for this site.
       translate_manager_->RecordTranslateEvent(
           metrics::TranslateEventProto::USER_NEVER_TRANSLATE_SITE);
     }
   } else {
-    prefs_->RemoveSiteFromBlacklist(host);
+    prefs_->RemoveSiteFromBlacklist(page_host);
   }
 
   UMA_HISTOGRAM_BOOLEAN(kNeverTranslateSite, value);
 }
 
 bool TranslateUIDelegate::ShouldAlwaysTranslate() {
   return prefs_->IsLanguagePairWhitelisted(GetOriginalLanguageCode(),
                                            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;
 
   std::map<std::string, std::string> params;
   if (!variations::GetVariationParams(translate::kTranslateUI2016Q2TrialName,
                                       &params))
     return false;
   int threshold = 0;
   base::StringToInt(params[translate::kAlwaysTranslateOfferThreshold],
                     &threshold);
   if (threshold <= 0)
     return false;
 
   // After N clicks on Translate for the same language.
   // We check for == N instead of >= N because if the user translates with the
   // "Always do this?" on, then the next time the bubble won't show up.
   // The only chance the bubble will show up is after the user manually unchecks
   // "Always do this?". In that case, since it is after user explictly unchecks,
   // we should show as it as unchecked so we only check == N instead of >= N.
   return prefs_->GetTranslationAcceptedCount(GetOriginalLanguageCode()) ==
          threshold;
 }
 
 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
     // for this language.
     if (translate_manager_) {
       translate_manager_->RecordTranslateEvent(
           metrics::TranslateEventProto::USER_ALWAYS_TRANSLATE_LANGUAGE);
     }
   } else {
-    prefs_->RemoveLanguagePairFromWhitelist(original_lang, target_lang);
+    prefs_->RemoveLanguagePairFromWhitelist(from_language, to_language);
   }
 
   UMA_HISTOGRAM_BOOLEAN(kAlwaysTranslateLang, value);
 }
 
 std::string TranslateUIDelegate::GetPageHost() {
   if (!translate_driver_->HasCurrentPage())
     return std::string();
   return translate_driver_->GetLastCommittedURL().HostNoBrackets();
 }
 
 }  // namespace translate