[Translate] Integrate TranslateEventProto UMA logging into TranslateManager.

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/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/profiler/scoped_tracker.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/metrics/proto/translate_event.pb.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"
@@ skipping 100 matching lines @@
 }
 
 TranslateManager::TranslateManager(
     TranslateClient* translate_client,
     const std::string& accept_languages_pref_name)
     : page_seq_no_(0),
       accept_languages_pref_name_(accept_languages_pref_name),
       translate_client_(translate_client),
       translate_driver_(translate_client_->GetTranslateDriver()),
       language_state_(translate_driver_),
+      translate_event_(base::MakeUnique<metrics::TranslateEventProto>()),
       weak_method_factory_(this) {
   if (TranslateRanker::IsEnabled())
     TranslateRanker::GetInstance()->FetchModelData();  // Asynchronous.
 }
 
 base::WeakPtr<TranslateManager> TranslateManager::GetWeakPtr() {
   return weak_method_factory_.GetWeakPtr();
 }
 
 void TranslateManager::InitiateTranslation(const std::string& page_lang) {
@@ skipping 63 matching lines @@
     return;
   }
 
   std::unique_ptr<TranslatePrefs> translate_prefs(
       translate_client_->GetTranslatePrefs());
 
   std::string target_lang = GetTargetLanguage(translate_prefs.get());
   std::string language_code =
       TranslateDownloadManager::GetLanguageCode(page_lang);
 
+  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;
   }
 
   // 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)) {
     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(
         TranslateBrowserMetrics::INITIATION_STATUS_DISABLED_BY_CONFIG);
+    RecordTranslateEvent(
+        metrics::TranslateEventProto::URL_DISABLED_BY_USER_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::string auto_target_lang =
         GetAutoTargetLanguage(language_code, translate_prefs.get());
     if (!auto_target_lang.empty()) {
       TranslateBrowserMetrics::ReportInitiationStatus(
           TranslateBrowserMetrics::INITIATION_STATUS_AUTO_BY_CONFIG);
+      translate_event_->set_modified_target_language(auto_target_lang);
+      RecordTranslateEvent(
+          metrics::TranslateEventProto::AUTOMATICALLY_TRANSLATED);
       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);
+    translate_event_->set_modified_target_language(auto_translate_to);
+    RecordTranslateEvent(
+        metrics::TranslateEventProto::AUTOMATICALLY_TRANSLATED);
     TranslatePage(language_code, auto_translate_to, false);
     return;
   }
 
   if (LanguageInULP(language_code)) {
     TranslateBrowserMetrics::ReportInitiationStatus(
         TranslateBrowserMetrics::INITIATION_STATUS_LANGUAGE_IN_ULP);
+    RecordTranslateEvent(metrics::TranslateEventProto::DISABLED_BY_PREF);
     return;
   }
 
   if (TranslateRanker::IsEnabled()) {
-    if (!TranslateRanker::GetInstance()->ShouldOfferTranslation(
-            *translate_client_->GetTranslatePrefs(), language_code,
-            target_lang)) {
+    TranslateRanker* translate_ranker = TranslateRanker::GetInstance();
+    bool 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(
+        should_offer_translation ? metrics::TranslateEventProto::SHOW
+                                 : metrics::TranslateEventProto::DONT_SHOW);
+    if (!should_offer_translation && TranslateRanker::IsEnforcementEnabled()) {
       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,
@@ skipping 32 matching lines @@
   }
 
   // Translation can be kicked by context menu against unsupported languages.
   // Unsupported language strings should be replaced with
   // kUnknownLanguageCode in order to send a translation request with enabling
   // server side auto language detection.
   std::string source_lang(original_source_lang);
   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);
 
   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);
 
   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(
@@ skipping 155 matching lines @@
   return language_state_;
 }
 
 bool TranslateManager::ignore_missing_key_for_testing_ = false;
 
 // static
 void TranslateManager::SetIgnoreMissingKeyForTesting(bool ignore) {
   ignore_missing_key_for_testing_ = ignore;
 }
 
+void TranslateManager::InitTranslateEvent(const std::string& src_lang,
+                                          const std::string& dst_lang,
+                                          const TranslatePrefs& prefs) {
+  translate_event_->Clear();
+  translate_event_->set_source_language(src_lang);
+  translate_event_->set_target_language(dst_lang);
+  translate_event_->set_accept_count(
+      prefs.GetTranslationAcceptedCount(src_lang));
+  translate_event_->set_decline_count(
+      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());
+  TranslateRanker::GetInstance()->RecordTranslateEvent(*translate_event_);
+}
+
 }  // namespace translate