TabContentsWrapper -> TabContents, part 32.

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/json/json_reader.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/infobars/infobar_tab_helper.h"
 #include "chrome/browser/prefs/pref_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_infobar_delegate.h"
 #include "chrome/browser/translate/translate_prefs.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/tab_contents/tab_contents_wrapper.h"
+#include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/translate_errors.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
@@ skipping 269 matching lines @@
       NavigationController* controller =
           content::Source<NavigationController>(source).ptr();
       content::LoadCommittedDetails* load_details =
           content::Details<content::LoadCommittedDetails>(details).ptr();
       NavigationEntry* entry = controller->GetActiveEntry();
       if (!entry) {
         NOTREACHED();
         return;
       }
 
-      TabContentsWrapper* wrapper =
-          TabContentsWrapper::GetCurrentWrapperForContents(
-              controller->GetWebContents());
-      if (!wrapper || !wrapper->translate_tab_helper())
+      TabContents* tab_contents =
+          TabContents::FromWebContents(controller->GetWebContents());
+      if (!tab_contents || !tab_contents->translate_tab_helper())
         return;
 
-      TranslateTabHelper* helper = wrapper->translate_tab_helper();
+      TranslateTabHelper* helper = tab_contents->translate_tab_helper();
       if (!load_details->is_main_frame &&
           helper->language_state().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;
@@ skipping 11 matching lines @@
               controller->GetWebContents()->GetRenderProcessHost()->GetID(),
               controller->GetWebContents()->
                   GetRenderViewHost()->GetRoutingID(),
               helper->language_state().original_language()));
       break;
     }
     case chrome::NOTIFICATION_TAB_LANGUAGE_DETERMINED: {
       WebContents* tab = content::Source<WebContents>(source).ptr();
       // We may get this notifications multiple times.  Make sure to translate
       // only once.
-      TabContentsWrapper* wrapper =
-          TabContentsWrapper::GetCurrentWrapperForContents(tab);
-      if (!wrapper || !wrapper->translate_tab_helper())
+      TabContents* tab_contents = TabContents::FromWebContents(tab);
+      if (!tab_contents || !tab_contents->translate_tab_helper())
         return;
 
       LanguageState& language_state =
-          wrapper->translate_tab_helper()->language_state();
+          tab_contents->translate_tab_helper()->language_state();
       if (language_state.page_translatable() &&
           !language_state.translation_pending() &&
           !language_state.translation_declined() &&
           !language_state.IsPageTranslated()) {
         std::string language = *(content::Details<std::string>(details).ptr());
         InitiateTranslation(tab, language);
       }
       break;
     }
     case chrome::NOTIFICATION_PAGE_TRANSLATED: {
@@ skipping 65 matching lines @@
       MessageLoop::current()->PostDelayedTask(FROM_HERE,
           base::Bind(&TranslateManager::ClearTranslateScript,
                      weak_method_factory_.GetWeakPtr()),
           translate_script_expiration_delay_);
     }
     // Process any pending requests.
     std::vector<PendingRequest>::const_iterator iter;
     for (iter = pending_requests_.begin(); iter != pending_requests_.end();
          ++iter) {
       const PendingRequest& request = *iter;
-      WebContents* tab = tab_util::GetWebContentsByID(request.render_process_id,
-                                                      request.render_view_id);
-      if (!tab) {
+      WebContents* web_contents =
+          tab_util::GetWebContentsByID(request.render_process_id,
+                                       request.render_view_id);
+      if (!web_contents) {
         // The tab went away while we were retrieving the script.
         continue;
       }
-      NavigationEntry* entry = tab->GetController().GetActiveEntry();
+      NavigationEntry* entry = web_contents->GetController().GetActiveEntry();
       if (!entry || entry->GetPageID() != request.page_id) {
         // We navigated away from the page the translation was triggered on.
         continue;
       }
 
       if (error) {
-        TabContentsWrapper* wrapper =
-            TabContentsWrapper::GetCurrentWrapperForContents(tab);
-        InfoBarTabHelper* infobar_helper = wrapper->infobar_tab_helper();
+        TabContents* tab_contents = TabContents::FromWebContents(web_contents);
+        InfoBarTabHelper* infobar_helper = tab_contents->infobar_tab_helper();
         ShowInfoBar(
-            tab, TranslateInfoBarDelegate::CreateErrorDelegate(
+            web_contents,
+            TranslateInfoBarDelegate::CreateErrorDelegate(
                 TranslateErrors::NETWORK,
                 infobar_helper,
-                wrapper->profile()->GetPrefs(),
+                tab_contents->profile()->GetPrefs(),
                 request.source_lang,
                 request.target_lang));
       } else {
         // Translate the page.
-        DoTranslatePage(tab, translate_script_,
+        DoTranslatePage(web_contents, translate_script_,
                         request.source_lang, request.target_lang);
       }
     }
     pending_requests_.clear();
   } else {  // if (translate_script_request_pending_.get() == source)
     scoped_ptr<const net::URLFetcher> delete_ptr(
         language_list_request_pending_.release());
     if (!error) {
       std::string data;
       source->GetResponseAsString(&data);
       SetSupportedLanguages(data);
     } else {
       VLOG(1) << "Failed to Fetch languages from: " << kLanguageListFetchURL;
     }
   }
 }
 
 // static
-bool TranslateManager::IsShowingTranslateInfobar(WebContents* tab) {
-  return GetTranslateInfoBarDelegate(tab) != NULL;
+bool TranslateManager::IsShowingTranslateInfobar(WebContents* web_contents) {
+  return GetTranslateInfoBarDelegate(web_contents) != NULL;
 }
 
 TranslateManager::TranslateManager()
     : ALLOW_THIS_IN_INITIALIZER_LIST(weak_method_factory_(this)),
       translate_script_expiration_delay_(
           base::TimeDelta::FromDays(kTranslateScriptExpirationDelayDays)) {
   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());
 }
 
-void TranslateManager::InitiateTranslation(WebContents* tab,
+void TranslateManager::InitiateTranslation(WebContents* web_contents,
                                            const std::string& page_lang) {
 #ifdef FILE_MANAGER_EXTENSION
-  const GURL& page_url = tab->GetURL();
+  const GURL& page_url = web_contents->GetURL();
   if (page_url.SchemeIs("chrome-extension") &&
       page_url.DomainIs(kFileBrowserDomain))
     return;
 #endif
 
-  Profile* profile = Profile::FromBrowserContext(tab->GetBrowserContext());
+  Profile* profile =
+      Profile::FromBrowserContext(web_contents->GetBrowserContext());
   PrefService* prefs = profile->GetOriginalProfile()->GetPrefs();
   if (!prefs->GetBoolean(prefs::kEnableTranslate))
     return;
 
   // Allow disabling of translate from the command line to assist with
   // automated browser testing.
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableTranslate))
     return;
 
-  NavigationEntry* entry = tab->GetController().GetActiveEntry();
+  NavigationEntry* entry = web_contents->GetController().GetActiveEntry();
   if (!entry) {
     // This can happen for popups created with window.open("").
     return;
   }
 
   // If there is already a translate infobar showing, don't show another one.
-  if (GetTranslateInfoBarDelegate(tab))
+  if (GetTranslateInfoBarDelegate(web_contents))
     return;
 
   std::string target_lang = GetTargetLanguage(prefs);
   std::string language_code = GetLanguageCode(page_lang);
   // 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)) {
     return;
   }
 
   // We don't want to translate:
   // - any Chrome specific page (New Tab Page, Download, History... pages).
   // - similar languages (ex: en-US to en).
   // - any user black-listed URLs or user selected language combination.
   // - any language the user configured as accepted languages.
   if (!IsTranslatableURL(entry->GetURL()) || language_code == target_lang ||
       !TranslatePrefs::CanTranslate(prefs, language_code, entry->GetURL()) ||
-      IsAcceptLanguage(tab, language_code)) {
+      IsAcceptLanguage(web_contents, language_code)) {
     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 (!tab->GetBrowserContext()->IsOffTheRecord() &&
+  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)) {
-      TranslatePage(tab, language_code, auto_target_lang);
+      TranslatePage(web_contents, language_code, auto_target_lang);
       return;
     }
   }
 
