[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"
@@ skipping 200 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_client_->GetTranslatePrefs(), 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) {
+    translate_event_.set_source_language(source_lang);
+    translate_event_.set_target_language(target_lang);

[hamelphi, 2016/10/07 21:41:26]

Why not call InitTranslateEvent here?

[Roger McFarlane (Chromium), 2016/10/13 07:45:43]

Done.

+    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(
+    metrics::TranslateEventProto::EventType event_type) {
+  // TODO(rogerm): early exit for incognito?
+  translate_event_.set_event_type(event_type);
+  translate_event_.set_event_timestamp_sec(
+      (base::TimeTicks::Now() - base::TimeTicks()).InSeconds());
+  // TODO(rogerm): Finish writing me!
+}
+
 }  // namespace translate