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) {
+  auto result = std::find_if(languages_.begin(), languages_.end(),

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

auto it = languages_.find(language_code);
return (it != languages_.end()) ? result - languages_.begin() : kNoIndex;

Per Chromium Style Guide, no else after return

https://chromium.googlesource.com/chromium/src/+/master/styleguide/c++/c++.md...

[jzw1, 2017/05/15 02:43:28]

Will .find be able to do it? Think I need to keep my find_if to check against
the contents of the language pair right?

[Hiroshi Ichikawa, 2017/05/15 03:25:34]

+1 to John. Note that it's a comparison against x.first, not x.

[Eugene But (OOO till 7-30), 2017/05/15 14:36:14]

map::iterator::fist is a key in std::map. map::find searches for a key and
returns map::iterator: http://www.cplusplus.com/reference/map/map/find/

What is the advantage of std::find_if over std::map::find when you searching by
key, not by value?

[Hiroshi Ichikawa, 2017/05/16 04:30:55]

|languages_| is a vector, not a map. So you cannot use map::find. I believe it's
a vector because it must be also accessed by an index?

[Eugene But (OOO till 7-30), 2017/05/16 15:28:38]

Sorry, if it's a vector, then |std::find(languages_.begin(), languages_.end(),
language_code);| should work.

+                             [&language_code](const LanguageNamePair& x) {
+                               return x.first == language_code;
+                             });
+  if (result != languages_.end()) {
+    return result - languages_.begin();
+  } else {
+    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/12 14:39:19]

Comments says that empty host is not allowed, but this code accepts and ignores
it.

[michaeldo, 2017/05/12 15:29:09]

To retain original behavior, you can move this early return to
|SetSiteBlacklist(bool value)| method. Then DCHECK in your
|SetSiteBlacklist(bool value, const std::string& page_host)| method.

[jzw1, 2017/05/15 02:43:28]

Should I just DCHECK(!page_host.empty())?

[michaeldo, 2017/05/15 17:09:30]

yes, that is fine here.

     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 {

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

Per Style Guide: no else after return please

[jzw1, 2017/05/15 02:43:28]

Done.

+    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