-  TabContentsWrapper* wrapper =
-      TabContentsWrapper::GetCurrentWrapperForContents(tab);
-  if (!wrapper || !wrapper->translate_tab_helper())
+  TabContents* tab_contents = TabContents::FromWebContents(web_contents);
+  if (!tab_contents || !tab_contents->translate_tab_helper())
     return;
 
-  TranslateTabHelper* helper = wrapper->translate_tab_helper();
+  TranslateTabHelper* helper = tab_contents->translate_tab_helper();
   std::string auto_translate_to = helper->language_state().AutoTranslateTo();
   if (!auto_translate_to.empty()) {
     // This page was navigated through a click from a translated page.
-    TranslatePage(tab, language_code, auto_translate_to);
+    TranslatePage(web_contents, language_code, auto_translate_to);
     return;
   }
 
-  InfoBarTabHelper* infobar_helper = wrapper->infobar_tab_helper();
+  InfoBarTabHelper* infobar_helper = tab_contents->infobar_tab_helper();
   // Prompts the user if he/she wants the page translated.
   infobar_helper->AddInfoBar(
       TranslateInfoBarDelegate::CreateDelegate(
           TranslateInfoBarDelegate::BEFORE_TRANSLATE, infobar_helper,
-          wrapper->profile()->GetPrefs(), language_code, target_lang));
+          tab_contents->profile()->GetPrefs(), language_code, target_lang));
 }
 
 void TranslateManager::InitiateTranslationPosted(
     int process_id, int render_id, const std::string& page_lang) {
   // The tab might have been closed.
-  WebContents* tab = tab_util::GetWebContentsByID(process_id, render_id);
-  if (!tab)
+  WebContents* web_contents =
+      tab_util::GetWebContentsByID(process_id, render_id);
+  if (!web_contents)
     return;
 
-  TranslateTabHelper* helper = TabContentsWrapper::GetCurrentWrapperForContents(
-      tab)->translate_tab_helper();
+  TranslateTabHelper* helper =
+      TabContents::FromWebContents(web_contents)->translate_tab_helper();
   if (helper->language_state().translation_pending())
     return;
 
-  InitiateTranslation(tab, GetLanguageCode(page_lang));
+  InitiateTranslation(web_contents, GetLanguageCode(page_lang));
 }
 
 void TranslateManager::TranslatePage(WebContents* web_contents,
                                      const std::string& source_lang,
                                      const std::string& target_lang) {
   NavigationEntry* entry = web_contents->GetController().GetActiveEntry();
   if (!entry) {
     NOTREACHED();
     return;
   }
 
-  TabContentsWrapper* wrapper =
-      TabContentsWrapper::GetCurrentWrapperForContents(web_contents);
-  InfoBarTabHelper* infobar_helper = wrapper->infobar_tab_helper();
+  TabContents* tab_contents = TabContents::FromWebContents(web_contents);
+  InfoBarTabHelper* infobar_helper = tab_contents->infobar_tab_helper();
   ShowInfoBar(web_contents, TranslateInfoBarDelegate::CreateDelegate(
       TranslateInfoBarDelegate::TRANSLATING, infobar_helper,
-      wrapper->profile()->GetPrefs(), source_lang, target_lang));
+      tab_contents->profile()->GetPrefs(), source_lang, target_lang));
 
   if (!translate_script_.empty()) {
     DoTranslatePage(web_contents, translate_script_, source_lang, target_lang);
     return;
   }
 
   // The script is not available yet.  Queue that request and query for the
   // script.  Once it is downloaded we'll do the translate.
   content::RenderViewHost* rvh = web_contents->GetRenderViewHost();
   PendingRequest request;
   request.render_process_id = rvh->GetProcess()->GetID();
   request.render_view_id = rvh->GetRoutingID();
   request.page_id = entry->GetPageID();
   request.source_lang = source_lang;
   request.target_lang = target_lang;
   pending_requests_.push_back(request);
   RequestTranslateScript();
 }
 
 void TranslateManager::RevertTranslation(WebContents* web_contents) {
   NavigationEntry* entry = web_contents->GetController().GetActiveEntry();
   if (!entry) {
     NOTREACHED();
     return;
   }
   web_contents->GetRenderViewHost()->Send(new ChromeViewMsg_RevertTranslation(
       web_contents->GetRenderViewHost()->GetRoutingID(), entry->GetPageID()));
 
-  TranslateTabHelper* helper = TabContentsWrapper::GetCurrentWrapperForContents(
-      web_contents)->translate_tab_helper();
+  TranslateTabHelper* helper =
+      TabContents::FromWebContents(web_contents)->translate_tab_helper();
   helper->language_state().set_current_language(
       helper->language_state().original_language());
 }
 
 void TranslateManager::ReportLanguageDetectionError(WebContents* web_contents) {
   UMA_HISTOGRAM_COUNTS("Translate.ReportLanguageDetectionError", 1);
   GURL page_url = web_contents->GetController().GetActiveEntry()->GetURL();
   // Report option should be disabled for secure URLs.
   DCHECK(!page_url.SchemeIsSecure());
   std::string report_error_url(kReportLanguageDetectionErrorURL);
   report_error_url += "?client=cr&action=langidc&u=";
   report_error_url += net::EscapeUrlEncodedData(page_url.spec(), true);
   report_error_url += "&sl=";
 
-  TranslateTabHelper* helper = TabContentsWrapper::GetCurrentWrapperForContents(
-      web_contents)->translate_tab_helper();
+  TranslateTabHelper* helper =
+      TabContents::FromWebContents(web_contents)->translate_tab_helper();
   report_error_url += helper->language_state().original_language();
   report_error_url += "&hl=";
   report_error_url +=
       GetLanguageCode(g_browser_process->GetApplicationLocale());
   // Open that URL in a new tab so that the user can tell us more.
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   Browser* browser = browser::FindLastActiveWithProfile(profile);
   if (!browser) {
     NOTREACHED();
     return;
   }
   browser->AddSelectedTabWithURL(GURL(report_error_url),
                                  content::PAGE_TRANSITION_AUTO_BOOKMARK);
 }
 
