[Translate] Integrate TranslateEventProto UMA logging into TranslateManager.

components/translate/core/browser/translate_manager.cc

Index: components/translate/core/browser/translate_manager.cc
diff --git a/components/translate/core/browser/translate_manager.cc b/components/translate/core/browser/translate_manager.cc
index 17216867182c55de753171a1c1231dd765bbb587..86685b3f6bc14a3928ca0ab472d00491709a473c 100644
--- a/components/translate/core/browser/translate_manager.cc
+++ b/components/translate/core/browser/translate_manager.cc
@@ -218,6 +218,8 @@ void TranslateManager::InitiateTranslation(const std::string& page_lang) {
   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(
@@ -233,6 +235,7 @@ void TranslateManager::InitiateTranslation(const std::string& page_lang) {
         TranslateBrowserMetrics::INITIATION_STATUS_LANGUAGE_IS_NOT_SUPPORTED);
     TranslateBrowserMetrics::ReportUnsupportedLanguageAtInitiation(
         language_code);
+    RecordTranslateEvent(metrics::TranslateEventProto::UNSUPPORTED_LANGUAGE);
     return;
   }
 
@@ -243,6 +246,8 @@ void TranslateManager::InitiateTranslation(const std::string& page_lang) {
                                              language_code)) {
     TranslateBrowserMetrics::ReportInitiationStatus(
         TranslateBrowserMetrics::INITIATION_STATUS_DISABLED_BY_CONFIG);
+    RecordTranslateEvent(
+        metrics::TranslateEventProto::LANGUAGE_DISABLED_BY_USER_CONFIG);
     return;
   }
 
@@ -250,6 +255,8 @@ void TranslateManager::InitiateTranslation(const std::string& page_lang) {
   if (translate_prefs->IsSiteBlacklisted(page_url.HostNoBrackets())) {
     TranslateBrowserMetrics::ReportInitiationStatus(
         TranslateBrowserMetrics::INITIATION_STATUS_DISABLED_BY_CONFIG);
+    RecordTranslateEvent(
+        metrics::TranslateEventProto::URL_DISABLED_BY_USER_CONFIG);
     return;
   }
 
@@ -263,6 +270,9 @@ void TranslateManager::InitiateTranslation(const std::string& page_lang) {
     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;
     }
@@ -273,6 +283,9 @@ void TranslateManager::InitiateTranslation(const std::string& page_lang) {
     // 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;
   }
@@ -280,15 +293,24 @@ void TranslateManager::InitiateTranslation(const std::string& page_lang) {
   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;
     }
   }
@@ -341,6 +363,15 @@ void TranslateManager::TranslatePage(const std::string& 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,
@@ -366,6 +397,10 @@ void TranslateManager::TranslatePage(const std::string& original_source_lang,
 }
 
 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());
 }
@@ -541,4 +576,29 @@ 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