Move LanguageState 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/language_state.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_error_details.h"
 #include "components/translate/core/browser/translate_event_details.h"
 #include "components/translate/core/common/language_detection_details.h"
 #include "components/translate/core/common/translate_constants.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"
@@ skipping 147 matching lines @@
         return;
 
       // If the navigation happened while offline don't show the translate
       // bar since there will be nothing to translate.
       if (load_details->http_status_code == 0 ||
           load_details->http_status_code == net::HTTP_INTERNAL_SERVER_ERROR) {
         return;
       }
 
       if (!load_details->is_main_frame &&
-          translate_tab_helper->language_state().translation_declined()) {
+          translate_tab_helper->GetLanguageState().translation_declined()) {
         // Some sites (such as Google map) may trigger sub-frame navigations
         // when the user interacts with the page.  We don't want to show a new
         // infobar if the user already dismissed one in that case.
         return;
       }
       if (entry->GetTransitionType() != content::PAGE_TRANSITION_RELOAD &&
           load_details->type != content::NAVIGATION_TYPE_SAME_PAGE) {
         return;
       }
 
       // When doing a page reload, TAB_LANGUAGE_DETERMINED is not sent,
       // so the translation needs to be explicitly initiated, but only when the
       // page needs translation.
-      if (!translate_tab_helper->language_state().page_needs_translation())
+      if (!translate_tab_helper->GetLanguageState().page_needs_translation())
         return;
       // Note that we delay it as the TranslateManager gets this notification
       // before the WebContents and the WebContents processing might remove the
       // current infobars.  Since InitTranslation might add an infobar, it must
       // be done after that.
       base::MessageLoop::current()->PostTask(FROM_HERE,
           base::Bind(
               &TranslateManager::InitiateTranslationPosted,
               weak_method_factory_.GetWeakPtr(),
               controller->GetWebContents()->GetRenderProcessHost()->GetID(),
               controller->GetWebContents()->GetRenderViewHost()->GetRoutingID(),
-              translate_tab_helper->language_state().original_language(), 0));
+              translate_tab_helper->GetLanguageState().original_language(), 0));
       break;
     }
     case chrome::NOTIFICATION_TAB_LANGUAGE_DETERMINED: {
       const LanguageDetectionDetails* lang_det_details =
           content::Details<const LanguageDetectionDetails>(details).ptr();
 
       WebContents* tab = content::Source<WebContents>(source).ptr();
       if (!tab->GetBrowserContext()->IsOffTheRecord())
         NotifyLanguageDetection(*lang_det_details);
 
       // We may get this notifications multiple times.  Make sure to translate
       // only once.
       TranslateTabHelper* translate_tab_helper =
           TranslateTabHelper::FromWebContents(tab);
       if (!translate_tab_helper)
         return;
 
-      LanguageState& language_state = translate_tab_helper->language_state();
+      LanguageState& language_state = translate_tab_helper->GetLanguageState();
       if (language_state.page_needs_translation() &&
           !language_state.translation_pending() &&
           !language_state.translation_declined() &&
           !language_state.IsPageTranslated()) {
         std::string language = lang_det_details->adopted_language;
         InitiateTranslation(tab, language);
       }
       break;
     }
     case chrome::NOTIFICATION_PAGE_TRANSLATED: {
@@ skipping 137 matching lines @@
   if (!web_contents->GetBrowserContext()->IsOffTheRecord()) {
     std::string auto_target_lang = GetAutoTargetLanguage(language_code, prefs);
     if (!auto_target_lang.empty()) {
       TranslateBrowserMetrics::ReportInitiationStatus(
           TranslateBrowserMetrics::INITIATION_STATUS_AUTO_BY_CONFIG);
       TranslatePage(web_contents, language_code, auto_target_lang);
       return;
     }
   }
 
-  LanguageState& language_state = translate_tab_helper->language_state();
+  LanguageState& language_state = translate_tab_helper->GetLanguageState();
   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(web_contents, language_code, auto_translate_to);
     return;
   }
 
   TranslateBrowserMetrics::ReportInitiationStatus(
@@ skipping 20 matching lines @@
                                                  const std::string& page_lang,
                                                  int attempt) {
   // The tab might have been closed.
   WebContents* web_contents =
       tab_util::GetWebContentsByID(process_id, render_id);
   if (!web_contents)
     return;
 
   TranslateTabHelper* translate_tab_helper =
       TranslateTabHelper::FromWebContents(web_contents);
-  if (translate_tab_helper->language_state().translation_pending())
+  if (translate_tab_helper->GetLanguageState().translation_pending())
     return;
 
   // During a reload we need web content to be available before the
   // translate script is executed. Otherwise we will run the translate script on
   // an empty DOM which will fail. Therefore we wait a bit to see if the page
   // has finished.
   if ((web_contents->IsLoading()) && attempt < kMaxTranslateLoadCheckAttempts) {
     int backoff = attempt * max_reload_check_attempts_;
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE, base::Bind(&TranslateManager::InitiateTranslationPosted,
@@ skipping 66 matching lines @@
   NavigationEntry* entry = web_contents->GetController().GetActiveEntry();
   if (!entry) {
     NOTREACHED();
     return;
   }
   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().SetCurrentLanguage(
-      translate_tab_helper->language_state().original_language());
+  translate_tab_helper->GetLanguageState().SetCurrentLanguage(
+      translate_tab_helper->GetLanguageState().original_language());
 }
 
 void TranslateManager::ReportLanguageDetectionError(WebContents* web_contents) {
   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();
   report_error_url = net::AppendQueryParameter(
       report_error_url,
       kUrlQueryName,
       page_url.spec());
 
   TranslateTabHelper* translate_tab_helper =
       TranslateTabHelper::FromWebContents(web_contents);
   report_error_url = net::AppendQueryParameter(
       report_error_url,
       kSourceLanguageQueryName,
-      translate_tab_helper->language_state().original_language());
+      translate_tab_helper->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);
 }
 
 void TranslateManager::ClearTranslateScript() {
   if (script_.get() == NULL) {
@@ skipping 11 matching lines @@
   if (!entry) {
     NOTREACHED();
     return;
   }
 
   TranslateTabHelper* translate_tab_helper =
       TranslateTabHelper::FromWebContents(web_contents);
   if (!translate_tab_helper)
     return;
 
-  translate_tab_helper->language_state().set_translation_pending(true);
+  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)) {
@@ skipping 124 matching lines @@
       chrome::FindLastActiveWithHostDesktopType(browser->host_desktop_type())) {
     return;
   }
 
   // During auto-translating, the bubble should not be shown.
   if (view_state == TranslateBubbleModel::VIEW_STATE_TRANSLATING ||
       view_state == TranslateBubbleModel::VIEW_STATE_AFTER_TRANSLATE) {
     TranslateTabHelper* translate_tab_helper =
         TranslateTabHelper::FromWebContents(web_contents);
     if (!translate_tab_helper ||
-        translate_tab_helper->language_state().InTranslateNavigation()) {
+        translate_tab_helper->GetLanguageState().InTranslateNavigation()) {
       return;
     }
   }
 
   TranslateBubbleFactory::Show(browser->window(), web_contents, view_state,
                                error_type);
 #else
   NOTREACHED();
 #endif
 }
@@ skipping 61 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;
 }