-void TranslateManager::DoTranslatePage(WebContents* tab,
+void TranslateManager::DoTranslatePage(WebContents* web_contents,
                                        const std::string& translate_script,
                                        const std::string& source_lang,
                                        const std::string& target_lang) {
-  NavigationEntry* entry = tab->GetController().GetActiveEntry();
+  NavigationEntry* entry = web_contents->GetController().GetActiveEntry();
   if (!entry) {
     NOTREACHED();
     return;
   }
 
-  TabContentsWrapper* wrapper =
-      TabContentsWrapper::GetCurrentWrapperForContents(tab);
-  if (!wrapper || !wrapper->translate_tab_helper())
+  TabContents* tab_contents = TabContents::FromWebContents(web_contents);
+  if (!tab_contents || !tab_contents->translate_tab_helper())
     return;
 
-  wrapper->translate_tab_helper()->language_state().set_translation_pending(
-      true);
-  tab->GetRenderViewHost()->Send(new ChromeViewMsg_TranslatePage(
-      tab->GetRenderViewHost()->GetRoutingID(), entry->GetPageID(),
+  tab_contents->translate_tab_helper()->
+      language_state().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* tab,
+void TranslateManager::PageTranslated(WebContents* web_contents,
                                       PageTranslatedDetails* details) {
-  TabContentsWrapper* wrapper =
-      TabContentsWrapper::GetCurrentWrapperForContents(tab);
-  InfoBarTabHelper* infobar_helper = wrapper->infobar_tab_helper();
-  PrefService* prefs = wrapper->profile()->GetPrefs();
+  TabContents* tab_contents = TabContents::FromWebContents(web_contents);
+  InfoBarTabHelper* infobar_helper = tab_contents->infobar_tab_helper();
+  PrefService* prefs = tab_contents->profile()->GetPrefs();
 
   // Create the new infobar to display.
   TranslateInfoBarDelegate* infobar;
   if (details->error_type != TranslateErrors::NONE) {
     infobar = TranslateInfoBarDelegate::CreateErrorDelegate(
         details->error_type,
         infobar_helper,
         prefs,
         details->source_language,
         details->target_language);
   } else if (!IsSupportedLanguage(details->source_language)) {
     // TODO(jcivelli): http://crbug.com/9390 We should change the "after
     //                 translate" infobar to support unknown as the original
     //                 language.
     UMA_HISTOGRAM_COUNTS("Translate.ServerReportedUnsupportedLanguage", 1);
     infobar = TranslateInfoBarDelegate::CreateErrorDelegate(
         TranslateErrors::UNSUPPORTED_LANGUAGE, infobar_helper,
         prefs, details->source_language, details->target_language);
   } else {
     infobar = TranslateInfoBarDelegate::CreateDelegate(
         TranslateInfoBarDelegate::AFTER_TRANSLATE, infobar_helper,
         prefs, details->source_language, details->target_language);
   }
-  ShowInfoBar(tab, infobar);
+  ShowInfoBar(web_contents, infobar);
 }
 
-bool TranslateManager::IsAcceptLanguage(WebContents* tab,
+bool TranslateManager::IsAcceptLanguage(WebContents* web_contents,
                                         const std::string& language) {
-  Profile* profile = Profile::FromBrowserContext(tab->GetBrowserContext());
+  Profile* profile =
+      Profile::FromBrowserContext(web_contents->GetBrowserContext());
   profile = profile->GetOriginalProfile();
   PrefService* pref_service = profile->GetPrefs();
   PrefServiceLanguagesMap::const_iterator iter =
       accept_languages_.find(pref_service);
   if (iter == accept_languages_.end()) {
     InitAcceptLanguages(pref_service);
     // Listen for this profile going away, in which case we would need to clear
     // the accepted languages for the profile.
     notification_registrar_.Add(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
                                 content::Source<Profile>(profile));
@@ skipping 84 matching lines @@
       0, GURL(translate_script_url), net::URLFetcher::GET, this));
   translate_script_request_pending_->SetLoadFlags(
       net::LOAD_DO_NOT_SEND_COOKIES | net::LOAD_DO_NOT_SAVE_COOKIES);
   translate_script_request_pending_->SetRequestContext(
       g_browser_process->system_request_context());
   translate_script_request_pending_->SetExtraRequestHeaders(
       kTranslateScriptHeader);
   translate_script_request_pending_->Start();
 }
 
-void TranslateManager::ShowInfoBar(content::WebContents* tab,
+void TranslateManager::ShowInfoBar(content::WebContents* web_contents,
                                    TranslateInfoBarDelegate* infobar) {
   DCHECK(infobar != NULL);
-  TranslateInfoBarDelegate* old_infobar = GetTranslateInfoBarDelegate(tab);
+  TranslateInfoBarDelegate* old_infobar =
+      GetTranslateInfoBarDelegate(web_contents);
   infobar->UpdateBackgroundAnimation(old_infobar);
-  TabContentsWrapper* wrapper =
-      TabContentsWrapper::GetCurrentWrapperForContents(tab);
-  if (!wrapper)
+  TabContents* tab_contents = TabContents::FromWebContents(web_contents);
+  if (!tab_contents)
     return;
-  InfoBarTabHelper* infobar_helper = wrapper->infobar_tab_helper();
+  InfoBarTabHelper* infobar_helper = tab_contents->infobar_tab_helper();
   if (old_infobar) {
     // There already is a translate infobar, simply replace it.
     infobar_helper->ReplaceInfoBar(old_infobar, infobar);
   } else {
     infobar_helper->AddInfoBar(infobar);
   }
 }
 
 // static
 std::string TranslateManager::GetTargetLanguage(PrefService* prefs) {
@@ skipping 15 matching lines @@
        iter != accept_langs_list.end(); ++iter) {
     std::string lang_code = GetLanguageCode(*iter);
     if (IsSupportedLanguage(lang_code))
       return lang_code;
   }
   return std::string();
 }
 
 // static
 TranslateInfoBarDelegate* TranslateManager::GetTranslateInfoBarDelegate(
-    WebContents* tab) {
-  TabContentsWrapper* wrapper =
-      TabContentsWrapper::GetCurrentWrapperForContents(tab);
-  if (!wrapper)
+    WebContents* web_contents) {
+  TabContents* tab_contents = TabContents::FromWebContents(web_contents);
+  if (!tab_contents)
     return NULL;
-  InfoBarTabHelper* infobar_helper = wrapper->infobar_tab_helper();
+  InfoBarTabHelper* infobar_helper = tab_contents->infobar_tab_helper();
 
   for (size_t i = 0; i < infobar_helper->infobar_count(); ++i) {
     TranslateInfoBarDelegate* delegate =
         infobar_helper->GetInfoBarDelegateAt(i)->AsTranslateInfoBarDelegate();
     if (delegate)
       return delegate;
   }
   return NULL;
 }