When replacing an infobar, maintain the old infobar's position.

chrome/browser/tab_contents/infobar_container.cc

 // Copyright (c) 2011 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.
 
 #if defined(TOOLKIT_VIEWS)  // TODO(pkasting): Port non-views to use this.
 
 #include "chrome/browser/tab_contents/infobar_container.h"
 
 #include "chrome/browser/tab_contents/infobar.h"
 #include "chrome/browser/tab_contents/infobar_delegate.h"
@@ skipping 38 matching lines @@
     registrar_.Add(this, NotificationType::TAB_CONTENTS_INFOBAR_REMOVED,
                    tc_source);
     registrar_.Add(this, NotificationType::TAB_CONTENTS_INFOBAR_REPLACED,
                    tc_source);
 
     for (size_t i = 0; i < tab_contents_->infobar_count(); ++i) {
       // As when we removed the infobars above, we prevent callbacks to
       // OnInfoBarAnimated() for each infobar.
       AddInfoBar(
           tab_contents_->GetInfoBarDelegateAt(i)->CreateInfoBar(tab_contents_),
-          false, NO_CALLBACK);
+          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 47 matching lines @@
   delegate_ = NULL;
   ChangeTabContents(NULL);
 }
 
 void InfoBarContainer::Observe(NotificationType type,
                                const NotificationSource& source,
                                const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::TAB_CONTENTS_INFOBAR_ADDED:
       AddInfoBar(
-          Details<InfoBarDelegate>(details)->CreateInfoBar(tab_contents_), true,
-          WANT_CALLBACK);
+          Details<InfoBarDelegate>(details)->CreateInfoBar(tab_contents_),
+          infobars_.size(), true, WANT_CALLBACK);
       break;
 
     case NotificationType::TAB_CONTENTS_INFOBAR_REMOVED: {
       typedef std::pair<InfoBarDelegate*, bool> RemoveDetails;
       RemoveDetails* remove_details = Details<RemoveDetails>(details).ptr();
       RemoveInfoBar(remove_details->first, remove_details->second);
       break;
     }
 
     case NotificationType::TAB_CONTENTS_INFOBAR_REPLACED: {
       typedef std::pair<InfoBarDelegate*, InfoBarDelegate*> ReplaceDetails;
       ReplaceDetails* replace_details = Details<ReplaceDetails>(details).ptr();
-      RemoveInfoBar(replace_details->first, false);
-      AddInfoBar(replace_details->second->CreateInfoBar(tab_contents_), false,
-                 WANT_CALLBACK);
+      AddInfoBar(replace_details->second->CreateInfoBar(tab_contents_),
+          RemoveInfoBar(replace_details->first, false), false, WANT_CALLBACK);
       break;
     }
 
     default:
       NOTREACHED();
       break;
   }
 }
 
-void InfoBarContainer::RemoveInfoBar(InfoBarDelegate* delegate,
-                                     bool use_animation) {
+size_t InfoBarContainer::RemoveInfoBar(InfoBarDelegate* delegate,
+                                       bool use_animation) {
   // Search for the infobar associated with |delegate|.  We cannot search for
   // |delegate| in |tab_contents_|, 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) {
+      size_t position = i - infobars_.begin();
       // We merely need hide the infobar; it will call back to RemoveInfoBar()
       // itself once it's hidden.
       infobar->Hide(use_animation);
       UpdateInfoBarArrowTargetHeights();
-      break;
+      return position;
     }
   }
+  NOTREACHED();
+  return infobars_.size();
 }
 
 void InfoBarContainer::AddInfoBar(InfoBar* infobar,
+                                  size_t position,
                                   bool animate,
                                   CallbackStatus callback_status) {
   DCHECK(std::find(infobars_.begin(), infobars_.end(), infobar) ==
       infobars_.end());
-  infobars_.push_back(infobar);
+  DCHECK_LE(position, infobars_.size());
+  infobars_.insert(infobars_.begin() + position, infobar);
   UpdateInfoBarArrowTargetHeights();
-  PlatformSpecificAddInfoBar(infobar);
+  PlatformSpecificAddInfoBar(infobar, position);
   if (callback_status == WANT_CALLBACK)
     infobar->set_container(this);
   infobar->Show(animate);
   if (callback_status == NO_CALLBACK)
     infobar->set_container(this);
 }
 
 void InfoBarContainer::UpdateInfoBarArrowTargetHeights() {
   for (size_t i = 0; i < infobars_.size(); ++i)
     infobars_[i]->SetArrowTargetHeight(ArrowTargetHeightForInfoBar(i));
@@ skipping 10 matching lines @@
     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());
 }
 
 #endif  // TOOLKIT_VIEWS