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

chrome/browser/ui/browser.cc

 // Copyright 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/ui/browser.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #endif  // defined(OS_WIN)
@@ skipping 867 matching lines @@
   return false;
 }
 
 // static
 void Browser::JSOutOfMemoryHelper(WebContents* web_contents) {
   InfoBarService* infobar_service =
       InfoBarService::FromWebContents(web_contents);
   if (!infobar_service)
     return;
 
-  infobar_service->AddInfoBar(new SimpleAlertInfoBarDelegate(
-      infobar_service,
-      NULL,
-      l10n_util::GetStringUTF16(IDS_JS_OUT_OF_MEMORY_PROMPT),
-      true));
+  SimpleAlertInfoBarDelegate::Create(
+      infobar_service, NULL,
+      l10n_util::GetStringUTF16(IDS_JS_OUT_OF_MEMORY_PROMPT), true);
 }
 
 // static
 void Browser::RegisterProtocolHandlerHelper(WebContents* web_contents,
                                             const std::string& protocol,
                                             const GURL& url,
                                             const string16& title,
                                             bool user_gesture,
                                             BrowserWindow* window) {
   Profile* profile =
@@ skipping 19 matching lines @@
     return;
   }
 
   // Make sure content-setting icon is turned off in case the page does
   // ungestured and gestured RPH calls.
   if (window) {
     tab_content_settings->ClearPendingProtocolHandler();
     window->GetLocationBar()->UpdateContentSettingsIcons();
   }
 
-  content::RecordAction(
-      UserMetricsAction("RegisterProtocolHandler.InfoBar_Shown"));
-  InfoBarService* infobar_service =
-      InfoBarService::FromWebContents(web_contents);
-
-  RegisterProtocolHandlerInfoBarDelegate* rph_delegate =
-      new RegisterProtocolHandlerInfoBarDelegate(infobar_service,
-                                                 registry,
-                                                 handler);
-
-  for (size_t i = 0; i < infobar_service->GetInfoBarCount(); i++) {
-    InfoBarDelegate* delegate = infobar_service->GetInfoBarDelegateAt(i);
-    RegisterProtocolHandlerInfoBarDelegate* cast_delegate =
-        delegate->AsRegisterProtocolHandlerInfoBarDelegate();
-    if (cast_delegate != NULL && cast_delegate->IsReplacedBy(rph_delegate)) {
-      infobar_service->ReplaceInfoBar(cast_delegate, rph_delegate);
-      rph_delegate = NULL;
-      break;
-    }
-  }
-
-  if (rph_delegate != NULL)
-    infobar_service->AddInfoBar(rph_delegate);
+  RegisterProtocolHandlerInfoBarDelegate::Create(
+      InfoBarService::FromWebContents(web_contents), registry, handler);
 }
 
 // static
 void Browser::FindReplyHelper(WebContents* web_contents,
                               int request_id,
                               int number_of_matches,
                               const gfx::Rect& selection_rect,
                               int active_match_ordinal,
                               bool final_update) {
   FindTabHelper* find_tab_helper = FindTabHelper::FromWebContents(web_contents);
   if (!find_tab_helper)
     return;
 
   find_tab_helper->HandleFindReply(request_id,
                                    number_of_matches,
                                    selection_rect,
                                    active_match_ordinal,
                                    final_update);
 }
 
