LanguageState should be owned by 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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
@@ skipping 55 matching lines @@
     g_callback_list_ = new TranslateErrorCallbackList;
   return g_callback_list_->Add(callback);
 }
 
 TranslateManager::TranslateManager(
     TranslateClient* translate_client,
     const std::string& accept_languages_pref_name)
     : accept_languages_pref_name_(accept_languages_pref_name),
       translate_client_(translate_client),
       translate_driver_(translate_client_->GetTranslateDriver()),
-      weak_method_factory_(this) {}
+      language_state_(translate_driver_),
+      weak_method_factory_(this) {
+}
 
 base::WeakPtr<TranslateManager> TranslateManager::GetWeakPtr() {
   return weak_method_factory_.GetWeakPtr();
 }
 
 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() ||
-      language_state.IsPageTranslated()) {
+  if (!language_state_.page_needs_translation() ||
+      language_state_.translation_pending() ||
+      language_state_.translation_declined() ||
+      language_state_.IsPageTranslated()) {
     return;
   }
 
   PrefService* prefs = translate_client_->GetPrefs();
   if (!prefs->GetBoolean(prefs::kEnableTranslate)) {
     TranslateBrowserMetrics::ReportInitiationStatus(
         TranslateBrowserMetrics::INITIATION_STATUS_DISABLED_BY_PREFS);
     const std::string& locale =
         TranslateDownloadManager::GetInstance()->application_locale();
     TranslateBrowserMetrics::ReportLocalesOnDisabledByPrefs(locale);
@@ skipping 83 matching lines @@
     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();
+  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);
     TranslatePage(language_code, auto_translate_to, false);
     return;
   }
 
   TranslateBrowserMetrics::ReportInitiationStatus(
       TranslateBrowserMetrics::INITIATION_STATUS_SHOW_INFOBAR);
@@ skipping 41 matching lines @@
   // script.  Once it is downloaded we'll do the translate.
   TranslateScript::RequestCallback callback = base::Bind(
       &TranslateManager::OnTranslateScriptFetchComplete, GetWeakPtr(),
       translate_driver_->GetCurrentPageID(), source_lang, target_lang);
 
   script->Request(callback);
 }
 
 void TranslateManager::RevertTranslation() {
   translate_driver_->RevertTranslation();
-  translate_driver_->GetLanguageState().SetCurrentLanguage(
-      translate_driver_->GetLanguageState().original_language());
+  language_state_.SetCurrentLanguage(language_state_.original_language());
 }
 
 void TranslateManager::ReportLanguageDetectionError() {
   TranslateBrowserMetrics::ReportLanguageDetectionError();
 
   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 =
+      net::AppendQueryParameter(report_error_url,
+                                kSourceLanguageQueryName,
+                                language_state_.original_language());
 
   report_error_url = TranslateURLUtil::AddHostLocaleToUrl(report_error_url);
   report_error_url = TranslateURLUtil::AddApiKeyToUrl(report_error_url);
 
   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);
+  language_state_.set_translation_pending(true);
   translate_driver_->TranslatePage(translate_script, source_lang, target_lang);
 }
 
 void TranslateManager::PageTranslated(const std::string& source_lang,
                                       const std::string& target_lang,
                                       TranslateErrors::Type error_type) {
-  translate_driver_->GetLanguageState().SetCurrentLanguage(target_lang);
-  translate_driver_->GetLanguageState().set_translation_pending(false);
+  language_state_.SetCurrentLanguage(target_lang);
+  language_state_.set_translation_pending(false);
 
   if ((error_type == TranslateErrors::NONE) &&
       source_lang != translate::kUnknownLanguageCode &&
       !TranslateDownloadManager::IsSupportedLanguage(source_lang)) {
     error_type = TranslateErrors::UNSUPPORTED_LANGUAGE;
   }
 
   translate_client_->ShowTranslateUI(translate::TRANSLATE_STEP_AFTER_TRANSLATE,
                                      source_lang,
                                      target_lang,
@@ skipping 76 matching lines @@
                                            &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();
 }
+
+LanguageState& TranslateManager::GetLanguageState() {
+  return language_state_;
+}