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

chrome/browser/infobars/infobar_tab_helper.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/infobars/infobar_tab_helper.h"
 
 #include "chrome/browser/api/infobars/infobar_delegate.h"
 #include "chrome/browser/infobars/infobar.h"
 #include "chrome/browser/infobars/insecure_content_infobar_delegate.h"
 #include "chrome/common/chrome_notification_types.h"
@@ skipping 42 matching lines @@
   // TODO(pkasting): If there is no InfoBarContainer, this leaks all the
   // InfoBarDelegates.  This will be fixed once we call CloseSoon() directly on
   // Infobars.
   RemoveAllInfoBars(false);
 }
 
 void InfoBarTabHelper::SetInfoBarsEnabled(bool enabled) {
   infobars_enabled_ = enabled;
 }
 
-bool InfoBarTabHelper::AddInfoBar(InfoBarDelegate* delegate) {
-  if (!infobars_enabled_) {
-    delegate->InfoBarClosed();
-    return false;
-  }
+InfoBarDelegate* InfoBarTabHelper::AddInfoBar(
+    scoped_ptr<InfoBarDelegate> delegate) {
+  if (!infobars_enabled_)
+    return NULL;
 
   for (InfoBars::const_iterator i(infobars_.begin()); i != infobars_.end();
        ++i) {
-    if ((*i)->EqualsDelegate(delegate)) {
-      DCHECK_NE(*i, delegate);
-      delegate->InfoBarClosed();
-      return false;
+    if ((*i)->EqualsDelegate(delegate.get())) {
+      DCHECK_NE(*i, delegate.get());
+      return NULL;
     }
   }
 
   // TODO(pkasting): Consider removing InfoBarTabHelper arg from delegate
   // constructors and instead using a setter from here.
-  infobars_.push_back(delegate);
+  InfoBarDelegate* delegate_ptr = delegate.release();
+  infobars_.push_back(delegate_ptr);
   // Add ourselves as an observer for navigations the first time a delegate is
   // added. We use this notification to expire InfoBars that need to expire on
   // page transitions.
   if (infobars_.size() == 1) {
     registrar_.Add(
         this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
         content::Source<NavigationController>(
             &web_contents()->GetController()));
   }
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_ADDED,
       content::Source<InfoBarService>(this),
-      content::Details<InfoBarAddedDetails>(delegate));
-  return true;
+      content::Details<InfoBarAddedDetails>(delegate_ptr));
+  return delegate_ptr;
 }
 
 void InfoBarTabHelper::RemoveInfoBar(InfoBarDelegate* delegate) {
   RemoveInfoBarInternal(delegate, true);
 }
 
-bool InfoBarTabHelper::ReplaceInfoBar(InfoBarDelegate* old_delegate,
-                                      InfoBarDelegate* new_delegate) {
+InfoBarDelegate* InfoBarTabHelper::ReplaceInfoBar(
+    InfoBarDelegate* old_delegate,
+    scoped_ptr<InfoBarDelegate> new_delegate) {
   if (!infobars_enabled_)
-    return AddInfoBar(new_delegate);  // Deletes the delegate.
+    return AddInfoBar(new_delegate.Pass());  // Deletes the delegate.
 
   InfoBars::iterator i(std::find(infobars_.begin(), infobars_.end(),
                                  old_delegate));
   DCHECK(i != infobars_.end());
 
-  i = infobars_.insert(i, new_delegate) + 1;
+  InfoBarDelegate* new_delegate_ptr = new_delegate.release();
+  i = infobars_.insert(i, new_delegate_ptr);
+  InfoBarReplacedDetails replaced_details(old_delegate, new_delegate_ptr);
   // Remove the old delegate before notifying, so that if any observers call
   // back to AddInfoBar() or similar, we don't dupe-check against this delegate.
-  infobars_.erase(i);
+  infobars_.erase(++i);
 
   old_delegate->clear_owner();
-  InfoBarReplacedDetails replaced_details(old_delegate, new_delegate);
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REPLACED,
       content::Source<InfoBarService>(this),
       content::Details<InfoBarReplacedDetails>(&replaced_details));
-  return true;
+  return new_delegate_ptr;
 }
 
 size_t InfoBarTabHelper::GetInfoBarCount() const {
   return infobars_.size();
 }
 
 InfoBarDelegate* InfoBarTabHelper::GetInfoBarDelegateAt(size_t index) {
   return infobars_[index];
 }
 
@@ skipping 29 matching lines @@
       content::Source<InfoBarService>(this),
       content::Details<InfoBarRemovedDetails>(&removed_details));
 }
 
 void InfoBarTabHelper::RemoveAllInfoBars(bool animate) {
   while (!infobars_.empty())
     RemoveInfoBarInternal(GetInfoBarDelegateAt(GetInfoBarCount() - 1), animate);
 }
 
 void InfoBarTabHelper::OnDidBlockDisplayingInsecureContent() {
-  // At most one infobar and do not supersede the stronger running content bar.
-  for (size_t i = 0; i < infobars_.size(); ++i) {
-    if (GetInfoBarDelegateAt(i)->AsInsecureContentInfoBarDelegate())
-      return;
-  }
-  AddInfoBar(new InsecureContentInfoBarDelegate(this,
-      InsecureContentInfoBarDelegate::DISPLAY));
+  InsecureContentInfoBarDelegate::Create(
+      this, InsecureContentInfoBarDelegate::DISPLAY);
 }
 
 void InfoBarTabHelper::OnDidBlockRunningInsecureContent() {
-  // At most one infobar superseding any weaker displaying content bar.
-  for (size_t i = 0; i < infobars_.size(); ++i) {
-    InsecureContentInfoBarDelegate* delegate =
-        GetInfoBarDelegateAt(i)->AsInsecureContentInfoBarDelegate();
-    if (delegate) {
-      if (delegate->type() != InsecureContentInfoBarDelegate::RUN) {
-        ReplaceInfoBar(delegate, new InsecureContentInfoBarDelegate(
-            this, InsecureContentInfoBarDelegate::RUN));
-      }
-      return;
-    }
-  }
-  AddInfoBar(new InsecureContentInfoBarDelegate(this,
-      InsecureContentInfoBarDelegate::RUN));
+  InsecureContentInfoBarDelegate::Create(this,
+                                         InsecureContentInfoBarDelegate::RUN);
 }
 
 void InfoBarTabHelper::RenderViewGone(base::TerminationStatus status) {
   RemoveAllInfoBars(true);
 }
 
 bool InfoBarTabHelper::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(InfoBarTabHelper, message)
     IPC_MESSAGE_HANDLER(ChromeViewHostMsg_DidBlockDisplayingInsecureContent,
@@ skipping 30 matching lines @@
   DCHECK_EQ(type, content::NOTIFICATION_WEB_CONTENTS_DESTROYED);
   // The WebContents is going away; be aggressively paranoid and delete
   // ourselves lest other parts of the system attempt to add infobars or use
   // us otherwise during the destruction.
   DCHECK_EQ(web_contents(), content::Source<WebContents>(source).ptr());
   web_contents()->RemoveUserData(UserDataKey());
   // That was the equivalent of "delete this". This object is now destroyed;
   // returning from this function is the only safe thing to do.
   return;
 }