using ulp to improve TranslateManager GetTargetLanguage() and InitiateTranslation()

components/translate/core/browser/translate_manager.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_manager.h"
 
+#include <map>
+
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "components/prefs/pref_service.h"
 #include "components/translate/core/browser/language_state.h"
 #include "components/translate/core/browser/page_translated_details.h"
 #include "components/translate/core/browser/translate_accept_languages.h"
 #include "components/translate/core/browser/translate_browser_metrics.h"
 #include "components/translate/core/browser/translate_client.h"
 #include "components/translate/core/browser/translate_download_manager.h"
 #include "components/translate/core/browser/translate_driver.h"
 #include "components/translate/core/browser/translate_error_details.h"
 #include "components/translate/core/browser/translate_experiment.h"
 #include "components/translate/core/browser/translate_language_list.h"
 #include "components/translate/core/browser/translate_prefs.h"
 #include "components/translate/core/browser/translate_script.h"
 #include "components/translate/core/browser/translate_url_util.h"
 #include "components/translate/core/common/language_detection_details.h"
 #include "components/translate/core/common/translate_constants.h"
 #include "components/translate/core/common/translate_pref_names.h"
 #include "components/translate/core/common/translate_switches.h"
 #include "components/translate/core/common/translate_util.h"
+#include "components/variations/variations_associated_data.h"
 #include "google_apis/google_api_keys.h"
 #include "net/base/network_change_notifier.h"
 #include "net/base/url_util.h"
 #include "net/http/http_status_code.h"
 
 namespace translate {
 
+const base::Feature kTranslateLanguageByULP{"TranslateLanguageByULP",
+                                            base::FEATURE_DISABLED_BY_DEFAULT};
 namespace {
 
 // Callbacks for translate errors.
 TranslateManager::TranslateErrorCallbackList* g_callback_list_ = NULL;
 
 const char kReportLanguageDetectionErrorURL[] =
     "https://translate.google.com/translate_error?client=cr&action=langidc";
 
 // Used in kReportLanguageDetectionErrorURL to specify the original page
 // language.
 const char kSourceLanguageQueryName[] = "sl";
 
 // Used in kReportLanguageDetectionErrorURL to specify the page URL.
 const char kUrlQueryName[] = "u";
 
+// Name for params in config for considering ULP in GetTargetLanguage().
+const char kTargetLanguageULPConfidenceThresholdName[] =
+    "target_language_ulp_confidence_threshold";
+const char kTargetLanguageULPProbabilityThresholdName[] =
+    "target_language_ulp_probability_threshold";
+
+// Name for params in config for considering ULP in InitiateTranslation().
+const char kInitiateTranslationULPConfidenceThresholdName[] =
+    "initiate_translation_ulp_confidence_threshold";
+const char kInitiateTranslationULPProbabilityThresholdName[] =
+    "initiate_translation_ulp_probability_threshold";
+
+// Constants for considering ULP. These built-in constatants of default will be
+// override by the value in config params if present.
+//   Default constants for the GetTargetLanguage() function:
+//     The confidence threshold that we will consider to use the ULP
+//     "reading list".
+const double kDefaultTargetLanguageULPConfidenceThreshold = 0.7;
+//     The probability threshold that we will consider to use a language on
+//     ULP "reading list".
+const double kDefaultTargetLanguageULPProbabilityThreshold = 0.55;
+
+//   Default constants for the InitiateTranslation() function:
+//     The confidence threshold that we will consider to use the ULP
+//     "reading list".
+const double kDefaultInitiateTranslationULPConfidenceThreshold = 0.75;
+//     The probability threshold that we will consider to use a language on
+//     ULP "reading list".
+const double kDefaultInitiateTranslationULPProbabilityThreshold = 0.5;
+
+// Return the probability of the |language| in the |list|, or 0.0 if it is not
+// in
+// the |list|.
+double GetLanguageProbability(
+    const TranslatePrefs::LanguageAndProbabilityList& list,
+    const std::string language) {
+  for (const auto& it : list) {
+    if (language == it.first) {
+      return it.second;
+    }
+  }
+  return 0.0;
+}
+
+// Get a value from the |map| by |key| and return the converted double, if
+// failed
+// return the |default_value| instead.
+double GetDoubleFromMap(std::map<std::string, std::string>& map,

[Lei Zhang, 2016/11/17 07:03:28]

So "git cl lint" noticed this is being passed by non-const reference... map[key]
will actually created a new entry with the key |key| if it did not exist before.
Is that intentional? Not sure if this matters.

+                        const std::string& key,
+                        double default_value) {
+  double value = default_value;
+  return base::StringToDouble(map[key], &value) ? value : default_value;
+}
+
 }  // namespace
 
 TranslateManager::~TranslateManager() {}
 
 // static
 std::unique_ptr<TranslateManager::TranslateErrorCallbackList::Subscription>
 TranslateManager::RegisterTranslateErrorCallback(
     const TranslateManager::TranslateErrorCallback& callback) {
   if (!g_callback_list_)
     g_callback_list_ = new TranslateErrorCallbackList;
@@ skipping 117 matching lines @@
     TranslateBrowserMetrics::ReportInitiationStatus(
         TranslateBrowserMetrics::INITIATION_STATUS_DISABLED_BY_CONFIG);
     return;
   }
 
   // If the user has previously selected "always translate" for this language we
   // automatically translate.  Note that in incognito mode we disable that
   // feature; the user will get an infobar, so they can control whether the
   // page's text is sent to the translate server.
   if (!translate_driver_->IsOffTheRecord()) {
-    std::unique_ptr<TranslatePrefs> translate_prefs =
-        translate_client_->GetTranslatePrefs();
     std::string auto_target_lang =
         GetAutoTargetLanguage(language_code, translate_prefs.get());
     if (!auto_target_lang.empty()) {
       TranslateBrowserMetrics::ReportInitiationStatus(
           TranslateBrowserMetrics::INITIATION_STATUS_AUTO_BY_CONFIG);
       TranslatePage(language_code, auto_target_lang, false);
       return;
     }
   }
 
   std::string auto_translate_to = language_state_.AutoTranslateTo();
   if (!auto_translate_to.empty()) {
     // This page was navigated through a click from a translated page.
     TranslateBrowserMetrics::ReportInitiationStatus(
         TranslateBrowserMetrics::INITIATION_STATUS_AUTO_BY_LINK);
     TranslatePage(language_code, auto_translate_to, false);
     return;
   }
 
+  if (LanguageInULP(language_code)) {
+    TranslateBrowserMetrics::ReportInitiationStatus(
+        TranslateBrowserMetrics::INITIATION_STATUS_LANGUAGE_IN_ULP);
+    return;
+  }
+
   TranslateBrowserMetrics::ReportInitiationStatus(
       TranslateBrowserMetrics::INITIATION_STATUS_SHOW_INFOBAR);
 
   // Prompts the user if they want the page translated.
   translate_client_->ShowTranslateUI(translate::TRANSLATE_STEP_BEFORE_TRANSLATE,
                                      language_code,
                                      target_lang,
                                      TranslateErrors::NONE,
                                      false);
 }
 
