chrome/browser/infobars/infobar_container.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "build/build_config.h"
   6
   7 #include "chrome/browser/infobars/infobar_container.h"
   8
   9 #include <algorithm>
  10
  11 #include "base/logging.h"
  12 #include "chrome/browser/chrome_notification_types.h"
  13 #include "chrome/browser/infobars/infobar.h"
  14 #include "chrome/browser/infobars/infobar_delegate.h"
  15 #include "chrome/browser/infobars/infobar_service.h"
  16 #include "content/public/browser/notification_details.h"
  17 #include "content/public/browser/notification_source.h"
  18 #include "ui/gfx/animation/slide_animation.h"
  19
  20 InfoBarContainer::Delegate::~Delegate() {
  21 }
  22
  23 InfoBarContainer::InfoBarContainer(Delegate* delegate)
  24     : delegate_(delegate),
  25       infobar_service_(NULL),
  26       top_arrow_target_height_(InfoBar::kDefaultArrowTargetHeight) {
  27 }
  28
  29 InfoBarContainer::~InfoBarContainer() {
  30   // RemoveAllInfoBarsForDestruction() should have already cleared our infobars.
  31   DCHECK(infobars_.empty());
  32 }
  33
  34 void InfoBarContainer::ChangeInfoBarService(InfoBarService* infobar_service) {
  35   HideAllInfoBars();
  36
  37   infobar_service_ = infobar_service;
  38   if (infobar_service_) {
  39     content::Source<InfoBarService> source(infobar_service_);
  40     registrar_.Add(this, chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_ADDED,
  41                    source);
  42     registrar_.Add(this, chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REMOVED,
  43                    source);
  44     registrar_.Add(this, chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REPLACED,
  45                    source);
  46
  47     for (size_t i = 0; i < infobar_service_->infobar_count(); ++i) {
  48       // As when we removed the infobars above, we prevent callbacks to
  49       // OnInfoBarAnimated() for each infobar.
  50       AddInfoBar(infobar_service_->infobar_at(i), i, false, NO_CALLBACK);
  51     }
  52   }
  53
  54   // Now that everything is up to date, signal the delegate to re-layout.
  55   OnInfoBarStateChanged(false);
  56 }
  57
  58 int InfoBarContainer::GetVerticalOverlap(int* total_height) {
  59   // Our |total_height| is the sum of the preferred heights of the InfoBars
  60   // contained within us plus the |vertical_overlap|.
  61   int vertical_overlap = 0;
  62   int next_infobar_y = 0;
  63
  64   for (InfoBars::iterator i(infobars_.begin()); i != infobars_.end(); ++i) {
  65     InfoBar* infobar = *i;
  66     next_infobar_y -= infobar->arrow_height();
  67     vertical_overlap = std::max(vertical_overlap, -next_infobar_y);
  68     next_infobar_y += infobar->total_height();
  69   }
  70
  71   if (total_height)
  72     *total_height = next_infobar_y + vertical_overlap;
  73   return vertical_overlap;
  74 }
  75
  76 void InfoBarContainer::SetMaxTopArrowHeight(int height) {
  77   // Decrease the height by the arrow stroke thickness, which is the separator
  78   // line height, because the infobar arrow target heights are without-stroke.
  79   top_arrow_target_height_ = std::min(
  80       std::max(height - InfoBar::kSeparatorLineHeight, 0),
  81       InfoBar::kMaximumArrowTargetHeight);
  82   UpdateInfoBarArrowTargetHeights();
  83 }
  84
  85 void InfoBarContainer::OnInfoBarStateChanged(bool is_animating) {
  86   if (delegate_)
  87     delegate_->InfoBarContainerStateChanged(is_animating);
  88   UpdateInfoBarArrowTargetHeights();
  89   PlatformSpecificInfoBarStateChanged(is_animating);
  90 }
  91
  92 void InfoBarContainer::RemoveInfoBar(InfoBar* infobar) {
  93   infobar->set_container(NULL);
  94   InfoBars::iterator i(std::find(infobars_.begin(), infobars_.end(), infobar));
  95   DCHECK(i != infobars_.end());
  96   PlatformSpecificRemoveInfoBar(infobar);
  97   infobars_.erase(i);
  98 }
  99
 100 void InfoBarContainer::RemoveAllInfoBarsForDestruction() {
 101   // Before we remove any children, we reset |delegate_|, so that no removals
 102   // will result in us trying to call
 103   // delegate_->InfoBarContainerStateChanged().  This is important because at
 104   // this point |delegate_| may be shutting down, and it's at best unimportant
 105   // and at worst disastrous to call that.
 106   delegate_ = NULL;
 107   ChangeInfoBarService(NULL);
 108 }
 109
 110 void InfoBarContainer::Observe(int type,
 111                                const content::NotificationSource& source,
 112                                const content::NotificationDetails& details) {
 113   switch (type) {
 114     case chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_ADDED:
 115       AddInfoBar(content::Details<InfoBar::AddedDetails>(details).ptr(),
 116                  infobars_.size(), true, WANT_CALLBACK);
 117       break;
 118
 119     case chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REMOVED: {
 120       InfoBar::RemovedDetails* removed_details =
 121           content::Details<InfoBar::RemovedDetails>(details).ptr();
 122       removed_details->first->Hide(removed_details->second);
 123       UpdateInfoBarArrowTargetHeights();
 124       break;
 125     }
 126
 127     case chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REPLACED: {
 128       InfoBar::ReplacedDetails* replaced_details =
 129           content::Details<InfoBar::ReplacedDetails>(details).ptr();
 130       InfoBar* old_infobar = replaced_details->first;
 131       InfoBar* new_infobar = replaced_details->second;
 132       PlatformSpecificReplaceInfoBar(old_infobar, new_infobar);
 133       InfoBars::const_iterator i(std::find(infobars_.begin(), infobars_.end(),
 134                                            old_infobar));
 135       DCHECK(i != infobars_.end());
 136       size_t position = i - infobars_.begin();
 137       old_infobar->Hide(false);
 138       AddInfoBar(new_infobar, position, false, WANT_CALLBACK);
 139       break;
 140     }
 141
 142     default:
 143       NOTREACHED();
 144       break;
 145   }
 146 }
 147
 148 void InfoBarContainer::HideAllInfoBars() {
 149   registrar_.RemoveAll();
 150
 151   while (!infobars_.empty()) {
 152     InfoBar* infobar = infobars_.front();
 153     // Inform the infobar that it's hidden.  If it was already closing, this
 154     // deletes it.  Otherwise, this ensures the infobar will be deleted if it's
 155     // closed while it's not in an InfoBarContainer.
 156     infobar->Hide(false);
 157   }
 158 }
 159
 160 void InfoBarContainer::AddInfoBar(InfoBar* infobar,
 161                                   size_t position,
 162                                   bool animate,
 163                                   CallbackStatus callback_status) {
 164   DCHECK(std::find(infobars_.begin(), infobars_.end(), infobar) ==
 165       infobars_.end());
 166   DCHECK_LE(position, infobars_.size());
 167   infobars_.insert(infobars_.begin() + position, infobar);
 168   UpdateInfoBarArrowTargetHeights();
 169   PlatformSpecificAddInfoBar(infobar, position);
 170   if (callback_status == WANT_CALLBACK)
 171     infobar->set_container(this);
 172   infobar->Show(animate);
 173   if (callback_status == NO_CALLBACK)
 174     infobar->set_container(this);
 175 }
 176
 177 void InfoBarContainer::UpdateInfoBarArrowTargetHeights() {
 178   for (size_t i = 0; i < infobars_.size(); ++i)
 179     infobars_[i]->SetArrowTargetHeight(ArrowTargetHeightForInfoBar(i));
 180 }
 181
 182 int InfoBarContainer::ArrowTargetHeightForInfoBar(size_t infobar_index) const {
 183   if (!delegate_ || !delegate_->DrawInfoBarArrows(NULL))
 184     return 0;
 185   if (infobar_index == 0)
 186     return top_arrow_target_height_;
 187   const gfx::SlideAnimation& first_infobar_animation =
 188       const_cast<const InfoBar*>(infobars_.front())->animation();
 189   if ((infobar_index > 1) || first_infobar_animation.IsShowing())
 190     return InfoBar::kDefaultArrowTargetHeight;
 191   // When the first infobar is animating closed, we animate the second infobar's
 192   // arrow target height from the default to the top target height.  Note that
 193   // the animation values here are going from 1.0 -> 0.0 as the top bar closes.
 194   return top_arrow_target_height_ + static_cast<int>(
 195       (InfoBar::kDefaultArrowTargetHeight - top_arrow_target_height_) *
 196           first_infobar_animation.GetCurrentValue());
 197 }