Change infobar creation to use a public static Create() method on the infobar delegate classes.

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"
@@ skipping 447 matching lines @@
       }
       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) {
         Profile* profile =
             Profile::FromBrowserContext(web_contents->GetBrowserContext());
-        InfoBarService* infobar_service =
-            InfoBarService::FromWebContents(web_contents);
-        ShowInfoBar(
-            web_contents,
-            TranslateInfoBarDelegate::CreateErrorDelegate(
-                TranslateErrors::NETWORK,
-                infobar_service,
-                profile->GetPrefs(),
-                request.source_lang,
-                request.target_lang));
+        TranslateInfoBarDelegate::Create(
+            InfoBarService::FromWebContents(web_contents),
+            true,
+            TranslateInfoBarDelegate::TRANSLATION_ERROR,
+            TranslateErrors::NETWORK,
+            profile->GetPrefs(),
+            request.source_lang,
+            request.target_lang);
       } else {
         // Translate the page.
         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(9) << "Failed to Fetch languages from: " << kLanguageListFetchURL;
     }
   }
 }
 
-// static
-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,
@@ skipping 19 matching lines @@
   // automated browser testing.
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableTranslate))
     return;
 
   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(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).
@@ skipping 29 matching lines @@
     return;
 
   std::string auto_translate_to =
       translate_tab_helper->language_state().AutoTranslateTo();
   if (!auto_translate_to.empty()) {
     // This page was navigated through a click from a translated page.
     TranslatePage(web_contents, language_code, auto_translate_to);
     return;
   }
 
-  InfoBarService* infobar_service =
-      InfoBarService::FromWebContents(web_contents);
   // Prompts the user if he/she wants the page translated.
-  infobar_service->AddInfoBar(
-      TranslateInfoBarDelegate::CreateDelegate(
-          TranslateInfoBarDelegate::BEFORE_TRANSLATE, infobar_service,
-          profile->GetPrefs(), language_code, target_lang));
+  TranslateInfoBarDelegate::Create(
+      InfoBarService::FromWebContents(web_contents), false,
+      TranslateInfoBarDelegate::BEFORE_TRANSLATE, TranslateErrors::NONE,
+      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* 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())
     return;
 
   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;
   }
 
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
-  InfoBarService* infobar_service =
-      InfoBarService::FromWebContents(web_contents);
-  ShowInfoBar(web_contents, TranslateInfoBarDelegate::CreateDelegate(
-      TranslateInfoBarDelegate::TRANSLATING, infobar_service,
-      profile->GetPrefs(), source_lang, target_lang));
+  TranslateInfoBarDelegate::Create(
+      InfoBarService::FromWebContents(web_contents), true,
+      TranslateInfoBarDelegate::TRANSLATING, TranslateErrors::NONE,
+      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;
@@ skipping 68 matching lines @@
     return;
 
   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* web_contents,
                                       PageTranslatedDetails* details) {
-  InfoBarService* infobar_service =
-      InfoBarService::FromWebContents(web_contents);
-  Profile* profile =
-      Profile::FromBrowserContext(web_contents->GetBrowserContext());
-  PrefService* prefs = profile->GetPrefs();
-
-  // Create the new infobar to display.
-  TranslateInfoBarDelegate* infobar;
-  if (details->error_type != TranslateErrors::NONE) {
-    infobar = TranslateInfoBarDelegate::CreateErrorDelegate(
-        details->error_type,
-        infobar_service,
-        prefs,
-        details->source_language,
-        details->target_language);
-  } else if (!IsSupportedLanguage(details->source_language)) {
+  if ((details->error_type == TranslateErrors::NONE) &&
+      !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_service,
-        prefs, details->source_language, details->target_language);
-  } else {
-    infobar = TranslateInfoBarDelegate::CreateDelegate(
-        TranslateInfoBarDelegate::AFTER_TRANSLATE, infobar_service,
-        prefs, details->source_language, details->target_language);
+    details->error_type = TranslateErrors::UNSUPPORTED_LANGUAGE;
   }
-  ShowInfoBar(web_contents, infobar);
+  Profile* profile =
+      Profile::FromBrowserContext(web_contents->GetBrowserContext());
+  PrefService* prefs = profile->GetPrefs();
+  TranslateInfoBarDelegate::Create(
+      InfoBarService::FromWebContents(web_contents), true,
+      (details->error_type == TranslateErrors::NONE) ?
+          TranslateInfoBarDelegate::AFTER_TRANSLATE :
+          TranslateInfoBarDelegate::TRANSLATION_ERROR,
+      details->error_type, prefs, details->source_language,
+      details->target_language);
 }
 
 bool TranslateManager::IsAcceptLanguage(WebContents* web_contents,
                                         const std::string& language) {
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   profile = profile->GetOriginalProfile();
   PrefService* pref_service = profile->GetPrefs();
   PrefServiceLanguagesMap::const_iterator iter =
       accept_languages_.find(pref_service);
@@ skipping 98 matching lines @@
       0, 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* web_contents,
-                                   TranslateInfoBarDelegate* infobar) {
-  DCHECK(infobar != NULL);
-  TranslateInfoBarDelegate* old_infobar =
-      GetTranslateInfoBarDelegate(web_contents);
-  infobar->UpdateBackgroundAnimation(old_infobar);
-  InfoBarService* infobar_service =
-      InfoBarService::FromWebContents(web_contents);
-  if (!infobar_service)
-    return;
-  if (old_infobar) {
-    // There already is a translate infobar, simply replace it.
-    infobar_service->ReplaceInfoBar(old_infobar, infobar);
-  } else {
-    infobar_service->AddInfoBar(infobar);
-  }
-}
-
 // static
 std::string TranslateManager::GetTargetLanguage(PrefService* prefs) {
   std::string ui_lang =
     GetLanguageCode(g_browser_process->GetApplicationLocale());
   if (IsSupportedLanguage(ui_lang))
     return ui_lang;
 
   // Getting the accepted languages list
   std::string accept_langs_str = prefs->GetString(prefs::kAcceptLanguages);
 
   std::vector<std::string> accept_langs_list;
   base::SplitString(accept_langs_str, ',', &accept_langs_list);
 
   // Will translate to the first supported language on the Accepted Language
   // list or not at all if no such candidate exists
   std::vector<std::string>::iterator iter;
   for (iter = accept_langs_list.begin();
        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* web_contents) {
-  InfoBarService* infobar_service =
-      InfoBarService::FromWebContents(web_contents);
-  if (!infobar_service)
-    return NULL;
-
-  for (size_t i = 0; i < infobar_service->GetInfoBarCount(); ++i) {
-    TranslateInfoBarDelegate* delegate =
-        infobar_service->GetInfoBarDelegateAt(i)->
-            AsTranslateInfoBarDelegate();
-    if (delegate)
-      return delegate;
-  }
-  return NULL;
-}