Split InfoBarService core code into InfoBarManager

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>
 
 #include "base/logging.h"
 #include "chrome/browser/infobars/infobar.h"
 #include "chrome/browser/infobars/infobar_delegate.h"
-#include "chrome/browser/infobars/infobar_service.h"
 #include "ui/gfx/animation/slide_animation.h"
 
 InfoBarContainer::Delegate::~Delegate() {
 }
 
 InfoBarContainer::InfoBarContainer(Delegate* delegate)
     : delegate_(delegate),
-      infobar_service_(NULL),
+      infobar_manager_(NULL),
       top_arrow_target_height_(InfoBar::kDefaultArrowTargetHeight) {
 }
 
 InfoBarContainer::~InfoBarContainer() {
   // RemoveAllInfoBarsForDestruction() should have already cleared our infobars.
   DCHECK(infobars_.empty());
-  if (infobar_service_)
-    infobar_service_->RemoveObserver(this);
+  if (infobar_manager_)
+    infobar_manager_->RemoveObserver(this);
 }
 
-void InfoBarContainer::ChangeInfoBarService(InfoBarService* infobar_service) {
-  if (infobar_service_)
-    infobar_service_->RemoveObserver(this);
+void InfoBarContainer::ChangeInfoBarManager(InfoBarManager* infobar_manager) {
+  if (infobar_manager_)
+    infobar_manager_->RemoveObserver(this);
 
   // Hides all infobars in this container without animation.
   while (!infobars_.empty()) {
     InfoBar* infobar = infobars_.front();
     // Inform the infobar that it's hidden.  If it was already closing, this
     // deletes it.  Otherwise, this ensures the infobar will be deleted if it's
     // closed while it's not in an InfoBarContainer.
     infobar->Hide(false);
   }
 
-  infobar_service_ = infobar_service;
-  if (infobar_service_) {
-    infobar_service_->AddObserver(this);
+  infobar_manager_ = infobar_manager;
+  if (infobar_manager_) {
+    infobar_manager_->AddObserver(this);
 
-    for (size_t i = 0; i < infobar_service_->infobar_count(); ++i) {
+    for (size_t i = 0; i < infobar_manager_->infobar_count(); ++i) {
       // As when we removed the infobars above, we prevent callbacks to
       // OnInfoBarStateChanged() for each infobar.
-      AddInfoBar(infobar_service_->infobar_at(i), i, false, NO_CALLBACK);
+      AddInfoBar(infobar_manager_->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 36 matching lines @@
   infobars_.erase(i);
 }
 
 void InfoBarContainer::RemoveAllInfoBarsForDestruction() {
   // Before we remove any children, we reset |delegate_|, so that no removals
   // will result in us trying to call
   // delegate_->InfoBarContainerStateChanged().  This is important because at
   // this point |delegate_| may be shutting down, and it's at best unimportant
   // and at worst disastrous to call that.
   delegate_ = NULL;
-  ChangeInfoBarService(NULL);
+  ChangeInfoBarManager(NULL);
 }
 
 void InfoBarContainer::OnInfoBarAdded(InfoBar* infobar) {
   AddInfoBar(infobar, infobars_.size(), true, WANT_CALLBACK);
 }
 
 void InfoBarContainer::OnInfoBarRemoved(InfoBar* infobar, bool animate) {
   infobar->Hide(animate);
   UpdateInfoBarArrowTargetHeights();
 }
 
 void InfoBarContainer::OnInfoBarReplaced(InfoBar* old_infobar,
                                          InfoBar* new_infobar) {
   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);
 }
 
-void InfoBarContainer::OnServiceShuttingDown(InfoBarService* service) {
-  DCHECK_EQ(infobar_service_, service);
-  infobar_service_->RemoveObserver(this);
-  infobar_service_ = NULL;
+void InfoBarContainer::OnManagerShuttingDown(InfoBarManager* manager) {
+  DCHECK_EQ(infobar_manager_, manager);
+  infobar_manager_->RemoveObserver(this);
+  infobar_manager_ = NULL;
 }
 
 void InfoBarContainer::AddInfoBar(InfoBar* infobar,
                                   size_t position,
                                   bool animate,
                                   CallbackStatus callback_status) {
   DCHECK(std::find(infobars_.begin(), infobars_.end(), infobar) ==
       infobars_.end());
   DCHECK_LE(position, infobars_.size());
   infobars_.insert(infobars_.begin() + position, infobar);
@@ skipping 20 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());
 }