Use a layer transform for the waiting throbber

chrome/browser/ui/views/tabs/tab.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 "chrome/browser/ui/views/tabs/tab.h"
 
 #include <limits>
 
 #include "base/command_line.h"
 #include "base/debug/alias.h"
@@ skipping 12 matching lines @@
 #include "chrome/common/chrome_switches.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/user_metrics.h"
 #include "grit/theme_resources.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/list_selection_model.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/theme_provider.h"
+#include "ui/compositor/layer_animator.h"
+#include "ui/compositor/paint_recorder.h"
 #include "ui/gfx/animation/animation_container.h"
 #include "ui/gfx/animation/multi_animation.h"
 #include "ui/gfx/animation/throb_animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_analysis.h"
 #include "ui/gfx/favicon_size.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/paint_vector_icon.h"
 #include "ui/gfx/path.h"
@@ skipping 87 matching lines @@
 // The minimum opacity (out of 1) when a tab (either active or inactive) is
 // throbbing in the immersive mode light strip.
 const double kImmersiveTabMinThrobOpacity = 0.66;
 
 // Number of steps in the immersive mode loading animation.
 const int kImmersiveLoadingStepCount = 32;
 
 const char kTabCloseButtonName[] = "TabCloseButton";
 const int kTabCloseButtonSize = 16;
 
