Move TranslateLanguageList to the Translate component

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/memory/singleton.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/translate/translate_accept_languages.h"
 #include "chrome/browser/translate/translate_infobar_delegate.h"
-#include "chrome/browser/translate/translate_language_list.h"
 #include "chrome/browser/translate/translate_prefs.h"
 #include "chrome/browser/translate/translate_script.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/browser_window.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/translate/translate_bubble_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "components/translate/core/browser/language_state.h"
 #include "components/translate/core/browser/page_translated_details.h"
 #include "components/translate/core/browser/translate_browser_metrics.h"
+#include "components/translate/core/browser/translate_download_manager.h"
 #include "components/translate/core/browser/translate_error_details.h"
-#include "components/translate/core/browser/translate_event_details.h"
+#include "components/translate/core/browser/translate_language_list.h"
+#include "components/translate/core/browser/translate_url_util.h"
 #include "components/translate/core/common/language_detection_details.h"
 #include "components/translate/core/common/translate_constants.h"
+#include "components/translate/core/common/translate_pref_names.h"
+#include "components/translate/core/common/translate_switches.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
@@ skipping 51 matching lines @@
          !url.SchemeIs(chrome::kChromeUIScheme) &&
          !url.SchemeIs(chrome::kChromeDevToolsScheme) &&
 #if defined(OS_CHROMEOS)
          !(url.SchemeIs(extensions::kExtensionScheme) &&
            url.DomainIs(file_manager::kFileManagerAppId)) &&
 #endif
          !url.SchemeIs(content::kFtpScheme);
 }
 
 // static
-void TranslateManager::GetSupportedLanguages(
-    std::vector<std::string>* languages) {
-  if (GetInstance()->language_list_.get()) {
-    GetInstance()->language_list_->GetSupportedLanguages(languages);
-    return;
-  }
-  NOTREACHED();
-}
-
-// static
-base::Time TranslateManager::GetSupportedLanguagesLastUpdated() {
-  if (GetInstance()->language_list_.get()) {
-    return GetInstance()->language_list_->last_updated();
-  }
-  NOTREACHED();
-  return base::Time();
-}
-
-// static
-std::string TranslateManager::GetLanguageCode(
-    const std::string& chrome_locale) {
-  if (GetInstance()->language_list_.get())
-    return GetInstance()->language_list_->GetLanguageCode(chrome_locale);
-  NOTREACHED();
-  return chrome_locale;
-}
-
-// static
-bool TranslateManager::IsSupportedLanguage(const std::string& language) {
-  if (GetInstance()->language_list_.get())
-    return GetInstance()->language_list_->IsSupportedLanguage(language);
-  NOTREACHED();
-  return false;
-}
-
-// static
-bool TranslateManager::IsAlphaLanguage(const std::string& language) {
-  if (GetInstance()->language_list_.get())
-    return GetInstance()->language_list_->IsAlphaLanguage(language);
-  NOTREACHED();
-  return false;
-}
-
-// static
 bool TranslateManager::IsAcceptLanguage(Profile* profile,
                                         const std::string& language) {
   if (GetInstance()->accept_languages_.get()) {
     return GetInstance()->accept_languages_->IsAcceptLanguage(
         profile, language);
   }
   NOTREACHED();
   return false;
 }
 
@@ skipping 103 matching lines @@
 }
 
 void TranslateManager::AddObserver(Observer* obs) {
   observer_list_.AddObserver(obs);
 }
 
 void TranslateManager::RemoveObserver(Observer* obs) {
   observer_list_.RemoveObserver(obs);
 }
 
-void TranslateManager::NotifyTranslateEvent(
-    const TranslateEventDetails& details) {
-  FOR_EACH_OBSERVER(Observer, observer_list_, OnTranslateEvent(details));
-}
-
 void TranslateManager::NotifyLanguageDetection(
     const LanguageDetectionDetails& details) {
   FOR_EACH_OBSERVER(Observer, observer_list_, OnLanguageDetection(details));
 }
 
 void TranslateManager::NotifyTranslateError(
     const TranslateErrorDetails& details) {
   FOR_EACH_OBSERVER(Observer, observer_list_, OnTranslateError(details));
 }
 
 TranslateManager::TranslateManager()
   : max_reload_check_attempts_(kMaxTranslateLoadCheckAttempts),
     weak_method_factory_(this) {
   notification_registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
                               content::NotificationService::AllSources());
   notification_registrar_.Add(this,
                               chrome::NOTIFICATION_TAB_LANGUAGE_DETERMINED,
                               content::NotificationService::AllSources());
   notification_registrar_.Add(this, chrome::NOTIFICATION_PAGE_TRANSLATED,
                               content::NotificationService::AllSources());
