Preliminary cleanup of ShelfButton activity/status indicator.

ash/common/shelf/shelf_button.cc

 // Copyright 2013 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 "ash/common/shelf/shelf_button.h"
 
 #include <algorithm>
 
 #include "ash/common/ash_constants.h"
 #include "ash/common/shelf/ink_drop_button_listener.h"
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shelf/shelf_view.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "skia/ext/image_operations.h"
 #include "ui/accessibility/ax_node_data.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/animation/animation_delegate.h"
 #include "ui/gfx/animation/throb_animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/vector2d.h"
 #include "ui/gfx/image/image_skia_operations.h"
+#include "ui/gfx/scoped_canvas.h"
 #include "ui/gfx/skbitmap_operations.h"
 #include "ui/views/animation/ink_drop_impl.h"
 #include "ui/views/animation/square_ink_drop_ripple.h"
 #include "ui/views/controls/image_view.h"
 
 namespace {
 
-// Size of the bar. This is along the opposite axis of the shelf. For example,
-// if the shelf is aligned horizontally then this is the height of the bar.
-const int kBarSize = 3;
 const int kIconSize = 32;
 const int kAttentionThrobDurationMS = 800;
 const int kMaxAnimationSeconds = 10;
 const int kIndicatorOffsetFromBottom = 2;
-const int kIndicatorRadius = 2;
+const int kIndicatorRadiusDip = 2;
 const SkColor kIndicatorColor = SK_ColorWHITE;
-// Canvas scale to ensure that the activity indicator is not pixelated even at
-// the highest possible device scale factors.
-const int kIndicatorCanvasScale = 5;
 
 // Shelf item ripple constants.
 const int kInkDropSmallSize = 48;
 const int kInkDropLargeSize = 60;
 
 // Padding from the edge of the shelf to the application icon when the shelf
 // is horizontally and vertically aligned, respectively.
 const int kIconPaddingHorizontal = 7;
 const int kIconPaddingVertical = 8;
 
-// Paints an activity indicator on |canvas| whose |size| is specified in DIP.
-void PaintIndicatorOnCanvas(gfx::Canvas* canvas, const gfx::Size& size) {
-  cc::PaintFlags flags;
-  flags.setAntiAlias(true);
-  flags.setColor(kIndicatorColor);
-  canvas->DrawCircle(
-      gfx::Point(size.width() / 2,
-                 size.height() - kIndicatorOffsetFromBottom - kIndicatorRadius),
-      kIndicatorRadius, flags);
-}
-
 // Simple AnimationDelegate that owns a single ThrobAnimation instance to
 // keep all Draw Attention animations in sync.
 class ShelfButtonAnimation : public gfx::AnimationDelegate {
  public:
   class Observer {
    public:
     virtual void AnimationProgressed() = 0;
 
    protected:
     virtual ~Observer() {}
   };
 
   static ShelfButtonAnimation* GetInstance() {
     static ShelfButtonAnimation* s_instance = new ShelfButtonAnimation();
     return s_instance;
   }
 
   void AddObserver(Observer* observer) { observers_.AddObserver(observer); }
 
   void RemoveObserver(Observer* observer) {
     observers_.RemoveObserver(observer);
     if (!observers_.might_have_observers())
       animation_.Stop();
   }
 
-  int GetAlpha() { return GetThrobAnimation().CurrentValueBetween(0, 255); }
+  bool HasObserver(Observer* observer) const {
+    return observers_.HasObserver(observer);
+  }
+
+  SkAlpha GetAlpha() {
+    return GetThrobAnimation().CurrentValueBetween(SK_AlphaTRANSPARENT,
+                                                   SK_AlphaOPAQUE);
+  }
 
   double GetAnimation() { return GetThrobAnimation().GetCurrentValue(); }
 
  private:
   ShelfButtonAnimation() : animation_(this) {
     animation_.SetThrobDuration(kAttentionThrobDurationMS);
     animation_.SetTweenType(gfx::Tween::SMOOTH_IN_OUT);
   }
 
   ~ShelfButtonAnimation() override {}
@@ skipping 20 matching lines @@
   base::ObserverList<Observer> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(ShelfButtonAnimation);
 };
 
 }  // namespace
 
 namespace ash {
 
 ////////////////////////////////////////////////////////////////////////////////
-// ShelfButton::BarView
+// ShelfButton::AppStatusIndicatorView
 
-class ShelfButton::BarView : public views::ImageView,
-                             public ShelfButtonAnimation::Observer {
+class ShelfButton::AppStatusIndicatorView
+    : public views::View,
+      public ShelfButtonAnimation::Observer {
  public:
-  BarView(WmShelf* wm_shelf)
-      : wm_shelf_(wm_shelf),
-        show_attention_(false),
-        animation_end_time_(base::TimeTicks()),
-        animating_(false) {
+  AppStatusIndicatorView()
+      : show_attention_(false), animation_end_time_(base::TimeTicks()) {
     // Make sure the events reach the parent view for handling.
     set_can_process_events_within_subtree(false);
   }
 
-  ~BarView() override {
-    if (show_attention_)
-      ShelfButtonAnimation::GetInstance()->RemoveObserver(this);
+  ~AppStatusIndicatorView() override {
+    ShelfButtonAnimation::GetInstance()->RemoveObserver(this);
   }
 
   // views::View:
   void OnPaint(gfx::Canvas* canvas) override {
+    gfx::ScopedCanvas scoped(canvas);
     if (show_attention_) {
-      int alpha =
-          animating_ ? ShelfButtonAnimation::GetInstance()->GetAlpha() : 255;
+      SkAlpha alpha = ShelfButtonAnimation::GetInstance()->HasObserver(this)
+                          ? ShelfButtonAnimation::GetInstance()->GetAlpha()
+                          : SK_AlphaOPAQUE;
       canvas->SaveLayerAlpha(alpha);
-      views::ImageView::OnPaint(canvas);
-      canvas->Restore();
-    } else {
-      views::ImageView::OnPaint(canvas);
     }
+
+    DCHECK_EQ(width(), height());
+    DCHECK_EQ(kIndicatorRadiusDip, width() / 2);
+    cc::PaintFlags flags;
+    flags.setColor(kIndicatorColor);
+    flags.setFlags(cc::PaintFlags::kAntiAlias_Flag);
+    canvas->DrawCircle(gfx::Point(width() / 2, height() / 2),
+                       kIndicatorRadiusDip, flags);
   }
 
   // ShelfButtonAnimation::Observer
   void AnimationProgressed() override {
-    UpdateBounds();
+    UpdateAnimating();
     SchedulePaint();
   }
 
-  void SetBarBoundsRect(const gfx::Rect& bounds) {
-    base_bounds_ = bounds;
-    UpdateBounds();
-  }
+  void ShowAttention(bool show) {
+    if (show_attention_ == show)
+      return;
 
-  void ShowAttention(bool show) {
-    if (show_attention_ != show) {
-      show_attention_ = show;
-      if (show_attention_) {
-        animating_ = true;
-        animation_end_time_ =
-            base::TimeTicks::Now() +
-            base::TimeDelta::FromSeconds(kMaxAnimationSeconds);
-        ShelfButtonAnimation::GetInstance()->AddObserver(this);
-      } else {
-        animating_ = false;
-        ShelfButtonAnimation::GetInstance()->RemoveObserver(this);
-      }
-    }
-    UpdateBounds();
-  }
-
- private:
-  void UpdateBounds() {
-    gfx::Rect bounds = base_bounds_;
+    show_attention_ = show;
     if (show_attention_) {
-      // Scale from .35 to 1.0 of the total width (which is wider than the
-      // visible width of the image), so the animation "rests" briefly at full
-      // visible width.  Cap bounds length at kIconSize to prevent visual
-      // flutter while centering bar within further expanding bounds.
-      double animation =
-          animating_ ? ShelfButtonAnimation::GetInstance()->GetAnimation()
-                     : 1.0;
-      double scale = .35 + .65 * animation;
-      if (wm_shelf_->IsHorizontalAlignment()) {
-        int width = base_bounds_.width() * scale;
-        bounds.set_width(std::min(width, kIconSize));
-        int x_offset = (base_bounds_.width() - bounds.width()) / 2;
-        bounds.set_x(base_bounds_.x() + x_offset);
-        UpdateAnimating(bounds.width() == kIconSize);
-      } else {
-        int height = base_bounds_.height() * scale;
-        bounds.set_height(std::min(height, kIconSize));
-        int y_offset = (base_bounds_.height() - bounds.height()) / 2;
-        bounds.set_y(base_bounds_.y() + y_offset);
-        UpdateAnimating(bounds.height() == kIconSize);
-      }
-    }
-    SetBoundsRect(bounds);
-  }
-
-  void UpdateAnimating(bool max_length) {
-    if (!max_length)
-      return;
-    if (base::TimeTicks::Now() > animation_end_time_) {
-      animating_ = false;
+      animation_end_time_ = base::TimeTicks::Now() +
+                            base::TimeDelta::FromSeconds(kMaxAnimationSeconds);
+      ShelfButtonAnimation::GetInstance()->AddObserver(this);
+    } else {
       ShelfButtonAnimation::GetInstance()->RemoveObserver(this);
     }
   }
 
-  WmShelf* wm_shelf_;
+ private:
+  void UpdateAnimating() {
+    if (base::TimeTicks::Now() > animation_end_time_)
+      ShelfButtonAnimation::GetInstance()->RemoveObserver(this);
+  }
+
   bool show_attention_;
   base::TimeTicks animation_end_time_;  // For attention throbbing underline.
-  bool animating_;  // Is time-limited attention animation running?
-  gfx::Rect base_bounds_;
 
-  DISALLOW_COPY_AND_ASSIGN(BarView);
+  DISALLOW_COPY_AND_ASSIGN(AppStatusIndicatorView);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfButton
 
 // static
 const char ShelfButton::kViewClassName[] = "ash/ShelfButton";
 
 ShelfButton::ShelfButton(InkDropButtonListener* listener, ShelfView* shelf_view)
     : CustomButton(nullptr),
       listener_(listener),
       shelf_view_(shelf_view),
       icon_view_(new views::ImageView()),
-      bar_(new BarView(shelf_view->wm_shelf())),
+      indicator_(new AppStatusIndicatorView()),
       state_(STATE_NORMAL),
       destroyed_flag_(nullptr) {
   SetFocusBehavior(FocusBehavior::ACCESSIBLE_ONLY);
   SetInkDropMode(InkDropMode::ON);
   set_ink_drop_base_color(kShelfInkDropBaseColor);
   set_ink_drop_visible_opacity(kShelfInkDropVisibleOpacity);
 
   const gfx::ShadowValue kShadows[] = {
       gfx::ShadowValue(gfx::Vector2d(0, 2), 0, SkColorSetARGB(0x1A, 0, 0, 0)),
       gfx::ShadowValue(gfx::Vector2d(0, 3), 1, SkColorSetARGB(0x1A, 0, 0, 0)),
       gfx::ShadowValue(gfx::Vector2d(0, 0), 1, SkColorSetARGB(0x54, 0, 0, 0)),
   };
   icon_shadows_.assign(kShadows, kShadows + arraysize(kShadows));
 
   // TODO: refactor the layers so each button doesn't require 2.
   icon_view_->SetPaintToLayer();
   icon_view_->layer()->SetFillsBoundsOpaquely(false);
   icon_view_->SetHorizontalAlignment(views::ImageView::CENTER);
   icon_view_->SetVerticalAlignment(views::ImageView::LEADING);
   // Do not make this interactive, so that events are sent to ShelfView.
   icon_view_->set_can_process_events_within_subtree(false);
 
-  AddChildView(bar_);
+  AddChildView(indicator_);
   AddChildView(icon_view_);
 }
 
 ShelfButton::~ShelfButton() {
   if (destroyed_flag_)
     *destroyed_flag_ = true;
 }
 
 void ShelfButton::SetShadowedImage(const gfx::ImageSkia& image) {
   icon_view_->SetImage(gfx::ImageSkiaOperations::CreateImageWithDropShadow(
@@ skipping 28 matching lines @@
 
 const gfx::ImageSkia& ShelfButton::GetImage() const {
   return icon_view_->GetImage();
 }
 
 void ShelfButton::AddState(State state) {
   if (!(state_ & state)) {
     state_ |= state;
     Layout();
     if (state & STATE_ATTENTION)
-      bar_->ShowAttention(true);
+      indicator_->ShowAttention(true);
   }
 }
 
 void ShelfButton::ClearState(State state) {
   if (state_ & state) {
     state_ &= ~state;
     Layout();
     if (state & STATE_ATTENTION)
-      bar_->ShowAttention(false);
+      indicator_->ShowAttention(false);
   }
 }
 
 gfx::Rect ShelfButton::GetIconBounds() const {
   return icon_view_->bounds();
 }
 
 void ShelfButton::OnDragStarted(const ui::LocatedEvent* event) {
   AnimateInkDrop(views::InkDropState::HIDDEN, event);
 }
@@ skipping 59 matching lines @@
   int y_offset = is_horizontal_shelf ? icon_pad : 0;
 
   int icon_width = std::min(kIconSize, button_bounds.width() - x_offset);
   int icon_height = std::min(kIconSize, button_bounds.height() - y_offset);
 
   // If on the left or top 'invert' the inset so the constant gap is on
   // the interior (towards the center of display) edge of the shelf.
   if (SHELF_ALIGNMENT_LEFT == wm_shelf->GetAlignment())
     x_offset = button_bounds.width() - (kIconSize + icon_pad);
 
-  // Center icon with respect to the secondary axis, and ensure
-  // that the icon doesn't occlude the bar highlight.
-  if (is_horizontal_shelf) {
+  // Center icon with respect to the secondary axis.
+  if (is_horizontal_shelf)
     x_offset = std::max(0, button_bounds.width() - icon_width) / 2;
-    if (y_offset + icon_height + kBarSize > button_bounds.height())
-      icon_height = button_bounds.height() - (y_offset + kBarSize);
-  } else {
+  else
     y_offset = std::max(0, button_bounds.height() - icon_height) / 2;
-    if (x_offset + icon_width + kBarSize > button_bounds.width())
-      icon_width = button_bounds.width() - (x_offset + kBarSize);
-  }
 
   // Expand bounds to include shadows.
   gfx::Insets insets_shadows = gfx::ShadowValue::GetMargin(icon_shadows_);
   // Adjust offsets to center icon, not icon + shadow.
   x_offset += (insets_shadows.left() - insets_shadows.right()) / 2;
   y_offset += (insets_shadows.top() - insets_shadows.bottom()) / 2;
   gfx::Rect icon_view_bounds =
       gfx::Rect(button_bounds.x() + x_offset, button_bounds.y() + y_offset,
                 icon_width, icon_height);
+  // The indicator should be aligned with the icon, not the icon + shadow.
+  gfx::Point indicator_midpoint = icon_view_bounds.CenterPoint();
   icon_view_bounds.Inset(insets_shadows);
   icon_view_bounds.AdjustToFit(gfx::Rect(size()));
   icon_view_->SetBoundsRect(icon_view_bounds);
 
   // Icon size has been incorrect when running
   // PanelLayoutManagerTest.PanelAlignmentSecondDisplay on valgrind bot, see
   // http://crbug.com/234854.
   DCHECK_LE(icon_width, kIconSize);
   DCHECK_LE(icon_height, kIconSize);
 
-  bar_->SetBarBoundsRect(button_bounds);
+  switch (wm_shelf->GetAlignment()) {
+    case SHELF_ALIGNMENT_BOTTOM:
+    case SHELF_ALIGNMENT_BOTTOM_LOCKED:
+      indicator_midpoint.set_y(button_bounds.bottom() - kIndicatorRadiusDip -
+                               kIndicatorOffsetFromBottom);
+      break;
+    case SHELF_ALIGNMENT_LEFT:
+      indicator_midpoint.set_x(button_bounds.x() + kIndicatorRadiusDip +
+                               kIndicatorOffsetFromBottom);
+      break;
+    case SHELF_ALIGNMENT_RIGHT:
+      indicator_midpoint.set_x(button_bounds.right() - kIndicatorRadiusDip -
+                               kIndicatorOffsetFromBottom);
+      break;
+  }
+
+  gfx::Rect indicator_bounds(indicator_midpoint, gfx::Size());
+  indicator_bounds.Inset(gfx::Insets(-kIndicatorRadiusDip));
+  indicator_->SetBoundsRect(indicator_bounds);
 
   UpdateState();
 }
 
 void ShelfButton::ChildPreferredSizeChanged(views::View* child) {
   Layout();
 }
 
 void ShelfButton::OnFocus() {
   AddState(STATE_FOCUSED);
@@ skipping 62 matching lines @@
   return std::move(ink_drop);
 }
 
 void ShelfButton::NotifyClick(const ui::Event& event) {
   CustomButton::NotifyClick(event);
   if (listener_)
     listener_->ButtonPressed(this, event, GetInkDrop());
 }
 
 void ShelfButton::UpdateState() {
-  UpdateBar();
+  indicator_->SetVisible(!(state_ & STATE_HIDDEN) &&
+                         (state_ & STATE_ACTIVE || state_ & STATE_ATTENTION ||
+                          state_ & STATE_RUNNING));
+
   const bool is_horizontal_shelf =
       shelf_view_->wm_shelf()->IsHorizontalAlignment();
   icon_view_->SetHorizontalAlignment(is_horizontal_shelf
                                          ? views::ImageView::CENTER
                                          : views::ImageView::LEADING);
   icon_view_->SetVerticalAlignment(is_horizontal_shelf
                                        ? views::ImageView::LEADING
                                        : views::ImageView::CENTER);
   SchedulePaint();
 }
 
-void ShelfButton::UpdateBar() {
-  bool draw_bar = !(state_ & STATE_HIDDEN) &&
-                  (state_ & STATE_ACTIVE || state_ & STATE_ATTENTION ||
-                   state_ & STATE_RUNNING);
-
-  if (draw_bar) {
-    WmShelf* wm_shelf = shelf_view_->wm_shelf();
-    gfx::ImageSkia image;
-    if (wm_shelf->IsVisible()) {
-      gfx::Size size(kShelfButtonSize, GetShelfConstant(SHELF_SIZE));
-      gfx::Canvas canvas(size, kIndicatorCanvasScale, true /* is_opaque */);
-      PaintIndicatorOnCanvas(&canvas, size);
-      image = gfx::ImageSkia(canvas.ExtractImageRep());
-    }
-    ShelfAlignment shelf_alignment = wm_shelf->GetAlignment();
-    if (!wm_shelf->IsHorizontalAlignment()) {
-      image = gfx::ImageSkiaOperations::CreateRotatedImage(
-          image, shelf_alignment == SHELF_ALIGNMENT_LEFT
-                     ? SkBitmapOperations::ROTATION_90_CW
-                     : SkBitmapOperations::ROTATION_270_CW);
-    }
-    bar_->SetImage(image);
-    switch (shelf_alignment) {
-      case SHELF_ALIGNMENT_BOTTOM:
-      case SHELF_ALIGNMENT_BOTTOM_LOCKED:
-        bar_->SetHorizontalAlignment(views::ImageView::CENTER);
-        bar_->SetVerticalAlignment(views::ImageView::TRAILING);
-        break;
-      case SHELF_ALIGNMENT_LEFT:
-        bar_->SetHorizontalAlignment(views::ImageView::LEADING);
-        bar_->SetVerticalAlignment(views::ImageView::CENTER);
-        break;
-      case SHELF_ALIGNMENT_RIGHT:
-        bar_->SetHorizontalAlignment(views::ImageView::TRAILING);
-        bar_->SetVerticalAlignment(views::ImageView::CENTER);
-        break;
-    }
-    bar_->SchedulePaint();
-  }
-
-  bar_->SetVisible(draw_bar);
-}
-
 }  // namespace ash