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;

[groby-ooo-7-16, 2016/08/04 02:33:42]

Can we share the same defaults? Since they can be overridden for an experiment
anyways, I'm not sure we need to have separate constants.

[ftang, 2016/08/05 04:45:27]

No, we really cannot use the same threshold. These are two kind of different
decision and it will be very difficult to tune and figure the right threshold
later if we decide to combine them. Think about this- one set of the
(confidence/probability) threshold is for deciding which ONE language is likely
to be the user prefer to translate the page into, and the second one is to
decide which SET of languages that we would like to suppressed the showing the
Translate Bubble UI. It is likely we will choose the threshold more strict on
one but more relax on the other.

+
+//   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,
+                        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(translate_prefs.get(), 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 TranslatePrefs* translate_prefs,
+                                     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_prefs->GetReadingFromUserLanguageProfile(&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);
+  double probability_threshold =
+      GetDoubleFromMap(params, kTargetLanguageULPProbabilityThresholdName,
+                       kDefaultTargetLanguageULPProbabilityThreshold);
+  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();
+
+  for (const auto& it : reading) {

[groby-ooo-7-16, 2016/08/04 02:33:42]

Question: Isn't the list sorted by decreasing probability? In which case we can
just test the first element?

[ftang, 2016/08/05 04:45:27]

Done.
You are right, the for loop is needed before the normalization of the language
code. I forget to change it after that. Sorry.

+    if (it.second > probability_threshold)
+      return it.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