-// static
-void Browser::RequestMediaAccessPermissionHelper(
-    content::WebContents* web_contents,
-    const content::MediaStreamRequest& request,
-    const content::MediaResponseCallback& callback) {
-  Profile* profile =
-      Profile::FromBrowserContext(web_contents->GetBrowserContext());
-
-  scoped_ptr<MediaStreamDevicesController>
-      controller(new MediaStreamDevicesController(profile,
-                                                  request,
-                                                  callback));
-  if (!controller->DismissInfoBarAndTakeActionOnSettings()) {
-  InfoBarService* infobar_service =
-      InfoBarService::FromWebContents(web_contents);
-    InfoBarDelegate* old_infobar = NULL;
-    for (size_t i = 0; i < infobar_service->GetInfoBarCount(); ++i) {
-      old_infobar = infobar_service->GetInfoBarDelegateAt(i)->
-          AsMediaStreamInfoBarDelegate();
-      if (old_infobar)
-        break;
-    }
-
-    InfoBarDelegate* infobar =
-        new MediaStreamInfoBarDelegate(infobar_service, controller.release());
-    if (old_infobar)
-      infobar_service->ReplaceInfoBar(old_infobar, infobar);
-    else
-      infobar_service->AddInfoBar(infobar);
-  }
-}
-
 void Browser::UpdateUIForNavigationInTab(WebContents* contents,
                                          content::PageTransition transition,
                                          bool user_initiated) {
   tab_strip_model_->TabNavigating(contents, transition);
 
   bool contents_is_selected =
       contents == tab_strip_model_->GetActiveWebContents();
   if (user_initiated && contents_is_selected && window()->GetLocationBar()) {
     // Forcibly reset the location bar if the url is going to change in the
     // current tab, since otherwise it won't discard any ongoing user edits,
@@ skipping 582 matching lines @@
     return;
 
   chrome::ShowHungRendererDialog(source);
 }
 
 void Browser::RendererResponsive(WebContents* source) {
   chrome::HideHungRendererDialog(source);
 }
 
 void Browser::WorkerCrashed(WebContents* source) {
-  InfoBarService* infobar_service =
-      InfoBarService::FromWebContents(source);
-  infobar_service->AddInfoBar(new SimpleAlertInfoBarDelegate(
-      infobar_service,
-      NULL,
-      l10n_util::GetStringUTF16(IDS_WEBWORKER_CRASHED_PROMPT),
-      true));
+  SimpleAlertInfoBarDelegate::Create(
+      InfoBarService::FromWebContents(source), NULL,
+      l10n_util::GetStringUTF16(IDS_WEBWORKER_CRASHED_PROMPT), true);
 }
 
 void Browser::DidNavigateMainFramePostCommit(WebContents* web_contents) {
   if (web_contents == tab_strip_model_->GetActiveWebContents())
     UpdateBookmarkBarState(BOOKMARK_BAR_STATE_CHANGE_TAB_STATE);
 }
 
 void Browser::DidNavigateToPendingEntry(WebContents* web_contents) {
   if (web_contents == tab_strip_model_->GetActiveWebContents())
     UpdateBookmarkBarState(BOOKMARK_BAR_STATE_CHANGE_TAB_STATE);
@@ skipping 59 matching lines @@
                                       const string16& title,
                                       bool user_gesture) {
   RegisterProtocolHandlerHelper(
       web_contents, protocol, url, title, user_gesture, window());
 }
 
 void Browser::RegisterIntentHandler(
     WebContents* web_contents,
     const webkit_glue::WebIntentServiceData& data,
     bool user_gesture) {
-  RegisterIntentHandlerHelper(web_contents, data, user_gesture);
+  RegisterIntentHandlerInfoBarDelegate::Create(web_contents, data);
 }
 
 void Browser::WebIntentDispatch(
     WebContents* web_contents,
     content::WebIntentsDispatcher* intents_dispatcher) {
   if (!web_intents::IsWebIntentsEnabledForProfile(profile_)) {
     web_intents::RecordIntentsDispatchDisabled();
     delete intents_dispatcher;
     return;
   }
@@ skipping 75 matching lines @@
 }
 
 void Browser::LostMouseLock() {
   fullscreen_controller_->LostMouseLock();
 }
 
 void Browser::RequestMediaAccessPermission(
     content::WebContents* web_contents,
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback) {
-  RequestMediaAccessPermissionHelper(web_contents, request, callback);
+  MediaStreamInfoBarDelegate::Create(web_contents, request, callback);
 }
 
 bool Browser::RequestPpapiBrokerPermission(
     WebContents* web_contents,
     const GURL& url,
     const FilePath& plugin_path,
     const base::Callback<void(bool)>& callback) {
-  PepperBrokerInfoBarDelegate::Show(web_contents, url, plugin_path, callback);
+  PepperBrokerInfoBarDelegate::Create(web_contents, url, plugin_path, callback);
   return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, CoreTabHelperDelegate implementation:
 
 void Browser::SwapTabContents(content::WebContents* old_contents,
                               content::WebContents* new_contents) {
   int index = tab_strip_model_->GetIndexOfWebContents(old_contents);
   DCHECK_NE(TabStripModel::kNoTab, index);
@@ skipping 628 matching lines @@
   if (contents && !allow_js_access) {
     contents->web_contents()->GetController().LoadURL(
         target_url,
         content::Referrer(),
         content::PAGE_TRANSITION_LINK,
         std::string());  // No extra headers.
   }
 
   return contents != NULL;
 }