Add ink drop masking to TrayBackgroundView

ui/views/animation/ink_drop_host_view.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/ink_drop_host_view.h"
 
 #include "base/memory/ptr_util.h"
 #include "ui/events/event.h"
 #include "ui/events/scoped_target_handler.h"
 #include "ui/gfx/color_palette.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/views/animation/ink_drop.h"
 #include "ui/views/animation/ink_drop_highlight.h"
 #include "ui/views/animation/ink_drop_impl.h"
+#include "ui/views/animation/ink_drop_mask.h"
 #include "ui/views/animation/ink_drop_stub.h"
 #include "ui/views/animation/square_ink_drop_ripple.h"
 
 namespace views {
 namespace {
 
 // Size used for the default SquareInkDropRipple.
 const int kInkDropSize = 24;
 
 // The scale factor to compute the large size of the default
@@ skipping 96 matching lines @@
 InkDropHostView::~InkDropHostView() {
   // TODO(bruthig): Improve InkDropImpl to be safer about calling back to
   // potentially destroyed InkDropHosts and remove |destroying_|.
   destroying_ = true;
 }
 
 void InkDropHostView::AddInkDropLayer(ui::Layer* ink_drop_layer) {
   old_paint_to_layer_ = layer() != nullptr;
   SetPaintToLayer(true);
   layer()->SetFillsBoundsOpaquely(false);
+  ink_drop_mask_ = CreateInkDropMask();
+  if (ink_drop_mask_)
+    ink_drop_layer->SetMaskLayer(ink_drop_mask_->layer());
   layer()->Add(ink_drop_layer);
   layer()->StackAtBottom(ink_drop_layer);
 }
 
 void InkDropHostView::RemoveInkDropLayer(ui::Layer* ink_drop_layer) {
   // No need to do anything when called during shutdown, and if a derived
   // class has overridden Add/RemoveInkDropLayer, running this implementation
   // would be wrong.
   if (destroying_)
     return;
   layer()->Remove(ink_drop_layer);
+  ink_drop_layer->SetMaskLayer(nullptr);
+  ink_drop_mask_.reset();
   SetPaintToLayer(old_paint_to_layer_);
 }
 
 std::unique_ptr<InkDrop> InkDropHostView::CreateInkDrop() {
   return CreateDefaultInkDropImpl();
 }
 
 std::unique_ptr<InkDropRipple> InkDropHostView::CreateInkDropRipple() const {
   return CreateDefaultInkDropRipple(GetLocalBounds().CenterPoint());
 }
@@ skipping 52 matching lines @@
   if (event && (event->IsTouchEvent() || event->IsGestureEvent()) &&
       GetInkDrop()->GetTargetInkDropState() == InkDropState::HIDDEN &&
       state != InkDropState::ACTIVATED)
     return;
 #endif
   last_ripple_triggering_event_.reset(
       event ? ui::Event::Clone(*event).release()->AsLocatedEvent() : nullptr);
   GetInkDrop()->AnimateToState(state);
 }
 
+void InkDropHostView::OnBoundsChanged(const gfx::Rect& previous_bounds) {
+  if (ink_drop_)
+    ink_drop_->HostSizeChanged(size());

[bruthig, 2016/11/14 21:07:41]

Should we be re-creating/applying the mask here too, or maybe in an
InkDropHostView::OnMaskChanged() event that clients/subclasses would have to
call?

[bruthig, 2016/11/14 21:45:41]

Discussed offline, my request is not needed until we are supporting
InkDropHostView's that are dynamically resized.

+}
+
 void InkDropHostView::VisibilityChanged(View* starting_from, bool is_visible) {
   View::VisibilityChanged(starting_from, is_visible);
   if (GetWidget() && !is_visible) {
     GetInkDrop()->AnimateToState(InkDropState::HIDDEN);
     GetInkDrop()->SetHovered(false);
   }
 }
 
 void InkDropHostView::OnFocus() {
   views::View::OnFocus();
@@ skipping 20 matching lines @@
       break;
   }
   View::OnMouseEvent(event);
 }
 
 SkColor InkDropHostView::GetInkDropBaseColor() const {
   NOTREACHED();
   return gfx::kPlaceholderColor;
 }
 
+std::unique_ptr<views::InkDropMask> InkDropHostView::CreateInkDropMask() const {
+  return nullptr;
+}
+
 InkDrop* InkDropHostView::GetInkDrop() {
   if (!ink_drop_) {
     if (ink_drop_mode_ == InkDropMode::OFF)
       ink_drop_ = base::MakeUnique<InkDropStub>();
     else
       ink_drop_ = CreateInkDrop();
   }
   return ink_drop_.get();
 }
 
 std::unique_ptr<InkDropImpl> InkDropHostView::CreateDefaultInkDropImpl() {
-  std::unique_ptr<InkDropImpl> ink_drop = base::MakeUnique<InkDropImpl>(this);
+  std::unique_ptr<InkDropImpl> ink_drop =
+      base::MakeUnique<InkDropImpl>(this, size());
   ink_drop->SetAutoHighlightMode(
       views::InkDropImpl::AutoHighlightMode::HIDE_ON_RIPPLE);
   return ink_drop;
 }
 
 std::unique_ptr<InkDropImpl>
 InkDropHostView::CreateDefaultFloodFillInkDropImpl() {
   std::unique_ptr<views::InkDropImpl> ink_drop =
       InkDropHostView::CreateDefaultInkDropImpl();
   ink_drop->SetAutoHighlightMode(
       views::InkDropImpl::AutoHighlightMode::SHOW_ON_RIPPLE);
   return ink_drop;
 }
 
 }  // namespace views