Handle view resize for ripple

ui/views/animation/flood_fill_ink_drop_ripple.cc

 // Copyright 2016 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/flood_fill_ink_drop_ripple.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "third_party/skia/include/core/SkColor.h"
@@ skipping 89 matching lines @@
   // accessibility reasons."See https://crbug.com/658384.
   if (!gfx::Animation::ShouldRenderRichAnimation())
     return base::TimeDelta();
   return base::TimeDelta::FromMilliseconds(
       (views::InkDropRipple::UseFastAnimations()
            ? 1
            : views::InkDropRipple::kSlowAnimationDurationFactor) *
       kAnimationDurationInMs[state]);
 }
 
+gfx::Rect CalculateClipBounds(const gfx::Size& host_size,
+                              const gfx::Insets& clip_insets) {
+  gfx::Rect clip_bounds(host_size);
+  clip_bounds.Inset(clip_insets);
+  return clip_bounds;
+}
+
+float CalculateCircleLayerRadius(const gfx::Rect& clip_bounds) {
+  return std::max(clip_bounds.width(), clip_bounds.height()) / 2.f;
+}
+
 }  // namespace
 
 namespace views {
 
-FloodFillInkDropRipple::FloodFillInkDropRipple(const gfx::Rect& clip_bounds,
+FloodFillInkDropRipple::FloodFillInkDropRipple(const gfx::Size& host_size,
+                                               const gfx::Insets& clip_insets,
                                                const gfx::Point& center_point,
                                                SkColor color,
                                                float visible_opacity)
-    : center_point_(center_point),
+    : clip_insets_(clip_insets),
+      center_point_(center_point),
       visible_opacity_(visible_opacity),
       root_layer_(ui::LAYER_NOT_DRAWN),
-      circle_layer_delegate_(
-          color,
-          std::max(clip_bounds.width(), clip_bounds.height()) / 2.f),
+      circle_layer_delegate_(color,
+                             CalculateCircleLayerRadius(
+                                 CalculateClipBounds(host_size, clip_insets))),
       ink_drop_state_(InkDropState::HIDDEN) {
+  gfx::Rect clip_bounds = CalculateClipBounds(host_size, clip_insets);
   root_layer_.set_name("FloodFillInkDropRipple:ROOT_LAYER");
   root_layer_.SetMasksToBounds(true);
   root_layer_.SetBounds(clip_bounds);
 
   const int painted_size_length =
       std::max(clip_bounds.width(), clip_bounds.height());
 
   painted_layer_.SetBounds(gfx::Rect(painted_size_length, painted_size_length));
   painted_layer_.SetFillsBoundsOpaquely(false);
   painted_layer_.set_delegate(&circle_layer_delegate_);
   painted_layer_.SetVisible(true);
   painted_layer_.SetOpacity(1.0);
   painted_layer_.SetMasksToBounds(false);
   painted_layer_.set_name("FloodFillInkDropRipple:PAINTED_LAYER");
 
   root_layer_.Add(&painted_layer_);
 
   SetStateToHidden();
 }
 
+FloodFillInkDropRipple::FloodFillInkDropRipple(const gfx::Size& host_size,
+                                               const gfx::Point& center_point,
+                                               SkColor color,
+                                               float visible_opacity)
+    : FloodFillInkDropRipple(host_size,
+                             gfx::Insets(),
+                             center_point,
+                             color,
+                             visible_opacity) {}
+
 FloodFillInkDropRipple::~FloodFillInkDropRipple() {
   // Explicitly aborting all the animations ensures all callbacks are invoked
   // while this instance still exists.
   AbortAllAnimations();
 }
 
+void FloodFillInkDropRipple::HostSizeChanged(const gfx::Size& new_size) {
+  root_layer_.SetBounds(CalculateClipBounds(new_size, clip_insets_));
+  switch (target_ink_drop_state()) {
+    case InkDropState::ACTION_PENDING:
+    case InkDropState::ALTERNATE_ACTION_PENDING:
+    case InkDropState::ACTIVATED:
+      painted_layer_.SetTransform(GetMaxSizeTargetTransform());
+      break;
+    default:
+      break;
+  }
+}
+
 void FloodFillInkDropRipple::SnapToActivated() {
   InkDropRipple::SnapToActivated();
   SetOpacity(visible_opacity_);
   painted_layer_.SetTransform(GetMaxSizeTargetTransform());
 }
 
 ui::Layer* FloodFillInkDropRipple::GetRootLayer() {
   return &root_layer_;
 }
 
@@ skipping 173 matching lines @@
       (bounds.bottom_right() - point).Length();
 
   float largest_distance =
       std::max(distance_to_top_left, distance_to_top_right);
   largest_distance = std::max(largest_distance, distance_to_bottom_left);
   largest_distance = std::max(largest_distance, distance_to_bottom_right);
   return largest_distance;
 }
 
 }  // namespace views