Translate: Filter and record languages whose names Chrome doesn't show

chrome/browser/translate/translate_manager.cc

 // Copyright (c) 2012 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 "chrome/browser/translate/translate_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/language_state.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/translate/page_translated_details.h"
 #include "chrome/browser/translate/translate_accept_languages.h"
+#include "chrome/browser/translate/translate_browser_metrics.h"
 #include "chrome/browser/translate/translate_error_details.h"
 #include "chrome/browser/translate/translate_event_details.h"
 #include "chrome/browser/translate/translate_infobar_delegate.h"
 #include "chrome/browser/translate/translate_language_list.h"
-#include "chrome/browser/translate/translate_manager_metrics.h"
 #include "chrome/browser/translate/translate_prefs.h"
 #include "chrome/browser/translate/translate_tab_helper.h"
 #include "chrome/browser/translate/translate_url_util.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
@@ skipping 345 matching lines @@
   accept_languages_.reset(new TranslateAcceptLanguages);
 }
 
 void TranslateManager::InitiateTranslation(WebContents* web_contents,
                                            const std::string& page_lang) {
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   Profile* original_profile = profile->GetOriginalProfile();
   PrefService* prefs = original_profile->GetPrefs();
   if (!prefs->GetBoolean(prefs::kEnableTranslate)) {
-    TranslateManagerMetrics::ReportInitiationStatus(
-        TranslateManagerMetrics::INITIATION_STATUS_DISABLED_BY_PREFS);
+    TranslateBrowserMetrics::ReportInitiationStatus(
+        TranslateBrowserMetrics::INITIATION_STATUS_DISABLED_BY_PREFS);
     const std::string& locale = g_browser_process->GetApplicationLocale();
-    TranslateManagerMetrics::ReportLocalesOnDisabledByPrefs(locale);
+    TranslateBrowserMetrics::ReportLocalesOnDisabledByPrefs(locale);
     return;
   }
 
   // Allow disabling of translate from the command line to assist with
   // automated browser testing.
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDisableTranslate)) {
-    TranslateManagerMetrics::ReportInitiationStatus(
-        TranslateManagerMetrics::INITIATION_STATUS_DISABLED_BY_SWITCH);
+    TranslateBrowserMetrics::ReportInitiationStatus(
+        TranslateBrowserMetrics::INITIATION_STATUS_DISABLED_BY_SWITCH);
     return;
   }
 
   // Don't translate any Chrome specific page, e.g., New Tab Page, Download,
   // History, and so on.
   GURL page_url = web_contents->GetURL();
   if (!IsTranslatableURL(page_url)) {
-    TranslateManagerMetrics::ReportInitiationStatus(
-        TranslateManagerMetrics::INITIATION_STATUS_URL_IS_NOT_SUPPORTED);
+    TranslateBrowserMetrics::ReportInitiationStatus(
+        TranslateBrowserMetrics::INITIATION_STATUS_URL_IS_NOT_SUPPORTED);
     return;
   }
 
   // Don't translate similar languages (ex: en-US to en).
   std::string target_lang = GetTargetLanguage(prefs);
   std::string language_code = GetLanguageCode(page_lang);
   if (language_code == target_lang) {
-    TranslateManagerMetrics::ReportInitiationStatus(
-        TranslateManagerMetrics::INITIATION_STATUS_SIMILAR_LANGUAGES);
+    TranslateBrowserMetrics::ReportInitiationStatus(
+        TranslateBrowserMetrics::INITIATION_STATUS_SIMILAR_LANGUAGES);
     return;
   }
 
   // Don't translate any language the user configured as accepted languages.
   if (accept_languages_->IsAcceptLanguage(original_profile, language_code)) {
-    TranslateManagerMetrics::ReportInitiationStatus(
-        TranslateManagerMetrics::INITIATION_STATUS_ACCEPT_LANGUAGES);
+    TranslateBrowserMetrics::ReportInitiationStatus(
+        TranslateBrowserMetrics::INITIATION_STATUS_ACCEPT_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() || !IsSupportedLanguage(language_code)) {
-    TranslateManagerMetrics::ReportInitiationStatus(
-        TranslateManagerMetrics::INITIATION_STATUS_LANGUAGE_IS_NOT_SUPPORTED);
-    TranslateManagerMetrics::ReportUnsupportedLanguageAtInitiation(
+    TranslateBrowserMetrics::ReportInitiationStatus(
+        TranslateBrowserMetrics::INITIATION_STATUS_LANGUAGE_IS_NOT_SUPPORTED);
+    TranslateBrowserMetrics::ReportUnsupportedLanguageAtInitiation(
         language_code);
-
     return;
   }
 
   // Don't translate any user black-listed URLs or user selected language
   // combination.
   if (!TranslatePrefs::CanTranslate(prefs, language_code, page_url)) {
-    TranslateManagerMetrics::ReportInitiationStatus(
-        TranslateManagerMetrics::INITIATION_STATUS_DISABLED_BY_CONFIG);
+    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.
   std::string auto_target_lang;
   if (!web_contents->GetBrowserContext()->IsOffTheRecord() &&
       TranslatePrefs::ShouldAutoTranslate(prefs, language_code,
           &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 = GetLanguageCode(auto_target_lang);
     if (IsSupportedLanguage(auto_target_lang)) {
-      TranslateManagerMetrics::ReportInitiationStatus(
-          TranslateManagerMetrics::INITIATION_STATUS_AUTO_BY_CONFIG);
+      TranslateBrowserMetrics::ReportInitiationStatus(
+          TranslateBrowserMetrics::INITIATION_STATUS_AUTO_BY_CONFIG);
       TranslatePage(web_contents, language_code, auto_target_lang);
       return;
     }
   }
 
   TranslateTabHelper* translate_tab_helper =
       TranslateTabHelper::FromWebContents(web_contents);
   if (!translate_tab_helper)
     return;
 
   std::string auto_translate_to =
       translate_tab_helper->language_state().AutoTranslateTo();
   if (!auto_translate_to.empty()) {
     // This page was navigated through a click from a translated page.
-    TranslateManagerMetrics::ReportInitiationStatus(
-        TranslateManagerMetrics::INITIATION_STATUS_AUTO_BY_LINK);
+    TranslateBrowserMetrics::ReportInitiationStatus(
+        TranslateBrowserMetrics::INITIATION_STATUS_AUTO_BY_LINK);
     TranslatePage(web_contents, language_code, auto_translate_to);
     return;
   }
 
   // Prompts the user if he/she wants the page translated.
-  TranslateManagerMetrics::ReportInitiationStatus(
-      TranslateManagerMetrics::INITIATION_STATUS_SHOW_INFOBAR);
+  TranslateBrowserMetrics::ReportInitiationStatus(
+      TranslateBrowserMetrics::INITIATION_STATUS_SHOW_INFOBAR);
   TranslateInfoBarDelegate::Create(
       InfoBarService::FromWebContents(web_contents), false,
       TranslateInfoBarDelegate::BEFORE_TRANSLATE, TranslateErrors::NONE,
       profile->GetPrefs(), ShortcutConfig(),
       language_code, target_lang);
 }
 
 void TranslateManager::InitiateTranslationPosted(
     int process_id, int render_id, const std::string& page_lang, int attempt) {
   // The tab might have been closed.
@@ skipping 77 matching lines @@
   web_contents->GetRenderViewHost()->Send(new ChromeViewMsg_RevertTranslation(
       web_contents->GetRenderViewHost()->GetRoutingID(), entry->GetPageID()));
 
   TranslateTabHelper* translate_tab_helper =
       TranslateTabHelper::FromWebContents(web_contents);
   translate_tab_helper->language_state().set_current_language(
       translate_tab_helper->language_state().original_language());
 }
 
 void TranslateManager::ReportLanguageDetectionError(WebContents* web_contents) {
-  TranslateManagerMetrics::ReportLanguageDetectionError();
+  TranslateBrowserMetrics::ReportLanguageDetectionError();
   // We'll open the URL in a new tab so that the user can tell us more.
   Browser* browser = chrome::FindBrowserWithWebContents(web_contents);
   if (!browser) {
     NOTREACHED();
     return;
   }
 
   GURL report_error_url = GURL(kReportLanguageDetectionErrorURL);
 
   GURL page_url = web_contents->GetController().GetActiveEntry()->GetURL();
@@ skipping 35 matching lines @@
   web_contents->GetRenderViewHost()->Send(new ChromeViewMsg_TranslatePage(
       web_contents->GetRenderViewHost()->GetRoutingID(), entry->GetPageID(),
       translate_script, source_lang, target_lang));
 }
 
 void TranslateManager::PageTranslated(WebContents* web_contents,
                                       PageTranslatedDetails* details) {
   if ((details->error_type == TranslateErrors::NONE) &&
       details->source_language != chrome::kUnknownLanguageCode &&
       !IsSupportedLanguage(details->source_language)) {
-    // TODO(toyoshim): http://crbug.com/242142 We should check if
-    // l10n_util::GetDisplayNameForLocale() support |source_language| here.
-    // Also, following metrics should be modified to have language code.
-    TranslateManagerMetrics::ReportUnsupportedLanguage();
     details->error_type = TranslateErrors::UNSUPPORTED_LANGUAGE;
   }
 
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   PrefService* prefs = profile->GetPrefs();
   TranslateInfoBarDelegate::Create(
       InfoBarService::FromWebContents(web_contents), true,
       (details->error_type == TranslateErrors::NONE) ?
       TranslateInfoBarDelegate::AFTER_TRANSLATE :
@@ skipping 109 matching lines @@
   // reason so we are more aggressive showing the shortcuts for never translate.
   #if defined(OS_ANDROID)
   config.never_translate_min_count = 1;
   #else
   config.never_translate_min_count = 3;
   #endif  // defined(OS_ANDROID)
 
   config.always_translate_min_count = 3;
   return config;
 }