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_browser_metrics.h"
 #include "chrome/browser/translate/translate_manager.h"
 #include "chrome/browser/translate/translate_tab_helper.h"
 #include "chrome/browser/translate/translate_ui_delegate.h"
 #include "components/translate/common/translate_constants.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
@@ skipping 28 matching lines @@
       // context menu.
       DCHECK(infobar_type == TRANSLATING || infobar_type == AFTER_TRANSLATE);
       DCHECK_EQ(translate::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());
+        TranslateTabHelper::FromWebContents(infobar_service->web_contents());
     if (!translate_tab_helper ||
-         translate_tab_helper->language_state().InTranslateNavigation())
+        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;
     }
   }
 
   // Add the new delegate.
-  scoped_ptr<InfoBarDelegate> infobar(
-      new TranslateInfoBarDelegate(infobar_service, infobar_type, old_delegate,
-                                   original_language, target_language,
-                                   error_type, prefs, shortcut_config));
+  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_delegate, infobar.Pass());
+    infobar_service->ReplaceInfoBar(old_infobar, infobar.Pass());
   else
     infobar_service->AddInfoBar(infobar.Pass());
 }
 
 
 void TranslateInfoBarDelegate::UpdateOriginalLanguageIndex(
     size_t language_index) {
   if (original_language_index_ == language_index)
     return;
 
@@ skipping 23 matching lines @@
                                                  target_language_code());
 
   UMA_HISTOGRAM_BOOLEAN(TranslateBrowserMetrics::GetMetricsName(
       TranslateBrowserMetrics::UMA_PERFORM_TRANSLATE), true);
 }
 
 void TranslateInfoBarDelegate::RevertTranslation() {
   TranslateManager::GetInstance()->RevertTranslation(web_contents());
   UMA_HISTOGRAM_BOOLEAN(TranslateBrowserMetrics::GetMetricsName(
       TranslateBrowserMetrics::UMA_REVERT_TRANSLATION), true);
-  RemoveSelf();
+  infobar()->RemoveSelf();
 }
 
 void TranslateInfoBarDelegate::ReportLanguageDetectionError() {
   TranslateManager::GetInstance()->ReportLanguageDetectionError(
       web_contents());
 }
 
 void TranslateInfoBarDelegate::TranslationDeclined() {
   if (!web_contents()->GetBrowserContext()->IsOffTheRecord()) {
     prefs_.ResetTranslationAcceptedCount(original_language_code());
@@ skipping 22 matching lines @@
 
 void TranslateInfoBarDelegate::ToggleTranslatableLanguageByPrefs() {
   if (prefs_.IsBlockedLanguage(original_language_code())) {
     prefs_.UnblockLanguage(original_language_code());
   } else {
     prefs_.BlockLanguage(original_language_code());
     TranslateTabHelper* translate_tab_helper =
         TranslateTabHelper::FromWebContents(web_contents());
     DCHECK(translate_tab_helper);
     translate_tab_helper->language_state().SetTranslateEnabled(false);
-    RemoveSelf();
+    infobar()->RemoveSelf();
   }
 
   UMA_HISTOGRAM_BOOLEAN(TranslateBrowserMetrics::GetMetricsName(
       TranslateBrowserMetrics::UMA_NEVER_TRANSLATE_LANG), true);
 }
 
 bool TranslateInfoBarDelegate::IsSiteBlacklisted() {
   std::string host = TranslateUIDelegate::GetPageHost(web_contents());
   return !host.empty() && prefs_.IsSiteBlacklisted(host);
 }
 
 void TranslateInfoBarDelegate::ToggleSiteBlacklist() {
   std::string host = TranslateUIDelegate::GetPageHost(web_contents());
   if (host.empty())
     return;
 
   if (prefs_.IsSiteBlacklisted(host)) {
     prefs_.RemoveSiteFromBlacklist(host);
   } else {
     prefs_.BlacklistSite(host);
     TranslateTabHelper* translate_tab_helper =
         TranslateTabHelper::FromWebContents(web_contents());
     DCHECK(translate_tab_helper);
     translate_tab_helper->language_state().SetTranslateEnabled(false);
-    RemoveSelf();
+    infobar()->RemoveSelf();
   }
 
   UMA_HISTOGRAM_BOOLEAN(TranslateBrowserMetrics::GetMetricsName(
       TranslateBrowserMetrics::UMA_NEVER_TRANSLATE_SITE), true);
 }
 
 bool TranslateInfoBarDelegate::ShouldAlwaysTranslate() {
   return prefs_.IsLanguagePairWhitelisted(original_language_code(),
                                           target_language_code());
 }
@@ skipping 23 matching lines @@
 
 void TranslateInfoBarDelegate::NeverTranslatePageLanguage() {
   prefs_.BlockLanguage(original_language_code());
   TranslateTabHelper* translate_tab_helper =
       TranslateTabHelper::FromWebContents(web_contents());
   DCHECK(translate_tab_helper);
   translate_tab_helper->language_state().SetTranslateEnabled(false);
   UMA_HISTOGRAM_BOOLEAN(TranslateBrowserMetrics::GetMetricsName(
       TranslateBrowserMetrics::UMA_NEVER_TRANSLATE_LANG), true);
 
-  RemoveSelf();
+    infobar()->RemoveSelf();
 }
 
 string16 TranslateInfoBarDelegate::GetMessageInfoBarText() {
   if (infobar_type_ == TRANSLATING) {
     string16 target_language_name = language_name_at(target_language_index());
     return l10n_util::GetStringFUTF16(IDS_TRANSLATE_INFOBAR_TRANSLATING_TO,
                                       target_language_name);
   }
 
   DCHECK_EQ(TRANSLATION_ERROR, infobar_type_);
@@ skipping 101 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),
       target_language_index_(kNoIndex),
       error_type_(error_type),
       prefs_(prefs),
       shortcut_config_(shortcut_config) {
   DCHECK_NE((infobar_type_ == TRANSLATION_ERROR),
             (error_type_ == TranslateErrors::NONE));
 
   if (old_delegate && (old_delegate->is_error() != is_error()))
     background_animation_ = is_error() ? NORMAL_TO_ERROR : ERROR_TO_NORMAL;
 
   languages_ = TranslateUIDelegate::GetSortedLanguageNames(
       g_browser_process->GetApplicationLocale());
 
   for (std::vector<LanguageNamePair>::const_iterator iter = languages_.begin();
        iter != languages_.end(); ++iter) {
     std::string language_code = iter->first;
     if (language_code == original_language)
       original_language_index_ = iter - languages_.begin();
     if (language_code == target_language)
       target_language_index_ = iter - languages_.begin();
   }
 }
 
+// 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("Translate.DeclineTranslateCloseInfobar", true);
 }
 
 int TranslateInfoBarDelegate::GetIconID() const {
@@ skipping 11 matching lines @@
   if (!details.is_navigation_to_different_page() && !details.is_main_frame)
     return false;
 
   return InfoBarDelegate::ShouldExpireInternal(details);
 }
 
 TranslateInfoBarDelegate*
     TranslateInfoBarDelegate::AsTranslateInfoBarDelegate() {
   return this;
 }