Infobar system refactor.

chrome/browser/translate/translate_infobar_delegate.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_infobar_delegate.h"
 
 #include <algorithm>
 
 #include "base/i18n/string_compare.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/infobars/infobar.h"
 #include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/translate/translate_accept_languages.h"
 #include "chrome/browser/translate/translate_manager.h"
 #include "chrome/browser/translate/translate_tab_helper.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/web_contents.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
@@ skipping 36 matching lines @@
     DCHECK(TranslateManager::IsSupportedLanguage(target_language));
     if (!TranslateManager::IsSupportedLanguage(original_language)) {
       // The original language can only be "unknown" for the "translating"
       // infobar, which is the case when the user started a translation from the
       // context menu.
       DCHECK(infobar_type == TRANSLATING || infobar_type == AFTER_TRANSLATE);
       DCHECK_EQ(chrome::kUnknownLanguageCode, original_language);
     }
   }
 
+  // Do not create the after translate infobar if we are auto translating.
+  if ((infobar_type == TranslateInfoBarDelegate::AFTER_TRANSLATE) ||
+      (infobar_type == TranslateInfoBarDelegate::TRANSLATING)) {
+    TranslateTabHelper* translate_tab_helper =
+        TranslateTabHelper::FromWebContents(infobar_service->web_contents());
+    if (!translate_tab_helper ||
+        translate_tab_helper->language_state().InTranslateNavigation())
+      return;
+  }
+
   // Find any existing translate infobar delegate.
+  InfoBar* old_infobar = NULL;
   TranslateInfoBarDelegate* old_delegate = NULL;
   for (size_t i = 0; i < infobar_service->infobar_count(); ++i) {
-    old_delegate = infobar_service->infobar_at(i)->AsTranslateInfoBarDelegate();
+    old_infobar = infobar_service->infobar_at(i);
+    old_delegate = old_infobar->delegate()->AsTranslateInfoBarDelegate();
     if (old_delegate) {
       if (!replace_existing_infobar)
         return;
       break;
     }
   }
 
-  // Create the new delegate.
-  scoped_ptr<TranslateInfoBarDelegate> infobar(
-      new TranslateInfoBarDelegate(infobar_service, infobar_type, old_delegate,
-                                   original_language, target_language,
-                                   error_type, prefs, shortcut_config));
-
-  // Do not create the after translate infobar if we are auto translating.
-  if ((infobar_type == TranslateInfoBarDelegate::AFTER_TRANSLATE) ||
-      (infobar_type == TranslateInfoBarDelegate::TRANSLATING)) {
-    TranslateTabHelper* translate_tab_helper =
-      TranslateTabHelper::FromWebContents(infobar_service->web_contents());
-    if (!translate_tab_helper ||
-         translate_tab_helper->language_state().InTranslateNavigation())
-      return;
-  }
-
-  // Add the new delegate if necessary.
-  if (!old_delegate) {
-    infobar_service->AddInfoBar(infobar.PassAs<InfoBarDelegate>());
-  } else {
-    DCHECK(replace_existing_infobar);
-    infobar_service->ReplaceInfoBar(old_delegate,
-                                    infobar.PassAs<InfoBarDelegate>());
-  }
+  // Add the new delegate.
+  scoped_ptr<InfoBar> infobar(CreateInfoBar(
+      scoped_ptr<TranslateInfoBarDelegate>(new TranslateInfoBarDelegate(
+          infobar_type, old_delegate, original_language, target_language,
+          error_type, prefs, shortcut_config))));
+  if (old_delegate)
+    infobar_service->ReplaceInfoBar(old_infobar, infobar.Pass());
+  else
+    infobar_service->AddInfoBar(infobar.Pass());
 }
 
 void TranslateInfoBarDelegate::Translate() {
   if (!web_contents()->GetBrowserContext()->IsOffTheRecord()) {
     prefs_.ResetTranslationDeniedCount(original_language_code());
     prefs_.IncrementTranslationAcceptedCount(original_language_code());
   }
 
   TranslateManager::GetInstance()->TranslatePage(web_contents(),
                                                  original_language_code(),
                                                  target_language_code());
 
   UMA_HISTOGRAM_BOOLEAN(kPerformTranslate, true);
 }
 
 void TranslateInfoBarDelegate::RevertTranslation() {
   TranslateManager::GetInstance()->RevertTranslation(web_contents());
-  RemoveSelf();
+  infobar()->RemoveSelf();
 
   UMA_HISTOGRAM_BOOLEAN(kRevertTranslation, true);
 }
 
 void TranslateInfoBarDelegate::ReportLanguageDetectionError() {
   TranslateManager::GetInstance()->ReportLanguageDetectionError(
       web_contents());
 }
 
 void TranslateInfoBarDelegate::TranslationDeclined() {
@@ skipping 20 matching lines @@
   return TranslatePrefs::CanTranslateLanguage(original_profile,
                                               original_language_code());
 }
 
 void TranslateInfoBarDelegate::ToggleTranslatableLanguageByPrefs() {
   const std::string& original_lang = original_language_code();
   if (prefs_.IsBlockedLanguage(original_lang)) {
     prefs_.UnblockLanguage(original_lang);
   } else {
     prefs_.BlockLanguage(original_lang);
-    RemoveSelf();
+    infobar()->RemoveSelf();
   }
 
   UMA_HISTOGRAM_BOOLEAN(kNeverTranslateLang, true);
 }
 
 bool TranslateInfoBarDelegate::IsSiteBlacklisted() {
   std::string host = GetPageHost();
   return !host.empty() && prefs_.IsSiteBlacklisted(host);
 }
 
 void TranslateInfoBarDelegate::ToggleSiteBlacklist() {
   std::string host = GetPageHost();
   if (host.empty())
     return;
 
   if (prefs_.IsSiteBlacklisted(host)) {
     prefs_.RemoveSiteFromBlacklist(host);
   } else {
     prefs_.BlacklistSite(host);
-    RemoveSelf();
+    infobar()->RemoveSelf();
   }
 
   UMA_HISTOGRAM_BOOLEAN(kNeverTranslateSite, true);
 }
 
 bool TranslateInfoBarDelegate::ShouldAlwaysTranslate() {
   return prefs_.IsLanguagePairWhitelisted(original_language_code(),
                                           target_language_code());
 }
 