+bool TranslateManager::LanguageInULP(const std::string& language) const {
+  if (!base::FeatureList::IsEnabled(kTranslateLanguageByULP))
+    return false;
+  std::map<std::string, std::string> params;
+  variations::GetVariationParamsByFeature(translate::kTranslateLanguageByULP,
+                                          &params);
+  // Check the language & probability on the reading list.
+  TranslatePrefs::LanguageAndProbabilityList reading;
+  if (translate_client_->GetTranslatePrefs()->GetReadingFromUserLanguageProfile(

[Lei Zhang, 2016/11/17 07:03:28]

nit: "if (eval) return true; return false" -> return eval;

+          &reading) >
+          GetDoubleFromMap(params,
+                           kInitiateTranslationULPConfidenceThresholdName,
+                           kDefaultInitiateTranslationULPConfidenceThreshold) &&
+      GetLanguageProbability(reading, language) >
+          GetDoubleFromMap(params,
+                           kInitiateTranslationULPProbabilityThresholdName,
+                           kDefaultInitiateTranslationULPProbabilityThreshold))
+    return true;
+  return false;
+}
+
 void TranslateManager::TranslatePage(const std::string& original_source_lang,
                                      const std::string& target_lang,
                                      bool triggered_from_menu) {
   if (!translate_driver_->HasCurrentPage()) {
     NOTREACHED();
     return;
   }
 
   // Translation can be kicked by context menu against unsupported languages.
   // Unsupported language strings should be replaced with
@@ skipping 114 matching lines @@
         source_lang,
         target_lang,
         TranslateErrors::NETWORK,
         false);
     NotifyTranslateError(TranslateErrors::NETWORK);
   }
 }
 
 // static
 std::string TranslateManager::GetTargetLanguage(const TranslatePrefs* prefs) {
-  std::string ui_lang = TranslateDownloadManager::GetLanguageCode(
-      TranslateDownloadManager::GetInstance()->application_locale());
-  translate::ToTranslateLanguageSynonym(&ui_lang);
+  std::string language;
 
-  TranslateExperiment::OverrideUiLanguage(prefs->GetCountry(), &ui_lang);
+  // Get the override UI language.
+  TranslateExperiment::OverrideUiLanguage(prefs->GetCountry(), &language);
 
-  if (TranslateDownloadManager::IsSupportedLanguage(ui_lang))
-    return ui_lang;
+  // If there are no override.
+  if (language.empty()) {
+    // Get the language from ULP.
+    language = TranslateManager::GetTargetLanguageFromULP(prefs);
+    if (!language.empty())
+      return language;
+
+    // Get the browser's user interface language.
+    language = TranslateDownloadManager::GetLanguageCode(
+        TranslateDownloadManager::GetInstance()->application_locale());
+  }
+  if (TranslateDownloadManager::IsSupportedLanguage(language))
+    return language;
 
   // Will translate to the first supported language on the Accepted Language
   // list or not at all if no such candidate exists.
   std::vector<std::string> accept_languages_list;
   prefs->GetLanguageList(&accept_languages_list);
   for (const auto& lang : accept_languages_list) {
     std::string lang_code = TranslateDownloadManager::GetLanguageCode(lang);
     if (TranslateDownloadManager::IsSupportedLanguage(lang_code))
       return lang_code;
   }
   return std::string();
 }
 
 // static