-  language_list_.reset(new TranslateLanguageList);
   accept_languages_.reset(new TranslateAcceptLanguages);
   script_.reset(new TranslateScript);
 }
 
 void TranslateManager::InitiateTranslation(WebContents* web_contents,
                                            const std::string& page_lang) {
   TranslateTabHelper* translate_tab_helper =
       TranslateTabHelper::FromWebContents(web_contents);
   if (!translate_tab_helper)
     return;
 
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   Profile* original_profile = profile->GetOriginalProfile();
   PrefService* prefs = original_profile->GetPrefs();
   if (!prefs->GetBoolean(prefs::kEnableTranslate)) {
     TranslateBrowserMetrics::ReportInitiationStatus(
         TranslateBrowserMetrics::INITIATION_STATUS_DISABLED_BY_PREFS);
     const std::string& locale = g_browser_process->GetApplicationLocale();
     TranslateBrowserMetrics::ReportLocalesOnDisabledByPrefs(locale);
     return;
   }
 
   // Allow disabling of translate from the command line to assist with
   // automated browser testing.
   if (CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kDisableTranslate)) {
+          translate::switches::kDisableTranslate)) {
     TranslateBrowserMetrics::ReportInitiationStatus(
         TranslateBrowserMetrics::INITIATION_STATUS_DISABLED_BY_SWITCH);
     return;
   }
 
   // MHTML pages currently cannot be translated.
   // See bug: 217945.
   if (web_contents->GetContentsMimeType() == "multipart/related") {
     TranslateBrowserMetrics::ReportInitiationStatus(
         TranslateBrowserMetrics::INITIATION_STATUS_MIME_TYPE_IS_NOT_SUPPORTED);
     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)) {
     TranslateBrowserMetrics::ReportInitiationStatus(
         TranslateBrowserMetrics::INITIATION_STATUS_URL_IS_NOT_SUPPORTED);
     return;
   }
 
   std::string target_lang = GetTargetLanguage(prefs);
-  std::string language_code = GetLanguageCode(page_lang);
+  std::string language_code =
+      TranslateDownloadManager::GetLanguageCode(page_lang);
 
   // 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() || !IsSupportedLanguage(language_code)) {
+  if (target_lang.empty() ||
+      !TranslateDownloadManager::IsSupportedLanguage(language_code)) {
     TranslateBrowserMetrics::ReportInitiationStatus(
         TranslateBrowserMetrics::INITIATION_STATUS_LANGUAGE_IS_NOT_SUPPORTED);
     TranslateBrowserMetrics::ReportUnsupportedLanguageAtInitiation(
         language_code);
     return;
   }
 
   TranslatePrefs translate_prefs(prefs);
 
   // Don't translate any user black-listed languages.
@@ skipping 75 matching lines @@
   if ((web_contents->IsLoading()) && attempt < kMaxTranslateLoadCheckAttempts) {
     int backoff = attempt * max_reload_check_attempts_;
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE, base::Bind(&TranslateManager::InitiateTranslationPosted,
                               weak_method_factory_.GetWeakPtr(), process_id,
                               render_id, page_lang, ++attempt),
         base::TimeDelta::FromMilliseconds(backoff));
     return;
   }
 