@@ skipping 12 matching lines @@
   const std::string& original_lang = original_language_code();
   const std::string& target_lang = target_language_code();
   DCHECK(!prefs_.IsLanguagePairWhitelisted(original_lang, target_lang));
   prefs_.WhitelistLanguagePair(original_lang, target_lang);
   Translate();
 }
 
 void TranslateInfoBarDelegate::NeverTranslatePageLanguage() {
   std::string original_lang = original_language_code();
   prefs_.BlockLanguage(original_lang);
-  RemoveSelf();
+    infobar()->RemoveSelf();
 }
 
 string16 TranslateInfoBarDelegate::GetMessageInfoBarText() {
   if (infobar_type_ == TRANSLATING) {
     return l10n_util::GetStringFUTF16(IDS_TRANSLATE_INFOBAR_TRANSLATING_TO,
                                       language_name_at(target_language_index_));
   }
 
   DCHECK_EQ(TRANSLATION_ERROR, infobar_type_);
   UMA_HISTOGRAM_ENUMERATION(kShowErrorInfobar,
@@ skipping 100 matching lines @@
   *swap_languages = (offsets[0] > offsets[1]);
   if (*swap_languages)
     std::swap(offsets[0], offsets[1]);
 
   strings->push_back(text.substr(0, offsets[0]));
   strings->push_back(text.substr(offsets[0], offsets[1] - offsets[0]));
   strings->push_back(text.substr(offsets[1]));
 }
 
 TranslateInfoBarDelegate::TranslateInfoBarDelegate(
-    InfoBarService* infobar_service,
     Type infobar_type,
     TranslateInfoBarDelegate* old_delegate,
     const std::string& original_language,
     const std::string& target_language,
     TranslateErrors::Type error_type,
     PrefService* prefs,
     ShortcutConfiguration shortcut_config)
-    : InfoBarDelegate(infobar_service),
+    : InfoBarDelegate(),
       infobar_type_(infobar_type),
       background_animation_(NONE),
       original_language_index_(kNoIndex),
       initial_original_language_index_(kNoIndex),
       target_language_index_(kNoIndex),
       error_type_(error_type),
       prefs_(prefs),
       shortcut_config_(shortcut_config) {
   DCHECK_NE((infobar_type_ == TRANSLATION_ERROR),
             (error_type_ == TranslateErrors::NONE));
@@ skipping 33 matching lines @@
     if (language_code == original_language) {
       original_language_index_ = iter - languages_.begin();
       initial_original_language_index_ = original_language_index_;
     }
     if (language_code == target_language)
       target_language_index_ = iter - languages_.begin();
   }
   DCHECK_NE(kNoIndex, target_language_index_);
 }
 
+// TranslateInfoBarDelegate::CreateInfoBar() is implemented in platform-specific
+// files.
+
 void TranslateInfoBarDelegate::InfoBarDismissed() {
   if (infobar_type_ != BEFORE_TRANSLATE)
     return;
 
   // The user closed the infobar without clicking the translate button.
   TranslationDeclined();
   UMA_HISTOGRAM_BOOLEAN(kCloseInfobar, true);
 }
 
 int TranslateInfoBarDelegate::GetIconID() const {
@@ skipping 16 matching lines @@
 
 TranslateInfoBarDelegate*
     TranslateInfoBarDelegate::AsTranslateInfoBarDelegate() {
   return this;
 }
 
 std::string TranslateInfoBarDelegate::GetPageHost() {
   NavigationEntry* entry = web_contents()->GetController().GetActiveEntry();
   return entry ? entry->GetURL().HostNoBrackets() : std::string();
 }