Moved the *PaintedLayerDelegates from ink_drop_animation.cc to ink_drop_painted_layer_delegates.h.

ui/views/animation/ink_drop_animation.cc

 // Copyright 2015 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 "ui/views/animation/ink_drop_animation.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "third_party/skia/include/core/SkColor.h"
-#include "third_party/skia/include/core/SkPaint.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/compositor/callback_layer_animation_observer.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_sequence.h"
-#include "ui/compositor/paint_recorder.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
-#include "ui/gfx/canvas.h"
+#include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/transform_util.h"
 #include "ui/views/animation/ink_drop_animation_observer.h"
+#include "ui/views/animation/ink_drop_painted_layer_delegates.h"
 #include "ui/views/view.h"
 
 namespace {
 
 // The minimum scale factor to use when scaling rectangle layers. Smaller values
 // were causing visual anomalies.
 const float kMinimumRectScale = 0.0001f;
 
 // The minimum scale factor to use when scaling circle layers. Smaller values
 // were causing visual anomalies.
@@ skipping 84 matching lines @@
   gfx::Transform transform;
   transform.Scale(x_scale, y_scale);
   transform.Translate(-drawn_center_point.x(), -drawn_center_point.y());
   return transform;
 }
 
 }  // namespace
 
 namespace views {
 
-// Base ui::LayerDelegate stub that can be extended to paint shapes of a
-// specific color.
-class BasePaintedLayerDelegate : public ui::LayerDelegate {
- public:
-  ~BasePaintedLayerDelegate() override;
-
-  SkColor color() const { return color_; }
-
-  // ui::LayerDelegate:
-  void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override;
-  void OnDeviceScaleFactorChanged(float device_scale_factor) override;
-  base::Closure PrepareForLayerBoundsChange() override;
-
- protected:
-  explicit BasePaintedLayerDelegate(SkColor color);
-
- private:
-  // The color to paint.
-  SkColor color_;
-
-  DISALLOW_COPY_AND_ASSIGN(BasePaintedLayerDelegate);
-};
-
-BasePaintedLayerDelegate::BasePaintedLayerDelegate(SkColor color)
-    : color_(color) {}
-
-BasePaintedLayerDelegate::~BasePaintedLayerDelegate() {}
-
-void BasePaintedLayerDelegate::OnDelegatedFrameDamage(
-    const gfx::Rect& damage_rect_in_dip) {}
-
-void BasePaintedLayerDelegate::OnDeviceScaleFactorChanged(
-    float device_scale_factor) {}
-
-base::Closure BasePaintedLayerDelegate::PrepareForLayerBoundsChange() {
-  return base::Closure();
-}
-
-// A BasePaintedLayerDelegate that paints a circle of a specified color and
-// radius.
-class CircleLayerDelegate : public BasePaintedLayerDelegate {
- public:
-  CircleLayerDelegate(SkColor color, int radius);
-  ~CircleLayerDelegate() override;
-
-  int radius() const { return radius_; }
-
-  // ui::LayerDelegate:
-  void OnPaintLayer(const ui::PaintContext& context) override;
-
- private:
-  // The radius of the circle.
-  int radius_;
-
-  DISALLOW_COPY_AND_ASSIGN(CircleLayerDelegate);
-};
-
-CircleLayerDelegate::CircleLayerDelegate(SkColor color, int radius)
-    : BasePaintedLayerDelegate(color), radius_(radius) {}
-
-CircleLayerDelegate::~CircleLayerDelegate() {}
-
-void CircleLayerDelegate::OnPaintLayer(const ui::PaintContext& context) {
-  SkPaint paint;
-  paint.setColor(color());
-  paint.setFlags(SkPaint::kAntiAlias_Flag);
-  paint.setStyle(SkPaint::kFill_Style);
-
-  ui::PaintRecorder recorder(context, gfx::Size(radius_, radius_));
-  gfx::Canvas* canvas = recorder.canvas();
-
-  gfx::Point center_point = gfx::Point(radius_, radius_);
-  canvas->DrawCircle(center_point, radius_, paint);
-}
-
-// A BasePaintedLayerDelegate that paints a rectangle of a specified color and
-// size.
-class RectangleLayerDelegate : public BasePaintedLayerDelegate {
- public:
-  RectangleLayerDelegate(SkColor color, gfx::Size size);
-  ~RectangleLayerDelegate() override;
-
-  const gfx::Size& size() const { return size_; }
-
-  // ui::LayerDelegate:
-  void OnPaintLayer(const ui::PaintContext& context) override;
-
- private:
-  // The size of the rectangle.
-  gfx::Size size_;
-
-  DISALLOW_COPY_AND_ASSIGN(RectangleLayerDelegate);
-};
-
-RectangleLayerDelegate::RectangleLayerDelegate(SkColor color, gfx::Size size)
-    : BasePaintedLayerDelegate(color), size_(size) {}
-
-RectangleLayerDelegate::~RectangleLayerDelegate() {}
-
-void RectangleLayerDelegate::OnPaintLayer(const ui::PaintContext& context) {
-  SkPaint paint;
-  paint.setColor(color());
-  paint.setFlags(SkPaint::kAntiAlias_Flag);
-  paint.setStyle(SkPaint::kFill_Style);
-
-  ui::PaintRecorder recorder(context, size_);
-  gfx::Canvas* canvas = recorder.canvas();
-  canvas->DrawRect(gfx::Rect(size_), paint);
-}
-
 InkDropAnimation::InkDropAnimation(const gfx::Size& large_size,
                                    int large_corner_radius,
                                    const gfx::Size& small_size,
                                    int small_corner_radius)
     : large_size_(large_size),
       large_corner_radius_(large_corner_radius),
       small_size_(small_size),
       small_corner_radius_(small_corner_radius),
       circle_layer_delegate_(new CircleLayerDelegate(
           kInkDropColor,
@@ skipping 188 matching lines @@
   // methods to calculate the complex Transforms.
 
   const float circle_scale = std::max(
       kMinimumCircleScale,
       corner_radius / static_cast<float>(circle_layer_delegate_->radius()));
 
   const float circle_target_x_offset = size.width() / 2.0f - corner_radius;
   const float circle_target_y_offset = size.height() / 2.0f - corner_radius;
 
   (*transforms_out)[TOP_LEFT_CIRCLE] = CalculateCircleTransform(
-      painted_layers_[TOP_LEFT_CIRCLE]->bounds().CenterPoint(), circle_scale,
+      ToRoundedPoint(circle_layer_delegate_->GetCenterPoint()), circle_scale,
       -circle_target_x_offset, -circle_target_y_offset);
 
   (*transforms_out)[TOP_RIGHT_CIRCLE] = CalculateCircleTransform(
-      painted_layers_[TOP_RIGHT_CIRCLE]->bounds().CenterPoint(), circle_scale,
+      ToRoundedPoint(circle_layer_delegate_->GetCenterPoint()), circle_scale,
       circle_target_x_offset, -circle_target_y_offset);
 
   (*transforms_out)[BOTTOM_RIGHT_CIRCLE] = CalculateCircleTransform(
-      painted_layers_[BOTTOM_RIGHT_CIRCLE]->bounds().CenterPoint(),
-      circle_scale, circle_target_x_offset, circle_target_y_offset);
+      ToRoundedPoint(circle_layer_delegate_->GetCenterPoint()), circle_scale,
+      circle_target_x_offset, circle_target_y_offset);
 
   (*transforms_out)[BOTTOM_LEFT_CIRCLE] = CalculateCircleTransform(
-      painted_layers_[BOTTOM_LEFT_CIRCLE]->bounds().CenterPoint(), circle_scale,
+      ToRoundedPoint(circle_layer_delegate_->GetCenterPoint()), circle_scale,
       -circle_target_x_offset, circle_target_y_offset);
 
   const float rect_delegate_width =
       static_cast<float>(rect_layer_delegate_->size().width());
   const float rect_delegate_height =
       static_cast<float>(rect_layer_delegate_->size().height());
 
   (*transforms_out)[HORIZONTAL_RECT] = CalculateRectTransform(
-      painted_layers_[HORIZONTAL_RECT]->bounds().CenterPoint(),
+      ToRoundedPoint(rect_layer_delegate_->GetCenterPoint()),
       std::max(kMinimumRectScale, size.width() / rect_delegate_width),
       std::max(kMinimumRectScale,
                (size.height() - 2.0f * corner_radius) / rect_delegate_height));
 
   (*transforms_out)[VERTICAL_RECT] = CalculateRectTransform(
-      painted_layers_[VERTICAL_RECT]->bounds().CenterPoint(),
+      ToRoundedPoint(rect_layer_delegate_->GetCenterPoint()),
       std::max(kMinimumRectScale,
                (size.width() - 2.0f * corner_radius) / rect_delegate_width),
       std::max(kMinimumRectScale, size.height() / rect_delegate_height));
 }
 
 void InkDropAnimation::GetCurrentTansforms(
     InkDropTransforms* transforms_out) const {
   for (int i = 0; i < PAINTED_SHAPE_COUNT; ++i)
     (*transforms_out)[i] = painted_layers_[i]->GetTargetTransform();
 }
@@ skipping 48 matching lines @@
   FOR_EACH_OBSERVER(
       InkDropAnimationObserver, observers_,
       InkDropAnimationEnded(ink_drop_state,
                             observer.aborted_count()
                                 ? InkDropAnimationObserver::PRE_EMPTED
                                 : InkDropAnimationObserver::SUCCESS));
   return true;
 }
 
 }  // namespace views