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() {
   // 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());

[bruthig, 2016/11/28 22:13:46]

So will opacity animations continue here or do we need to snap them to the
correct values as well?

[mohsen, 2016/11/29 00:07:12]

I think the opacity animations continue and it makes sense. First, for
transform, the existing animation doesn't make sense anymore after resize and
should be updated, but, for now, we just snap it to the final state as a
workaround. However, that's not the case for opacity animations. We can continue
the same animations and there is no need to snap them to the final values.
Second, unlike snapping transform animations which is not much noticeable to the
user during a resize, I think snapping opacity animations would be noticeable
and it's better to let the animation run its course. WDYT?

[bruthig, 2016/11/29 01:37:48]

sgtm

+      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