-  InitiateTranslation(web_contents, GetLanguageCode(page_lang));
+  InitiateTranslation(web_contents,
+                      TranslateDownloadManager::GetLanguageCode(page_lang));
 }
 
 void TranslateManager::TranslatePage(WebContents* web_contents,
                                      const std::string& original_source_lang,
                                      const std::string& target_lang) {
   NavigationEntry* entry = web_contents->GetController().GetActiveEntry();
   if (!entry) {
     NOTREACHED();
     return;
   }
 
   // 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 (!IsSupportedLanguage(source_lang))
+  if (!TranslateDownloadManager::IsSupportedLanguage(source_lang))
     source_lang = std::string(translate::kUnknownLanguageCode);
 
   if (IsTranslateBubbleEnabled()) {
     ShowBubble(web_contents, TranslateBubbleModel::VIEW_STATE_TRANSLATING,
                TranslateErrors::NONE);
   } else {
     Profile* profile =
         Profile::FromBrowserContext(web_contents->GetBrowserContext());
     TranslateInfoBarDelegate::Create(
         true, web_contents, TranslateInfoBarDelegate::TRANSLATING, source_lang,
@@ skipping 100 matching lines @@
   translate_tab_helper->GetLanguageState().set_translation_pending(true);
   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 != translate::kUnknownLanguageCode &&
-      !IsSupportedLanguage(details->source_language)) {
+      !TranslateDownloadManager::IsSupportedLanguage(
+           details->source_language)) {
     details->error_type = TranslateErrors::UNSUPPORTED_LANGUAGE;
   }
 
   if (IsTranslateBubbleEnabled()) {
     TranslateBubbleModel::ViewState view_state =
         (details->error_type == TranslateErrors::NONE) ?
         TranslateBubbleModel::VIEW_STATE_AFTER_TRANSLATE :
         TranslateBubbleModel::VIEW_STATE_ERROR;
     ShowBubble(web_contents, view_state, details->error_type);
   } else {
@@ skipping 11 matching lines @@
   if (details->error_type != TranslateErrors::NONE &&
       !web_contents->GetBrowserContext()->IsOffTheRecord()) {
     TranslateErrorDetails error_details;
     error_details.time = base::Time::Now();
     error_details.url = web_contents->GetLastCommittedURL();
     error_details.error = details->error_type;
     NotifyTranslateError(error_details);
   }
 }
 
-void TranslateManager::FetchLanguageListFromTranslateServer(
-    PrefService* prefs) {
-  // We don't want to do this when translate is disabled.
-  DCHECK(prefs != NULL);
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kDisableTranslate) ||
-      (prefs != NULL && !prefs->GetBoolean(prefs::kEnableTranslate))) {
-    return;
-  }
-
-  if (language_list_.get())
-    language_list_->RequestLanguageList();
-  else
-    NOTREACHED();
-}
-
 void TranslateManager::CleanupPendingUlrFetcher() {
-  language_list_.reset();
   script_.reset();
 }
 
 void TranslateManager::OnTranslateScriptFetchComplete(
     bool success, const std::string& data) {
   std::vector<PendingRequest>::const_iterator iter;
   for (iter = pending_requests_.begin(); iter != pending_requests_.end();
        ++iter) {
     const PendingRequest& request = *iter;
     WebContents* web_contents =
@@ skipping 79 matching lines @@
 
   TranslateBubbleFactory::Show(browser->window(), web_contents, view_state,
                                error_type);
 #else
   NOTREACHED();
 #endif
 }
 
 // static
 std::string TranslateManager::GetTargetLanguage(PrefService* prefs) {
-  std::string ui_lang =
-      TranslatePrefs::ConvertLangCodeForTranslation(
-          GetLanguageCode(g_browser_process->GetApplicationLocale()));
+  std::string ui_lang = TranslatePrefs::ConvertLangCodeForTranslation(
+      TranslateDownloadManager::GetLanguageCode(
+          g_browser_process->GetApplicationLocale()));
 
-  if (IsSupportedLanguage(ui_lang))
+  if (TranslateDownloadManager::IsSupportedLanguage(ui_lang))
     return ui_lang;
 
   // Getting the accepted languages list
   std::string accept_langs_str = prefs->GetString(prefs::kAcceptLanguages);
 
   std::vector<std::string> accept_langs_list;
   base::SplitString(accept_langs_str, ',', &accept_langs_list);
 
   // Will translate to the first supported language on the Accepted Language
   // list or not at all if no such candidate exists
   std::vector<std::string>::iterator iter;
   for (iter = accept_langs_list.begin();
        iter != accept_langs_list.end(); ++iter) {
-    std::string lang_code = GetLanguageCode(*iter);
-    if (IsSupportedLanguage(lang_code))
+    std::string lang_code = TranslateDownloadManager::GetLanguageCode(*iter);
+    if (TranslateDownloadManager::IsSupportedLanguage(lang_code))
       return lang_code;
   }
   return std::string();
 }
 
 // static
 std::string TranslateManager::GetAutoTargetLanguage(
     const std::string& original_language,
     PrefService* prefs) {
   std::string auto_target_lang;
   if (TranslatePrefs::ShouldAutoTranslate(prefs, original_language,
                                           &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))
+    auto_target_lang =
+        TranslateDownloadManager::GetLanguageCode(auto_target_lang);
+    if (TranslateDownloadManager::IsSupportedLanguage(auto_target_lang))
       return auto_target_lang;
   }
   return std::string();
 }
 
 // static
 bool TranslateManager::IsTranslateBubbleEnabled() {
 #if defined(USE_AURA)
   return !use_infobar_;
 #elif defined(OS_MACOSX)
@@ skipping 19 matching lines @@
   // so we are more aggressive about showing the shortcut to 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;
 }