Infobar system refactor.

chrome/browser/infobars/infobar_container.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 "build/build_config.h"
 
 #include "chrome/browser/infobars/infobar_container.h"
 
 #include <algorithm>
 
@@ skipping 29 matching lines @@
     registrar_.Add(this, chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_ADDED,
                    source);
     registrar_.Add(this, chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REMOVED,
                    source);
     registrar_.Add(this, chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REPLACED,
                    source);
 
     for (size_t i = 0; i < infobar_service_->infobar_count(); ++i) {
       // As when we removed the infobars above, we prevent callbacks to
       // OnInfoBarAnimated() for each infobar.
-      AddInfoBar(
-          infobar_service_->infobar_at(i)->CreateInfoBar(infobar_service_),
-          i, false, NO_CALLBACK);
+      AddInfoBar(infobar_service_->infobar_at(i), i, false, NO_CALLBACK);
     }
   }
 
   // Now that everything is up to date, signal the delegate to re-layout.
   OnInfoBarStateChanged(false);
 }
 
 int InfoBarContainer::GetVerticalOverlap(int* total_height) {
   // Our |total_height| is the sum of the preferred heights of the InfoBars
   // contained within us plus the |vertical_overlap|.
@@ skipping 44 matching lines @@
   // and at worst disastrous to call that.
   delegate_ = NULL;
   ChangeInfoBarService(NULL);
 }
 
 void InfoBarContainer::Observe(int type,
                                const content::NotificationSource& source,
                                const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_ADDED:
-      AddInfoBar(
-          content::Details<InfoBarAddedDetails>(details)->CreateInfoBar(
-              infobar_service_),
-          infobars_.size(), true, WANT_CALLBACK);
+      AddInfoBar(content::Details<InfoBar::AddedDetails>(details).ptr(),
+                 infobars_.size(), true, WANT_CALLBACK);
       break;
 
     case chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REMOVED: {
-      InfoBarRemovedDetails* removed_details =
-          content::Details<InfoBarRemovedDetails>(details).ptr();
-      HideInfoBar(FindInfoBar(removed_details->first), removed_details->second);
+      InfoBar::RemovedDetails* removed_details =
+          content::Details<InfoBar::RemovedDetails>(details).ptr();
+      removed_details->first->Hide(removed_details->second);
+      UpdateInfoBarArrowTargetHeights();
       break;
     }
 
     case chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REPLACED: {
-      InfoBarReplacedDetails* replaced_details =
-          content::Details<InfoBarReplacedDetails>(details).ptr();
-      ReplaceInfoBar(replaced_details->first, replaced_details->second);
+      InfoBar::ReplacedDetails* replaced_details =
+          content::Details<InfoBar::ReplacedDetails>(details).ptr();
+      InfoBar* old_infobar = replaced_details->first;
+      InfoBar* new_infobar = replaced_details->second;
+      PlatformSpecificReplaceInfoBar(old_infobar, new_infobar);
+      InfoBars::const_iterator i(std::find(infobars_.begin(), infobars_.end(),
+                                           old_infobar));
+      DCHECK(i != infobars_.end());
+      size_t position = i - infobars_.begin();
+      old_infobar->Hide(false);
+      AddInfoBar(new_infobar, position, false, WANT_CALLBACK);
       break;
     }
 
     default:
       NOTREACHED();
       break;
   }
 }
 
-void InfoBarContainer::ReplaceInfoBar(InfoBarDelegate* old_delegate,
-                                      InfoBarDelegate* new_delegate) {
-  InfoBar* new_infobar = new_delegate->CreateInfoBar(infobar_service_);
-  InfoBar* old_infobar = FindInfoBar(old_delegate);
-#if defined(OS_ANDROID)
-  PlatformSpecificReplaceInfoBar(old_infobar, new_infobar);
-#endif
-  AddInfoBar(
-      new_infobar, HideInfoBar(old_infobar, false), false, WANT_CALLBACK);
-}
-
-InfoBar* InfoBarContainer::FindInfoBar(InfoBarDelegate* delegate) {
-  // Search for the infobar associated with |delegate|.  We cannot search for
-  // |delegate| in |tab_helper_|, because an InfoBar remains alive until its
-  // close animation completes, while the delegate is removed from the tab
-  // immediately.
-  for (InfoBars::iterator i(infobars_.begin()); i != infobars_.end(); ++i) {
-    InfoBar* infobar = *i;
-    if (infobar->delegate() == delegate)
-      return infobar;
-  }
-  NOTREACHED();
-  return NULL;
-}
-
-size_t InfoBarContainer::HideInfoBar(InfoBar* infobar, bool use_animation) {
-  InfoBars::iterator it =
-      std::find(infobars_.begin(), infobars_.end(), infobar);
-  DCHECK(it != infobars_.end());
-  size_t position = it - infobars_.begin();
-  // We merely need hide the infobar; it will call back to RemoveInfoBar()
-  // itself once it's hidden.
-  infobar->Hide(use_animation);
-  infobar->CloseSoon();
-  UpdateInfoBarArrowTargetHeights();
-  return position;
-}
-
 void InfoBarContainer::HideAllInfoBars() {
   registrar_.RemoveAll();
 
   while (!infobars_.empty()) {
     InfoBar* infobar = infobars_.front();
     // Inform the infobar that it's hidden.  If it was already closing, this
-    // closes its delegate.
+    // deletes it.  Otherwise, this ensures the infobar will be deleted if it's
+    // closed while it's not in an InfoBarContainer.
     infobar->Hide(false);
   }
 }
 
 void InfoBarContainer::AddInfoBar(InfoBar* infobar,
                                   size_t position,
                                   bool animate,
                                   CallbackStatus callback_status) {
   DCHECK(std::find(infobars_.begin(), infobars_.end(), infobar) ==
       infobars_.end());
@@ skipping 22 matching lines @@
       const_cast<const InfoBar*>(infobars_.front())->animation();
   if ((infobar_index > 1) || first_infobar_animation.IsShowing())
     return InfoBar::kDefaultArrowTargetHeight;
   // When the first infobar is animating closed, we animate the second infobar's
   // arrow target height from the default to the top target height.  Note that
   // the animation values here are going from 1.0 -> 0.0 as the top bar closes.
   return top_arrow_target_height_ + static_cast<int>(
       (InfoBar::kDefaultArrowTargetHeight - top_arrow_target_height_) *
           first_infobar_animation.GetCurrentValue());
 }