+std::string TranslateManager::GetTargetLanguageFromULP(
+    const TranslatePrefs* prefs) {
+  if (!base::FeatureList::IsEnabled(kTranslateLanguageByULP))
+    return std::string();
+  std::map<std::string, std::string> params;
+  variations::GetVariationParamsByFeature(translate::kTranslateLanguageByULP,
+                                          &params);
+  TranslatePrefs::LanguageAndProbabilityList reading;
+  // We only consider ULP if the confidence is greater than the threshold.
+  if (prefs->GetReadingFromUserLanguageProfile(&reading) <=
+      GetDoubleFromMap(params, kTargetLanguageULPConfidenceThresholdName,
+                       kDefaultTargetLanguageULPConfidenceThreshold))
+    return std::string();
+
+  if (reading.size() > 0 &&

[Lei Zhang, 2016/11/17 07:03:28]

nit: !reading.empty() is a wee bit shorter

+      reading[0].second >
+          GetDoubleFromMap(params, kTargetLanguageULPProbabilityThresholdName,
+                           kDefaultTargetLanguageULPProbabilityThreshold))
+    return reading[0].first;
+  return std::string();
+}
+
+// static
 std::string TranslateManager::GetAutoTargetLanguage(
     const std::string& original_language,
     TranslatePrefs* translate_prefs) {
   std::string auto_target_lang;
   if (translate_prefs->ShouldAutoTranslate(original_language,
                                            &auto_target_lang)) {
     // We need to confirm that the saved target language is still supported.
     // Also, GetLanguageCode will take care of removing country code if any.
     auto_target_lang =
         TranslateDownloadManager::GetLanguageCode(auto_target_lang);
     if (TranslateDownloadManager::IsSupportedLanguage(auto_target_lang))
       return auto_target_lang;
   }
   return std::string();
 }
 
 LanguageState& TranslateManager::GetLanguageState() {
   return language_state_;
 }
 
 bool TranslateManager::ignore_missing_key_for_testing_ = false;
 
 // static
 void TranslateManager::SetIgnoreMissingKeyForTesting(bool ignore) {
   ignore_missing_key_for_testing_ = ignore;
 }
 
 }  // namespace translate