Allow TranslateRanker to override decisions taken by heuristics.

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"
@@ skipping 147 matching lines @@
       language_state_.translation_declined() ||
       language_state_.IsPageTranslated()) {
     return;
   }
 
   // Also, skip if the connection is currently offline - initiation doesn't make
   // sense there, either.
   if (net::NetworkChangeNotifier::IsOffline())
     return;
 
-  if (!ignore_missing_key_for_testing_ &&
-      !::google_apis::HasKeysConfigured()) {
+  if (!ignore_missing_key_for_testing_ && !::google_apis::HasKeysConfigured()) {
     // Without an API key, translate won't work, so don't offer to translate
     // in the first place. Leave prefs::kEnableTranslate on, though, because
     // that settings syncs and we don't want to turn off translate everywhere
     // else.
     TranslateBrowserMetrics::ReportInitiationStatus(
         TranslateBrowserMetrics::INITIATION_STATUS_DISABLED_BY_KEY);
     return;
   }
 
   std::unique_ptr<TranslatePrefs> translate_prefs(
@@ skipping 41 matching lines @@
 
   InitTranslateEvent(language_code, target_lang, *translate_prefs);
 
   // Don't translate similar languages (ex: en-US to en).
   if (language_code == target_lang) {
     TranslateBrowserMetrics::ReportInitiationStatus(
         TranslateBrowserMetrics::INITIATION_STATUS_SIMILAR_LANGUAGES);
     return;
   }
 
-  bool ranker_should_offer_translation = true;
-  if (translate_ranker_->IsQueryEnabled() ||
-      translate_ranker_->IsEnforcementEnabled()) {
-    ranker_should_offer_translation = translate_ranker_->ShouldOfferTranslation(
-        *translate_prefs, language_code, target_lang);
-    translate_event_->set_ranker_request_timestamp_sec(
-        (base::TimeTicks::Now() - base::TimeTicks()).InSeconds());
-    translate_event_->set_ranker_version(translate_ranker_->GetModelVersion());
-    translate_event_->set_ranker_response(
-        ranker_should_offer_translation
-            ? metrics::TranslateEventProto::SHOW
-            : metrics::TranslateEventProto::DONT_SHOW);
-  }
+  // Querying the ranker now, but not exiting immediately so that we may log
+  // other potential suppression reasons.
+  bool should_offer_translation = translate_ranker_->ShouldOfferTranslation(
+      *translate_prefs, language_code, target_lang, translate_event_.get());
 
-  // Nothing to do if either the language Chrome is in or the language of the
-  // page is not supported by the translation server.
+  // Nothing to do if either the language Chrome is in or the language of
+  // the page is not supported by the translation server.
   if (target_lang.empty() ||
       !TranslateDownloadManager::IsSupportedLanguage(language_code)) {
     TranslateBrowserMetrics::ReportInitiationStatus(
         TranslateBrowserMetrics::INITIATION_STATUS_LANGUAGE_IS_NOT_SUPPORTED);
     TranslateBrowserMetrics::ReportUnsupportedLanguageAtInitiation(
         language_code);
     RecordTranslateEvent(metrics::TranslateEventProto::UNSUPPORTED_LANGUAGE);
     return;
   }
 
   TranslateAcceptLanguages* accept_languages =
       translate_client_->GetTranslateAcceptLanguages();
   // Don't translate any user black-listed languages.
-  if (!translate_prefs->CanTranslateLanguage(accept_languages,
-                                             language_code)) {
+  if (!translate_prefs->CanTranslateLanguage(accept_languages, language_code)) {
     TranslateBrowserMetrics::ReportInitiationStatus(
         TranslateBrowserMetrics::INITIATION_STATUS_DISABLED_BY_CONFIG);
     RecordTranslateEvent(
         metrics::TranslateEventProto::LANGUAGE_DISABLED_BY_USER_CONFIG);
     return;
   }
 
   // Don't translate any user black-listed URLs.
   if (translate_prefs->IsSiteBlacklisted(page_url.HostNoBrackets())) {
     TranslateBrowserMetrics::ReportInitiationStatus(
@@ skipping 33 matching lines @@
     return;
   }
 
   if (LanguageInULP(language_code)) {
     TranslateBrowserMetrics::ReportInitiationStatus(
         TranslateBrowserMetrics::INITIATION_STATUS_LANGUAGE_IN_ULP);
     RecordTranslateEvent(metrics::TranslateEventProto::LANGUAGE_IN_ULP);
     return;
   }
 
-  if (!ranker_should_offer_translation &&
-      translate_ranker_->IsEnforcementEnabled()) {
+  if (!should_offer_translation) {
     TranslateBrowserMetrics::ReportInitiationStatus(
         TranslateBrowserMetrics::INITIATION_STATUS_ABORTED_BY_RANKER);
     RecordTranslateEvent(metrics::TranslateEventProto::DISABLED_BY_RANKER);
     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);
+                                     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;
@@ skipping 26 matching lines @@
   if (!TranslateDownloadManager::IsSupportedLanguage(source_lang))
     source_lang = std::string(translate::kUnknownLanguageCode);
 
   // Capture the translate event if we were triggered from the menu.
   if (triggered_from_menu) {
     RecordTranslateEvent(
         metrics::TranslateEventProto::USER_CONTEXT_MENU_TRANSLATE);
   }
 
   // Trigger the "translating now" UI.
-  translate_client_->ShowTranslateUI(translate::TRANSLATE_STEP_TRANSLATING,
-                                     source_lang,
-                                     target_lang,
-                                     TranslateErrors::NONE,
-                                     triggered_from_menu);
+  translate_client_->ShowTranslateUI(
+      translate::TRANSLATE_STEP_TRANSLATING, source_lang, target_lang,
+      TranslateErrors::NONE, triggered_from_menu);
 
   TranslateScript* script = TranslateDownloadManager::GetInstance()->script();
   DCHECK(script != NULL);
 
   const std::string& script_data = script->data();
   if (!script_data.empty()) {
     DoTranslatePage(script_data, source_lang, target_lang);
     return;
   }
 
   // The script is not available yet.  Queue that request and query for the
   // script.  Once it is downloaded we'll do the translate.
-  TranslateScript::RequestCallback callback = base::Bind(
-      &TranslateManager::OnTranslateScriptFetchComplete, GetWeakPtr(),
-      source_lang, target_lang);
+  TranslateScript::RequestCallback callback =
+      base::Bind(&TranslateManager::OnTranslateScriptFetchComplete,
+                 GetWeakPtr(), source_lang, target_lang);
 
   script->Request(callback);
 }
 
 void TranslateManager::RevertTranslation() {
   // Capture the revert event in the translate metrics
   RecordTranslateEvent(metrics::TranslateEventProto::USER_REVERT);
 
   // Revert the translation.
   translate_driver_->RevertTranslation(page_seq_no_);
   language_state_.SetCurrentLanguage(language_state_.original_language());
 }
 
 void TranslateManager::ReportLanguageDetectionError() {
   TranslateBrowserMetrics::ReportLanguageDetectionError();
 
   GURL report_error_url = GURL(kReportLanguageDetectionErrorURL);
 
   report_error_url = net::AppendQueryParameter(
       report_error_url, kUrlQueryName,
       translate_driver_->GetLastCommittedURL().spec());
 
   report_error_url =
-      net::AppendQueryParameter(report_error_url,
-                                kSourceLanguageQueryName,
+      net::AppendQueryParameter(report_error_url, kSourceLanguageQueryName,
                                 language_state_.original_language());
 
   report_error_url = translate::AddHostLocaleToUrl(report_error_url);
   report_error_url = translate::AddApiKeyToUrl(report_error_url);
 
   translate_client_->ShowReportLanguageDetectionErrorUI(report_error_url);
 }
 
 void TranslateManager::DoTranslatePage(const std::string& translate_script,
                                        const std::string& source_lang,
                                        const std::string& target_lang) {
   language_state_.set_translation_pending(true);
-  translate_driver_->TranslatePage(
-      page_seq_no_, translate_script, source_lang, target_lang);
+  translate_driver_->TranslatePage(page_seq_no_, translate_script, source_lang,
+                                   target_lang);
 }
 
 // Notifies |g_callback_list_| of translate errors.
 void TranslateManager::NotifyTranslateError(TranslateErrors::Type error_type) {
   if (!g_callback_list_ || error_type == TranslateErrors::NONE ||
       translate_driver_->IsIncognito()) {
     return;
   }
 
   TranslateErrorDetails error_details;
   error_details.time = base::Time::Now();
   error_details.url = translate_driver_->GetLastCommittedURL();
   error_details.error = error_type;
   g_callback_list_->Notify(error_details);
 }
 
 void TranslateManager::PageTranslated(const std::string& source_lang,
                                       const std::string& target_lang,
                                       TranslateErrors::Type error_type) {
   language_state_.SetCurrentLanguage(target_lang);
   language_state_.set_translation_pending(false);
 
   if ((error_type == TranslateErrors::NONE) &&
       source_lang != translate::kUnknownLanguageCode &&
       !TranslateDownloadManager::IsSupportedLanguage(source_lang)) {
     error_type = TranslateErrors::UNSUPPORTED_LANGUAGE;
   }
 
   translate_client_->ShowTranslateUI(translate::TRANSLATE_STEP_AFTER_TRANSLATE,
-                                     source_lang,
-                                     target_lang,
-                                     error_type,
+                                     source_lang, target_lang, error_type,
                                      false);
   NotifyTranslateError(error_type);
 }
 
 void TranslateManager::OnTranslateScriptFetchComplete(
     const std::string& source_lang,
     const std::string& target_lang,
     bool success,
     const std::string& data) {
   if (!translate_driver_->HasCurrentPage())
     return;
 
   if (success) {
     // Translate the page.
     TranslateScript* translate_script =
         TranslateDownloadManager::GetInstance()->script();
     DCHECK(translate_script);
     DoTranslatePage(translate_script->data(), source_lang, target_lang);
   } else {
     translate_client_->ShowTranslateUI(
-        translate::TRANSLATE_STEP_TRANSLATE_ERROR,
-        source_lang,
-        target_lang,
-        TranslateErrors::NETWORK,
-        false);
+        translate::TRANSLATE_STEP_TRANSLATE_ERROR, source_lang, target_lang,
+        TranslateErrors::NETWORK, false);
     NotifyTranslateError(TranslateErrors::NETWORK);
   }
 }
 
 // static
 std::string TranslateManager::GetTargetLanguage(const TranslatePrefs* prefs) {
   std::string language;
 
   // Get the override UI language.
   TranslateExperiment::OverrideUiLanguage(prefs->GetCountry(), &language);
@@ skipping 90 matching lines @@
       prefs.GetTranslationDeniedCount(src_lang));
   translate_event_->set_ignore_count(
       prefs.GetTranslationIgnoredCount(src_lang));
   translate_event_->set_ranker_response(
       metrics::TranslateEventProto::NOT_QUERIED);
   translate_event_->set_event_type(metrics::TranslateEventProto::UNKNOWN);
   // TODO(rogerm): Populate the language list.
 }
 
 void TranslateManager::RecordTranslateEvent(int event_type) {
-  DCHECK(metrics::TranslateEventProto::EventType_IsValid(event_type));
-  translate_event_->set_event_type(
-      static_cast<metrics::TranslateEventProto::EventType>(event_type));
-  translate_event_->set_event_timestamp_sec(
-      (base::TimeTicks::Now() - base::TimeTicks()).InSeconds());
-  translate_ranker_->AddTranslateEvent(*translate_event_,
-                                       translate_driver_->GetVisibleURL());
+  translate_ranker_->RecordTranslateEvent(
+      event_type, translate_driver_->GetVisibleURL(), translate_event_.get());
+}
+
+bool TranslateManager::ShouldOverrideDecision(int event_type) {
+  return translate_ranker_->ShouldOverrideDecision(
+      event_type, translate_driver_->GetVisibleURL(), translate_event_.get());
+}
+
+bool TranslateManager::ShouldSuppressBubbleUI(
+    bool triggered_from_menu,
+    const std::string& source_language) {
+  // Suppress the UI if the user navigates to a page with
+  // the same language as the previous page. In the new UI,
+  // continue offering translation after the user navigates
+  // to another page.
+  language_state_.SetTranslateEnabled(true);
+  if (!base::FeatureList::IsEnabled(translate::kTranslateUI2016Q2) &&
+      !language_state_.HasLanguageChanged() &&
+      !ShouldOverrideDecision(
+          metrics::TranslateEventProto::MATCHES_PREVIOUS_LANGUAGE)) {
+    return true;
+  }
+
+  // Suppress the UI if the user denied translation for this language
+  // too often.
+  if (!triggered_from_menu &&
+      translate_client_->GetTranslatePrefs()->IsTooOftenDenied(
+          source_language) &&
+      !ShouldOverrideDecision(
+          metrics::TranslateEventProto::LANGUAGE_DISABLED_BY_AUTO_BLACKLIST)) {
+    return true;
+  }
+
+  return false;
 }
 
 }  // namespace translate