Eliminate TranslateManager listening to //chrome-level notifications.

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/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
@@ skipping 147 matching lines @@
       // be done after that.
       base::MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(
               &TranslateManager::InitiateTranslationPosted,
               weak_method_factory_.GetWeakPtr(),
               translate_driver_->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();
-      DCHECK_EQ(translate_tab_helper_->GetWebContents(), tab);
-
-      if (!translate_tab_helper_->GetWebContents())
-        return;
-
-      // We may get this notifications multiple times.  Make sure to translate
-      // only once.
-      LanguageState& language_state = translate_driver_->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(language);
-      }
-      break;
-    }
-    case chrome::NOTIFICATION_PAGE_TRANSLATED: {
-      // Only add translate infobar if it doesn't exist; if it already exists,
-      // just update the state, the actual infobar would have received the same
-      //  notification and update the visual display accordingly.
-      PageTranslatedDetails* page_translated_details =
-          content::Details<PageTranslatedDetails>(details).ptr();
-      PageTranslated(page_translated_details);
-      break;
-    }
     default:
       NOTREACHED();
   }
 }
 
 // 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,
     const std::string& accept_languages_pref_name)
     : max_reload_check_attempts_(kMaxTranslateLoadCheckAttempts),
       accept_languages_pref_name_(accept_languages_pref_name),
       translate_tab_helper_(helper),
       translate_client_(helper),
       translate_driver_(translate_client_->GetTranslateDriver()),
       weak_method_factory_(this) {
 
   WebContents* web_contents = translate_tab_helper_->GetWebContents();
 
   notification_registrar_.Add(
       this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
       content::Source<NavigationController>(&web_contents->GetController()));
-  notification_registrar_.Add(this,
-                              chrome::NOTIFICATION_TAB_LANGUAGE_DETERMINED,
-                              content::Source<WebContents>(web_contents));
-  notification_registrar_.Add(this,
-                              chrome::NOTIFICATION_PAGE_TRANSLATED,
-                              content::Source<WebContents>(web_contents));
 }
 
 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()) {
+    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);
     return;
   }
 
@@ skipping 78 matching lines @@
   if (!translate_driver_->IsOffTheRecord()) {
     std::string auto_target_lang = GetAutoTargetLanguage(language_code, prefs);
     if (!auto_target_lang.empty()) {
       TranslateBrowserMetrics::ReportInitiationStatus(
           TranslateBrowserMetrics::INITIATION_STATUS_AUTO_BY_CONFIG);
       TranslatePage(language_code, auto_target_lang, false);
       return;
     }
   }
 
-  LanguageState& language_state = translate_driver_->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(language_code, auto_translate_to, false);
     return;
   }
 
   TranslateBrowserMetrics::ReportInitiationStatus(
@@ skipping 114 matching lines @@
                                 content::PAGE_TRANSITION_AUTO_BOOKMARK);
 }
 
 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(PageTranslatedDetails* details) {
-  if ((details->error_type == TranslateErrors::NONE) &&
-      details->source_language != translate::kUnknownLanguageCode &&
-      !TranslateDownloadManager::IsSupportedLanguage(
-           details->source_language)) {
-    details->error_type = TranslateErrors::UNSUPPORTED_LANGUAGE;
+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);
+
+  if ((error_type == TranslateErrors::NONE) &&
+      source_lang != translate::kUnknownLanguageCode &&
+      !TranslateDownloadManager::IsSupportedLanguage(source_lang)) {
+    error_type = TranslateErrors::UNSUPPORTED_LANGUAGE;
   }
 
-  DCHECK(translate_tab_helper_->GetWebContents());
-
   translate_client_->ShowTranslateUI(translate::TRANSLATE_STEP_AFTER_TRANSLATE,
-                                     details->source_language,
-                                     details->target_language,
-                                     details->error_type,
+                                     source_lang,
+                                     target_lang,
+                                     error_type,
                                      false);
 
   WebContents* web_contents = translate_tab_helper_->GetWebContents();
-  if (details->error_type != TranslateErrors::NONE &&
+  if (error_type != TranslateErrors::NONE &&
       !translate_driver_->IsOffTheRecord()) {
     TranslateErrorDetails error_details;
     error_details.time = base::Time::Now();
     error_details.url = web_contents->GetLastCommittedURL();
-    error_details.error = details->error_type;
+    error_details.error = error_type;
     NotifyTranslateError(error_details);
   }
 }
 
 void TranslateManager::OnTranslateScriptFetchComplete(
     int page_id,
     const std::string& source_lang,
     const std::string& target_lang,
     bool success,
     const std::string& data) {
@@ skipping 61 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();
 }