Home | History | Annotate | Download | only in core 
      1 // Copyright 2014 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 "components/infobars/core/infobar_container.h"
      6 
      7 #include <algorithm>
      8 
      9 #include "base/logging.h"
     10 #include "build/build_config.h"
     11 #include "components/infobars/core/infobar.h"
     12 #include "components/infobars/core/infobar_delegate.h"
     13 #include "ui/gfx/animation/slide_animation.h"
     14 
     15 namespace infobars {
     16 
     17 InfoBarContainer::Delegate::~Delegate() {
     18 }
     19 
     20 InfoBarContainer::InfoBarContainer(Delegate* delegate)
     21     : delegate_(delegate),
     22       infobar_manager_(NULL),
     23       top_arrow_target_height_(InfoBar::kDefaultArrowTargetHeight) {
     24 }
     25 
     26 InfoBarContainer::~InfoBarContainer() {
     27   // RemoveAllInfoBarsForDestruction() should have already cleared our infobars.
     28   DCHECK(infobars_.empty());
     29   if (infobar_manager_)
     30     infobar_manager_->RemoveObserver(this);
     31 }
     32 
     33 void InfoBarContainer::ChangeInfoBarManager(InfoBarManager* infobar_manager) {
     34   if (infobar_manager_)
     35     infobar_manager_->RemoveObserver(this);
     36 
     37   // Hides all infobars in this container without animation.
     38   while (!infobars_.empty()) {
     39     InfoBar* infobar = infobars_.front();
     40     // Inform the infobar that it's hidden.  If it was already closing, this
     41     // deletes it.  Otherwise, this ensures the infobar will be deleted if it's
     42     // closed while it's not in an InfoBarContainer.
     43     infobar->Hide(false);
     44   }
     45 
     46   infobar_manager_ = infobar_manager;
     47   if (infobar_manager_) {
     48     infobar_manager_->AddObserver(this);
     49 
     50     for (size_t i = 0; i < infobar_manager_->infobar_count(); ++i) {
     51       // As when we removed the infobars above, we prevent callbacks to
     52       // OnInfoBarStateChanged() for each infobar.
     53       AddInfoBar(infobar_manager_->infobar_at(i), i, false, NO_CALLBACK);
     54     }
     55   }
     56 
     57   // Now that everything is up to date, signal the delegate to re-layout.
     58   OnInfoBarStateChanged(false);
     59 }
     60 
     61 int InfoBarContainer::GetVerticalOverlap(int* total_height) const {
     62   // Our |total_height| is the sum of the preferred heights of the InfoBars
     63   // contained within us plus the |vertical_overlap|.
     64   int vertical_overlap = 0;
     65   int next_infobar_y = 0;
     66 
     67   for (InfoBars::const_iterator i(infobars_.begin()); i != infobars_.end();
     68        ++i) {
     69     InfoBar* infobar = *i;
     70     next_infobar_y -= infobar->arrow_height();
     71     vertical_overlap = std::max(vertical_overlap, -next_infobar_y);
     72     next_infobar_y += infobar->total_height();
     73   }
     74 
     75   if (total_height)
     76     *total_height = next_infobar_y + vertical_overlap;
     77   return vertical_overlap;
     78 }
     79 
     80 void InfoBarContainer::SetMaxTopArrowHeight(int height) {
     81   // Decrease the height by the arrow stroke thickness, which is the separator
     82   // line height, because the infobar arrow target heights are without-stroke.
     83   top_arrow_target_height_ = std::min(
     84       std::max(height - InfoBar::kSeparatorLineHeight, 0),
     85       InfoBar::kMaximumArrowTargetHeight);
     86   UpdateInfoBarArrowTargetHeights();
     87 }
     88 
     89 void InfoBarContainer::OnInfoBarStateChanged(bool is_animating) {
     90   if (delegate_)
     91     delegate_->InfoBarContainerStateChanged(is_animating);
     92   UpdateInfoBarArrowTargetHeights();
     93   PlatformSpecificInfoBarStateChanged(is_animating);
     94 }
     95 
     96 void InfoBarContainer::RemoveInfoBar(InfoBar* infobar) {
     97   infobar->set_container(NULL);
     98   InfoBars::iterator i(std::find(infobars_.begin(), infobars_.end(), infobar));
     99   DCHECK(i != infobars_.end());
    100   PlatformSpecificRemoveInfoBar(infobar);
    101   infobars_.erase(i);
    102 }
    103 
    104 void InfoBarContainer::RemoveAllInfoBarsForDestruction() {
    105   // Before we remove any children, we reset |delegate_|, so that no removals
    106   // will result in us trying to call
    107   // delegate_->InfoBarContainerStateChanged().  This is important because at
    108   // this point |delegate_| may be shutting down, and it's at best unimportant
    109   // and at worst disastrous to call that.
    110   delegate_ = NULL;
    111   ChangeInfoBarManager(NULL);
    112 }
    113 
    114 void InfoBarContainer::OnInfoBarAdded(InfoBar* infobar) {
    115   AddInfoBar(infobar, infobars_.size(), true, WANT_CALLBACK);
    116 }
    117 
    118 void InfoBarContainer::OnInfoBarRemoved(InfoBar* infobar, bool animate) {
    119   infobar->Hide(animate);
    120   UpdateInfoBarArrowTargetHeights();
    121 }
    122 
    123 void InfoBarContainer::OnInfoBarReplaced(InfoBar* old_infobar,
    124                                          InfoBar* new_infobar) {
    125   PlatformSpecificReplaceInfoBar(old_infobar, new_infobar);
    126   InfoBars::const_iterator i(std::find(infobars_.begin(), infobars_.end(),
    127                                        old_infobar));
    128   DCHECK(i != infobars_.end());
    129   size_t position = i - infobars_.begin();
    130   old_infobar->Hide(false);
    131   AddInfoBar(new_infobar, position, false, WANT_CALLBACK);
    132 }
    133 
    134 void InfoBarContainer::OnManagerShuttingDown(InfoBarManager* manager) {
    135   DCHECK_EQ(infobar_manager_, manager);
    136   infobar_manager_->RemoveObserver(this);
    137   infobar_manager_ = NULL;
    138 }
    139 
    140 void InfoBarContainer::AddInfoBar(InfoBar* infobar,
    141                                   size_t position,
    142                                   bool animate,
    143                                   CallbackStatus callback_status) {
    144   DCHECK(std::find(infobars_.begin(), infobars_.end(), infobar) ==
    145       infobars_.end());
    146   DCHECK_LE(position, infobars_.size());
    147   infobars_.insert(infobars_.begin() + position, infobar);
    148   UpdateInfoBarArrowTargetHeights();
    149   PlatformSpecificAddInfoBar(infobar, position);
    150   if (callback_status == WANT_CALLBACK)
    151     infobar->set_container(this);
    152   infobar->Show(animate);
    153   if (callback_status == NO_CALLBACK)
    154     infobar->set_container(this);
    155 }
    156 
    157 void InfoBarContainer::UpdateInfoBarArrowTargetHeights() {
    158   for (size_t i = 0; i < infobars_.size(); ++i)
    159     infobars_[i]->SetArrowTargetHeight(ArrowTargetHeightForInfoBar(i));
    160 }
    161 
    162 int InfoBarContainer::ArrowTargetHeightForInfoBar(size_t infobar_index) const {
    163   if (!delegate_ || !delegate_->DrawInfoBarArrows(NULL))
    164     return 0;
    165   if (infobar_index == 0)
    166     return top_arrow_target_height_;
    167   const gfx::SlideAnimation& first_infobar_animation =
    168       const_cast<const InfoBar*>(infobars_.front())->animation();
    169   if ((infobar_index > 1) || first_infobar_animation.IsShowing())
    170     return InfoBar::kDefaultArrowTargetHeight;
    171   // When the first infobar is animating closed, we animate the second infobar's
    172   // arrow target height from the default to the top target height.  Note that
    173   // the animation values here are going from 1.0 -> 0.0 as the top bar closes.
    174   return top_arrow_target_height_ + static_cast<int>(
    175       (InfoBar::kDefaultArrowTargetHeight - top_arrow_target_height_) *
    176           first_infobar_animation.GetCurrentValue());
    177 }
    178 
    179 }  // namespace infobars
    180