Componentize TranslateManager

components/translate/core/browser/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 "components/translate/core/browser/translate_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.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/translate/translate_tab_helper.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 "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_language_list.h"
 #include "components/translate/core/browser/translate_prefs.h"
 #include "components/translate/core/browser/translate_script.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/web_contents.h"
 #include "net/base/url_util.h"
 #include "net/http/http_status_code.h"
 
-using content::WebContents;
-
 namespace {
 
 // Callbacks for translate errors.
 TranslateManager::TranslateErrorCallbackList* g_callback_list_ = NULL;
 
 const char kReportLanguageDetectionErrorURL[] =
     "https://translate.google.com/translate_error?client=cr&action=langidc";
 
 // Used in kReportLanguageDetectionErrorURL to specify the original page
 // language.
@@ skipping 17 matching lines @@
 // static
 scoped_ptr<TranslateManager::TranslateErrorCallbackList::Subscription>
 TranslateManager::RegisterTranslateErrorCallback(
     const TranslateManager::TranslateErrorCallback& callback) {
   if (!g_callback_list_)
     g_callback_list_ = new TranslateErrorCallbackList;
   return g_callback_list_->Add(callback);
 }
 
 TranslateManager::TranslateManager(
-    TranslateTabHelper* helper,
+    TranslateClient* translate_client,
     const std::string& accept_languages_pref_name)
     : accept_languages_pref_name_(accept_languages_pref_name),
-      translate_tab_helper_(helper),
-      translate_client_(helper),
+      translate_client_(translate_client),
       translate_driver_(translate_client_->GetTranslateDriver()),
       weak_method_factory_(this) {}
 
 void TranslateManager::InitiateTranslation(const std::string& page_lang) {
   // Short-circuit out if not in a state where initiating translation makes
   // sense (this method may be called muhtiple times for a given page).
   LanguageState& language_state = translate_driver_->GetLanguageState();
   if (!language_state.page_needs_translation() ||
       language_state.translation_pending() ||
       language_state.translation_declined() ||
@@ skipping 82 matching lines @@
     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.
   if (!translate_driver_->IsOffTheRecord()) {
-    std::string auto_target_lang = GetAutoTargetLanguage(language_code, prefs);
+    scoped_ptr<TranslatePrefs> translate_prefs =
+        translate_client_->GetTranslatePrefs();
+    std::string auto_target_lang =
+        GetAutoTargetLanguage(language_code, translate_prefs.get());
     if (!auto_target_lang.empty()) {
       TranslateBrowserMetrics::ReportInitiationStatus(
           TranslateBrowserMetrics::INITIATION_STATUS_AUTO_BY_CONFIG);
       TranslatePage(language_code, auto_target_lang, false);
       return;
     }
   }
 
   std::string auto_translate_to = language_state.AutoTranslateTo();
   if (!auto_translate_to.empty()) {
@@ skipping 59 matching lines @@
 }
 
 void TranslateManager::RevertTranslation() {
   translate_driver_->RevertTranslation();
   translate_driver_->GetLanguageState().SetCurrentLanguage(
       translate_driver_->GetLanguageState().original_language());
 }
 
 void TranslateManager::ReportLanguageDetectionError() {
   TranslateBrowserMetrics::ReportLanguageDetectionError();
-  // We'll open the URL in a new tab so that the user can tell us more.
-  WebContents* web_contents = translate_tab_helper_->GetWebContents();
-  Browser* browser = chrome::FindBrowserWithWebContents(web_contents);
-  if (!browser) {
-    NOTREACHED();
-    return;
-  }
 
   GURL report_error_url = GURL(kReportLanguageDetectionErrorURL);
 
   report_error_url =
       net::AppendQueryParameter(report_error_url,
                                 kUrlQueryName,
                                 translate_driver_->GetActiveURL().spec());
 
   report_error_url = net::AppendQueryParameter(
       report_error_url,
       kSourceLanguageQueryName,
       translate_driver_->GetLanguageState().original_language());
 
   report_error_url = TranslateURLUtil::AddHostLocaleToUrl(report_error_url);
   report_error_url = TranslateURLUtil::AddApiKeyToUrl(report_error_url);
 
-  chrome::AddSelectedTabWithURL(browser, report_error_url,
-                                content::PAGE_TRANSITION_AUTO_BOOKMARK);
+  translate_client_->ShowReportLanguageDetectionErrorUI(report_error_url);
 }
 
 void TranslateManager::DoTranslatePage(const std::string& translate_script,
                                        const std::string& source_lang,
                                        const std::string& target_lang) {
   translate_driver_->GetLanguageState().set_translation_pending(true);
   translate_driver_->TranslatePage(translate_script, source_lang, target_lang);
 }
 
 void TranslateManager::PageTranslated(const std::string& source_lang,
@@ skipping 77 matching lines @@
     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) {
+    TranslatePrefs* translate_prefs) {
   std::string auto_target_lang;
-  scoped_ptr<TranslatePrefs> translate_prefs(
-      TranslateTabHelper::CreateTranslatePrefs(prefs));
   if (translate_prefs->ShouldAutoTranslate(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 =
         TranslateDownloadManager::GetLanguageCode(auto_target_lang);
     if (TranslateDownloadManager::IsSupportedLanguage(auto_target_lang))
       return auto_target_lang;
   }
   return std::string();
 }