components/infobars/core/infobar.cc

   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.h"
   6
   7 #include <cmath>
   8
   9 #include "base/logging.h"
  10 #include "build/build_config.h"
  11 #include "components/infobars/core/infobar_container.h"
  12 #include "components/infobars/core/infobar_manager.h"
  13 #include "ui/base/resource/material_design/material_design_controller.h"
  14 #include "ui/gfx/animation/slide_animation.h"
  15
  16 namespace infobars {
  17
  18 InfoBar::InfoBar(scoped_ptr<InfoBarDelegate> delegate)
  19     : owner_(NULL),
  20       delegate_(delegate.Pass()),
  21       container_(NULL),
  22       animation_(this),
  23       arrow_height_(0),
  24       arrow_target_height_(0),
  25       arrow_half_width_(0),
  26       bar_height_(0),
  27       bar_target_height_(-1) {
  28   DCHECK(delegate_ != NULL);
  29   animation_.SetTweenType(gfx::Tween::LINEAR);
  30   delegate_->set_infobar(this);
  31 }
  32
  33 InfoBar::~InfoBar() {
  34   DCHECK(!owner_);
  35 }
  36
  37 // static
  38 SkColor InfoBar::GetTopColor(InfoBarDelegate::Type infobar_type) {
  39   if (ui::MaterialDesignController::IsModeMaterial()) {
  40     static const SkColor kWarningBackgroundColorMd =
  41         SkColorSetRGB(0xFF, 0xEC, 0xB3);  // Yellow
  42     static const SkColor kPageActionBackgroundColorMd = SK_ColorWHITE;
  43
  44     return infobar_type == InfoBarDelegate::WARNING_TYPE ?
  45         kWarningBackgroundColorMd : kPageActionBackgroundColorMd;
  46   }
  47
  48   static const SkColor kWarningBackgroundColorTop =
  49       SkColorSetRGB(255, 242, 183);  // Yellow
  50   static const SkColor kPageActionBackgroundColorTop =
  51       SkColorSetRGB(237, 237, 237);  // Gray
  52   return (infobar_type == InfoBarDelegate::WARNING_TYPE) ?
  53       kWarningBackgroundColorTop : kPageActionBackgroundColorTop;
  54 }
  55
  56 // static
  57 SkColor InfoBar::GetBottomColor(InfoBarDelegate::Type infobar_type) {
  58   // No gradient in MD.
  59   if (ui::MaterialDesignController::IsModeMaterial())
  60     return GetTopColor(infobar_type);
  61
  62   static const SkColor kWarningBackgroundColorBottom =
  63       SkColorSetRGB(250, 230, 145);  // Yellow
  64   static const SkColor kPageActionBackgroundColorBottom =
  65       SkColorSetRGB(217, 217, 217);  // Gray
  66   return (infobar_type == InfoBarDelegate::WARNING_TYPE) ?
  67       kWarningBackgroundColorBottom : kPageActionBackgroundColorBottom;
  68 }
  69
  70 void InfoBar::SetOwner(InfoBarManager* owner) {
  71   DCHECK(!owner_);
  72   owner_ = owner;
  73   delegate_->set_nav_entry_id(owner->GetActiveEntryID());
  74   PlatformSpecificSetOwner();
  75 }
  76
  77 void InfoBar::Show(bool animate) {
  78   PlatformSpecificShow(animate);
  79   if (animate) {
  80     animation_.Show();
  81   } else {
  82     animation_.Reset(1.0);
  83     RecalculateHeights(true);
  84   }
  85 }
  86
  87 void InfoBar::Hide(bool animate) {
  88   PlatformSpecificHide(animate);
  89   if (animate) {
  90     animation_.Hide();
  91   } else {
  92     animation_.Reset(0.0);
  93     // We want to remove ourselves from the container immediately even if we
  94     // still have an owner, which MaybeDelete() won't do.
  95     DCHECK(container_);
  96     container_->RemoveInfoBar(this);
  97     MaybeDelete();  // Necessary if the infobar was already closing.
  98   }
  99 }
 100
 101 void InfoBar::SetArrowTargetHeight(int height) {
 102   // Once the closing animation starts, we ignore further requests to change the
 103   // target height.
 104   if ((arrow_target_height_ != height) && !animation_.IsClosing()) {
 105     arrow_target_height_ = height;
 106     RecalculateHeights(false);
 107   }
 108 }
 109
 110 void InfoBar::CloseSoon() {
 111   owner_ = NULL;
 112   PlatformSpecificOnCloseSoon();
 113   MaybeDelete();
 114 }
 115
 116 void InfoBar::RemoveSelf() {
 117   if (owner_)
 118     owner_->RemoveInfoBar(this);
 119 }
 120
 121 void InfoBar::SetBarTargetHeight(int height) {
 122   if (bar_target_height_ != height) {
 123     bar_target_height_ = height;
 124     RecalculateHeights(false);
 125   }
 126 }
 127
 128 void InfoBar::AnimationProgressed(const gfx::Animation* animation) {
 129   RecalculateHeights(false);
 130 }
 131
 132 void InfoBar::AnimationEnded(const gfx::Animation* animation) {
 133   // When the animation ends, we must ensure the container is notified even if
 134   // the heights haven't changed, lest it never get an "animation finished"
 135   // notification.  (If the browser doesn't get this notification, it will not
 136   // bother to re-layout the content area for the new infobar size.)
 137   RecalculateHeights(true);
 138   MaybeDelete();
 139 }
 140
 141 void InfoBar::RecalculateHeights(bool force_notify) {
 142   // If there's no container delegate, there's no way to compute new element
 143   // sizes, so return immediately.  We don't need to worry that this might leave
 144   // us with bogus sizes, because if we're ever re-added to a container, it will
 145   // call Show(false) while re-adding us, which will compute a correct set of
 146   // sizes.
 147   if (!container_ || !container_->delegate())
 148     return;
 149
 150   int old_arrow_height = arrow_height_;
 151   int old_bar_height = bar_height_;
 152
 153   container_->delegate()->ComputeInfoBarElementSizes(
 154       animation_, arrow_target_height_, bar_target_height_, &arrow_height_,
 155       &arrow_half_width_, &bar_height_);
 156
 157   // Don't re-layout if nothing has changed, e.g. because the animation step was
 158   // not large enough to actually change the heights by at least a pixel.
 159   bool heights_differ =
 160       (old_arrow_height != arrow_height_) || (old_bar_height != bar_height_);
 161   if (heights_differ)
 162     PlatformSpecificOnHeightsRecalculated();
 163
 164   if (heights_differ || force_notify)
 165     container_->OnInfoBarStateChanged(animation_.is_animating());
 166 }
 167
 168 void InfoBar::MaybeDelete() {
 169   if (!owner_ && (animation_.GetCurrentValue() == 0.0)) {
 170     if (container_)
 171       container_->RemoveInfoBar(this);
 172     delete this;
 173   }
 174 }
 175
 176 }  // namespace infobars