Refactored AppMenuAnimation

chrome/browser/ui/toolbar/app_menu_animation.cc

 // Copyright 2017 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/toolbar/app_menu_animation.h"
+#include "chrome/browser/ui/toolbar/app_menu_animation.h"
 
 #include "base/memory/ptr_util.h"
 #include "cc/paint/paint_flags.h"
-#include "chrome/browser/ui/views/toolbar/app_menu_button.h"
 #include "ui/gfx/animation/tween.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_palette.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/gfx/skia_util.h"
 
 namespace {
 
 // Duration of the open and close animations in ms.
 constexpr float kOpenDurationMs = 733.0f;
@@ skipping 36 matching lines @@
                                          float stroke_open_interval)
     : delay_(delay),
       width_open_interval_(width_open_interval),
       stroke_open_interval_(stroke_open_interval) {}
 
 void AppMenuAnimation::AppMenuDot::Paint(const gfx::PointF& center_point,
                                          SkColor start_color,
                                          SkColor target_color,
                                          gfx::Canvas* canvas,
                                          const gfx::Rect& bounds,
-                                         const gfx::SlideAnimation* animation) {
+                                         const gfx::SlideAnimation* animation,
+                                         AppMenuAnimationDelegate* delegate) {
   bool is_opening = animation->IsShowing();
   float total_duration = is_opening ? kOpenDurationMs : kCloseDurationMs;
   float width_duration =
       is_opening ? width_open_interval_ : kWidthStrokeCloseInterval;
   float stroke_duration =
       is_opening ? stroke_open_interval_ : kWidthStrokeCloseInterval;
 
   // When the animation is closing, each dot uses the remainder of the full
   // delay period (2 * kDotDelayMs). The results should be (0->2x, 1x->1x,
   // 2x->0).
@@ skipping 29 matching lines @@
       gfx::Tween::FloatValueBetween(width_progress, kCloseStroke, kOpenWidth);
   dot_width *= bounds.width();
 
   gfx::PointF point = center_point;
   point.Offset(-dot_width / 2, -dot_height / 2);
 
   SkColor color = is_opening ? gfx::Tween::ColorValueBetween(
                                    color_progress, start_color, target_color)
                              : target_color;
 
-  cc::PaintFlags flags;
-  flags.setColor(color);
-  flags.setStrokeWidth(bounds.height() * kCloseStroke);
-  flags.setStrokeCap(cc::PaintFlags::kRound_Cap);
-  flags.setStyle(cc::PaintFlags::kFill_Style);
-  flags.setAntiAlias(true);
-
-  gfx::SizeF dot_size = gfx::SizeF(dot_width, dot_height);
-  canvas->DrawRoundRect(gfx::RectF(point, dot_size), 2.0, flags);
+  delegate->PaintDot(point, color, gfx::SizeF(dot_width, dot_height), canvas);

[msw, 2017/05/05 18:47:38]

Would #if defined(OS_MACOSX) && !BUILDFLAG(MAC_VIEWS_BROWSER) here be simpler?

[spqchan, 2017/05/05 21:20:53]

Removed the delegate method

 }
 
-AppMenuAnimation::AppMenuAnimation(AppMenuButton* owner, SkColor initial_color)
-    : owner_(owner),
+AppMenuAnimation::AppMenuAnimation(AppMenuAnimationDelegate* delegate,
+                                   SkColor initial_color)
+    : delegate_(delegate),
       animation_(base::MakeUnique<gfx::SlideAnimation>(this)),
       bottom_dot_(base::TimeDelta(),
                   kBottomWidthOpenInterval,
                   kBottomStrokeOpenInterval),
       middle_dot_(base::TimeDelta::FromMilliseconds(kDotDelayMs),
                   kMiddleWidthOpenInterval,
                   kMiddleStrokeOpenInterval),
       top_dot_(base::TimeDelta::FromMilliseconds(kDotDelayMs * 2),
                kTopWidthOpenInterval,
                kTopStrokeOpenInterval),
       start_color_(initial_color),
       target_color_(initial_color) {
   animation_->SetSlideDuration(kOpenDurationMs);
   animation_->SetTweenType(gfx::Tween::FAST_OUT_SLOW_IN);
 }
 
 AppMenuAnimation::~AppMenuAnimation() {}
 
 void AppMenuAnimation::PaintAppMenu(gfx::Canvas* canvas,
                                     const gfx::Rect& bounds) {
   gfx::PointF middle_point = gfx::PointF(bounds.CenterPoint());
   float y_offset = kDotYOffset * bounds.height();
   gfx::PointF top_point = middle_point;
   top_point.Offset(0, -y_offset);
 
   gfx::PointF bottom_point = middle_point;
   bottom_point.Offset(0, y_offset);
 
   middle_dot_.Paint(middle_point, start_color_, target_color_, canvas, bounds,
-                    animation_.get());
+                    animation_.get(), delegate_);
   top_dot_.Paint(top_point, start_color_, target_color_, canvas, bounds,
-                 animation_.get());
+                 animation_.get(), delegate_);
   bottom_dot_.Paint(bottom_point, start_color_, target_color_, canvas, bounds,
-                    animation_.get());
+                    animation_.get(), delegate_);
 }
 
 void AppMenuAnimation::StartAnimation() {
   if (!animation_->is_animating()) {
     animation_->SetSlideDuration(kOpenDurationMs);
     animation_->Show();
-    owner_->AppMenuAnimationStarted();
+    delegate_->AppMenuAnimationStarted();
   }
 }
 
 void AppMenuAnimation::AnimationEnded(const gfx::Animation* animation) {
   if (animation_->IsShowing()) {
     animation_->SetSlideDuration(kCloseDurationMs);
     animation_->Hide();
   } else {
     start_color_ = target_color_;
   }
 
-  owner_->AppMenuAnimationEnded();
+  delegate_->AppMenuAnimationEnded();
 }
 
 void AppMenuAnimation::AnimationProgressed(const gfx::Animation* animation) {
-  owner_->SchedulePaint();
+  delegate_->InvalidateIcon();
 }