-// Layer-backed view for updating a waiting or loading tab spinner.
-class ThrobberView : public views::View {
- public:
-  explicit ThrobberView(Tab* owner) : owner_(owner) {
-    // Since the throbber animates, paint to a separate layer do reduce repaint
-    // overheads.
-    SetPaintToLayer(true);
-    SetFillsBoundsOpaquely(false);
-  }
-
-  // views::View:
-  bool CanProcessEventsWithinSubtree() const override { return false; }
-
-  void OnPaint(gfx::Canvas* canvas) override {
-    const TabRendererData::NetworkState state = owner_->data().network_state;
-    if (state == TabRendererData::NETWORK_STATE_NONE)
-      return;
-
-    const gfx::Rect bounds = GetLocalBounds();
-
-    // Paint network activity (aka throbber) animation frame.
-    ui::ThemeProvider* tp = GetThemeProvider();
-    if (state == TabRendererData::NETWORK_STATE_WAITING) {
-      if (waiting_start_time_ == base::TimeTicks())
-        waiting_start_time_ = base::TimeTicks::Now();
-
-      waiting_state_.elapsed_time =
-          base::TimeTicks::Now() - waiting_start_time_;
-      gfx::PaintThrobberWaiting(
-          canvas, bounds, tp->GetColor(ThemeProperties::COLOR_THROBBER_WAITING),
-          waiting_state_.elapsed_time);
-    } else {
-      if (loading_start_time_ == base::TimeTicks())
-        loading_start_time_ = base::TimeTicks::Now();
-
-      waiting_state_.color =
-          tp->GetColor(ThemeProperties::COLOR_THROBBER_WAITING);
-      gfx::PaintThrobberSpinningAfterWaiting(
-          canvas, bounds,
-          tp->GetColor(ThemeProperties::COLOR_THROBBER_SPINNING),
-          base::TimeTicks::Now() - loading_start_time_, &waiting_state_);
-    }
-  }
-
- private:
-  Tab* owner_;  // Weak. Owns |this|.
-
-  // The point in time when the tab icon was first painted in the waiting state.
-  base::TimeTicks waiting_start_time_;
-
-  // The point in time when the tab icon was first painted in the loading state.
-  base::TimeTicks loading_start_time_;
-
-  // Paint state for the throbber after the most recent waiting paint.
-  gfx::ThrobberWaitingState waiting_state_;
-
-  DISALLOW_COPY_AND_ASSIGN(ThrobberView);
-};
-
 void DrawIconAtLocation(gfx::Canvas* canvas,
                         const gfx::ImageSkia& image,
                         int image_offset,
                         int dst_x,
                         int dst_y,
                         int icon_width,
                         int icon_height,
                         bool filter,
                         const SkPaint& paint) {
   // NOTE: the clipping is a work around for 69528, it shouldn't be necessary.
@@ skipping 235 matching lines @@
 // ImageCacheEntry
 
 Tab::ImageCacheEntry::ImageCacheEntry()
     : resource_id(-1),
       scale_factor(ui::SCALE_FACTOR_NONE) {
 }
 
 Tab::ImageCacheEntry::~ImageCacheEntry() {}
 
 ////////////////////////////////////////////////////////////////////////////////
+// ThrobberView
+
+// Layer-backed view for updating a waiting or loading tab spinner.
+class Tab::ThrobberView : public views::View {
+ public:
+  explicit ThrobberView(Tab* owner) : owner_(owner), waiting_arc_(180) {
+    // Since the throbber animates, paint to a separate layer do reduce repaint
+    // overheads.
+    SetPaintToLayer(true);
+    SetFillsBoundsOpaquely(false);
+
+    waiting_mask_.SetFillsBoundsOpaquely(false);
+    waiting_mask_.SetMasksToBounds(true);
+    waiting_mask_.Add(waiting_arc_.layer());
+  }
+
+  void SchedulePaintIfRequired() {
+    if (NeedsPaint())
+      SchedulePaint();
+  }
+
+  // views::View:
+  bool CanProcessEventsWithinSubtree() const override { return false; }
+
+  void OnBoundsChanged(const gfx::Rect& previous_bounds) override {
+    gfx::Rect bounds = GetLocalBounds();
+    waiting_arc_.layer()->SetBounds(
+        gfx::Rect(0, 0, bounds.width() * Arc::kAA, bounds.height() * Arc::kAA));
+
+    bounds.set_width(bounds.width() / 2);
+    waiting_mask_.SetBounds(bounds);
+  }
+
+  void OnPaint(gfx::Canvas* canvas) override {
+    if (state_ == TabRendererData::NETWORK_STATE_NONE)
+      return;
+
+    const gfx::Rect bounds = GetLocalBounds();
+
+    // Paint network activity (aka throbber) animation frame.
+    ui::ThemeProvider* tp = owner_->GetThemeProvider();
+    if (state_ == TabRendererData::NETWORK_STATE_WAITING) {
+      // Painted by Arc.
+    } else {
+      if (loading_start_time_ == base::TimeTicks())
+        loading_start_time_ = base::TimeTicks::Now();
+
+      waiting_state_.color =
+          tp->GetColor(ThemeProperties::COLOR_THROBBER_WAITING);
+      gfx::PaintThrobberSpinningAfterWaiting(
+          canvas, bounds,
+          tp->GetColor(ThemeProperties::COLOR_THROBBER_SPINNING),
+          base::TimeTicks::Now() - loading_start_time_, &waiting_state_);
+    }
+  }
+
+ private:
+  class Arc : public ui::LayerDelegate {
+   public:
+    // Since the rotation transform mis-aligns the pixel anti-aliasing done by
+    // Skia, perform a kind of FSAA by drawing on a larger canvas and scaling
+    // down as part of the transform.
+    static const int kAA = 1;
+
+    explicit Arc(SkScalar sweep)
+        : color_(SK_ColorRED), sweep_(sweep), layer_(ui::LAYER_TEXTURED) {
+      layer_.set_delegate(this);
+      layer_.SetFillsBoundsOpaquely(false);
+    }
+
+    ui::Layer* layer() { return &layer_; }
+
+    void set_color(SkColor color) { color_ = color; }
+
+    void SetAngle(SkScalar angle) {
+      const gfx::Size size = layer()->size();
+      gfx::Transform transform;
+      transform.Translate(size.width() / 2.0 / kAA, size.height() / 2.0 / kAA);
+      transform.Rotate(-angle);
+      transform.Scale(1.0 / kAA, 1.0 / kAA);
+      transform.Translate(-size.width() / 2, -size.height() / 2);
+      layer()->SetTransform(transform);
+    }
+
+    // LayerDelegate:
+    void OnPaintLayer(const ui::PaintContext& context) override {
+      const gfx::Size size = layer()->size();
+      ui::PaintRecorder recorder(context, size);
+      gfx::PaintThrobberArc(recorder.canvas(), gfx::Rect(size), color_, -90,
+                            sweep_);
+    }
+
+    void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
+    void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
+    base::Closure PrepareForLayerBoundsChange() override {
+      return base::Closure();
+    }
+
+   private:
+    SkColor color_;
+    SkScalar sweep_;
+    ui::Layer layer_;
+
+    DISALLOW_COPY_AND_ASSIGN(Arc);
+  };
+
+  void ApplyWaitingRotation(const base::TimeDelta& elapsed_time) {
+    const base::TimeDelta revolution_time =
+        base::TimeDelta::FromMilliseconds(1320);
+    bool needs_mask = elapsed_time < revolution_time / 2;
+    waiting_mask_.SetMasksToBounds(needs_mask);
+    waiting_arc_.SetAngle(360 * waiting_state_.elapsed_time / revolution_time);
+    waiting_arc_.set_color(
+        GetThemeProvider()->GetColor(ThemeProperties::COLOR_THROBBER_WAITING));
+  }
+
+  bool NeedsPaint() {
+    if (bounds().IsEmpty())
+      return false;
+
+    TabRendererData::NetworkState new_state = owner_->data().network_state;
+    const bool changing_state = new_state != state_;
+
+    // Waiting throbber is fully layer-backed.
+    if (new_state == TabRendererData::NETWORK_STATE_WAITING) {
+      if (waiting_start_time_ == base::TimeTicks())
+        waiting_start_time_ = base::TimeTicks::Now();
+
+      state_ = new_state;
+      waiting_state_.elapsed_time =
+          base::TimeTicks::Now() - waiting_start_time_;
+      layer()->Add(&waiting_mask_);
+      ApplyWaitingRotation(waiting_state_.elapsed_time);
+      return changing_state;
+    }
+
+    if (state_ == TabRendererData::NETWORK_STATE_WAITING)
+      layer()->Remove(&waiting_mask_);
+
+    state_ = new_state;
+
+    return true;
+  }
+
+  Tab* owner_;  // Weak. Owns this.
+
+  TabRendererData::NetworkState state_ = TabRendererData::NETWORK_STATE_NONE;
+
+  // The point in time when the tab icon was first painted in the waiting state.
+  base::TimeTicks waiting_start_time_;
+
+  // The point in time when the tab icon was first painted in the loading state.
+  base::TimeTicks loading_start_time_;
+
+  // Paint state for the throbber after the most recent waiting paint.
+  gfx::ThrobberWaitingState waiting_state_;
+
+  ui::Layer waiting_mask_;
+  Arc waiting_arc_;
+
+  DISALLOW_COPY_AND_ASSIGN(ThrobberView);
+};
+
+////////////////////////////////////////////////////////////////////////////////
 // Tab, statics:
 
 // static
 const char Tab::kViewClassName[] = "Tab";
 Tab::TabImage Tab::tab_active_ = {0};
 Tab::TabImage Tab::tab_inactive_ = {0};
 Tab::TabImage Tab::tab_alpha_ = {0};
 Tab::ImageCache* Tab::image_cache_ = NULL;
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 989 matching lines @@
   // the left since the shoulder of a dragged tab can still paint over the icon.
   gfx::Rect clip = GetLocalBounds();
   const bool needs_throbber = state != TabRendererData::NETWORK_STATE_NONE &&
                               controller_->ShouldPaintTab(this, &clip) &&
                               clip.x() == 0 && clip.Contains(favicon_bounds_);
 
   if (needs_throbber != throbber_->visible()) {
     ScheduleIconPaint();  // Repaint the icon area to update favicon visibility.
     throbber_->SetVisible(needs_throbber);
   }
-  throbber_->SchedulePaint();
+  throbber_->SchedulePaintIfRequired();
 }
 
 int Tab::IconCapacity() const {
   const gfx::Size min_size(GetMinimumUnselectedSize());
   if (height() < min_size.height())
     return 0;
   const int available_width = std::max(0, width() - min_size.width());
   // All icons are the same size as the favicon.
   const int icon_width = gfx::kFaviconSize;
   // We need enough space to display the icons flush against each other.
@@ skipping 258 matching lines @@
                          const gfx::ImageSkia& image) {
   DCHECK_NE(scale_factor, ui::SCALE_FACTOR_NONE);
   ImageCacheEntry entry;
   entry.resource_id = resource_id;
   entry.scale_factor = scale_factor;
   entry.image = image;
   image_cache_->push_front(entry);
   if (image_cache_->size() > kMaxImageCacheSize)
     image_cache_->pop_back();
 }