Introduce the MaskedViewTargeter class

Introduce MaskedViewTargeter, a derived class of ViewTargeter.
Classes deriving from MaskedViewTargeter will be used to define a
custom-shaped hit test mask on a view to be considered in
event targeting.

BUG=375826
TEST=ViewTargeterTest.MaskedViewTargeter

Review URL: https://codereview.chromium.org/286933014

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@273023 0039d316-1c4b-4281-b951-d872f2087c98

ui/views/masked_view_targeter.cc

+// Copyright 2014 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/masked_view_targeter.h"
+
+#include "ui/gfx/path.h"
+#include "ui/gfx/skia_util.h"
+#include "ui/views/view.h"
+
+namespace views {
+
+MaskedViewTargeter::MaskedViewTargeter(View* masked_view)
+    : masked_view_(masked_view) {
+}
+
+MaskedViewTargeter::~MaskedViewTargeter() {
+}
+
+bool MaskedViewTargeter::EventLocationInsideBounds(
+    ui::EventTarget* target,
+    const ui::LocatedEvent& event) const {
+  View* view = static_cast<View*>(target);
+  if (view == masked_view_) {
+    gfx::Path mask;
+    if (!GetHitTestMask(view, &mask))
+      return ViewTargeter::EventLocationInsideBounds(view, event);
+
+    gfx::Size size = view->bounds().size();
+    SkRegion clip_region;
+    clip_region.setRect(0, 0, size.width(), size.height());
+
+    gfx::RectF bounds_f = ViewTargeter::BoundsForEvent(event);
+    if (view->parent())
+      View::ConvertRectToTarget(view->parent(), view, &bounds_f);
+    gfx::Rect bounds = gfx::ToEnclosingRect(bounds_f);
+
+    SkRegion mask_region;
+    return mask_region.setPath(mask, clip_region) &&
+           mask_region.intersects(RectToSkIRect(bounds));
+  }
+
+  return ViewTargeter::EventLocationInsideBounds(view, event);
+}
+
+}  // namespace views

ui/views/masked_view_targeter.h

+// Copyright 2014 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.
+
+#ifndef UI_VIEWS_MASKED_VIEW_TARGETER_H_
+#define UI_VIEWS_MASKED_VIEW_TARGETER_H_
+
+#include "ui/views/view_targeter.h"
+#include "ui/views/views_export.h"
+
+namespace gfx {
+class Path;
+}
+
+namespace views {
+
+// Derived classes of MaskedViewTargeter are used to define custom-shaped
+// hit test regions for a View used in event targeting.
+// TODO(tdanderson|sadrul): Some refactoring opportunities may be possible
+//                          between this class and MaskedWindowTargeter.
+class VIEWS_EXPORT MaskedViewTargeter : public ViewTargeter {
+ public:
+  explicit MaskedViewTargeter(View* masked_view);
+  virtual ~MaskedViewTargeter();
+
+ protected:
+  // Sets the hit-test mask for |view| in |mask| (in |view|'s local
+  // coordinate system). Returns whether a valid mask has been set in |mask|.
+  virtual bool GetHitTestMask(View* view, gfx::Path* mask) const = 0;
+
+  // ui::EventTargeter:
+  virtual bool EventLocationInsideBounds(
+      ui::EventTarget* target,
+      const ui::LocatedEvent& event) const OVERRIDE;
+
+ private:
+  View* masked_view_;
+
+  DISALLOW_COPY_AND_ASSIGN(MaskedViewTargeter);
+};
+
+}  // namespace views
+
+#endif  // UI_VIEWS_MASKED_VIEW_TARGETER_H_

ui/views/view_targeter.cc

@@ -13,6 +13,17 @@ namespace views {
 ViewTargeter::ViewTargeter() {}
 ViewTargeter::~ViewTargeter() {}
 
+gfx::RectF ViewTargeter::BoundsForEvent(const ui::LocatedEvent& event) const {
+  gfx::RectF event_bounds(event.location_f(), gfx::SizeF(1, 1));
+  if (event.IsGestureEvent()) {
+    const ui::GestureEvent& gesture =
+        static_cast<const ui::GestureEvent&>(event);
+    event_bounds = gesture.details().bounding_box_f();
+  }
+
+  return event_bounds;
+}
+
 ui::EventTarget* ViewTargeter::FindTargetForEvent(ui::EventTarget* root,
                                                   ui::Event* event) {
   View* view = static_cast<View*>(root);

ui/views/view_targeter.h

@@ -23,6 +23,11 @@ class VIEWS_EXPORT ViewTargeter : public ui::EventTargeter {
   virtual ~ViewTargeter();
 
  protected:
+  // Returns the location of |event| represented as a rect. If |event| is
+  // a gesture event, its bounding box is returned. Otherwise, a 1x1 rect
+  // having its origin at the location of |event| is returned.
+  gfx::RectF BoundsForEvent(const ui::LocatedEvent& event) const;
+
   // ui::EventTargeter:
   virtual ui::EventTarget* FindTargetForEvent(ui::EventTarget* root,
                                               ui::Event* event) OVERRIDE;

ui/views/view_targeter_unittest.cc

@@ -6,10 +6,37 @@
 
 #include "ui/events/event_targeter.h"
 #include "ui/events/event_utils.h"
+#include "ui/gfx/path.h"
+#include "ui/views/masked_view_targeter.h"
 #include "ui/views/test/views_test_base.h"
 #include "ui/views/widget/root_view.h"
 
 namespace views {
+
+// A class used to define a triangular-shaped hit test mask on a View.
+class TestMaskedViewTargeter : public MaskedViewTargeter {
+ public:
+  explicit TestMaskedViewTargeter(View* masked_view)
+      : MaskedViewTargeter(masked_view) {}
+  virtual ~TestMaskedViewTargeter() {}
+
+ private:
+  virtual bool GetHitTestMask(View* view, gfx::Path* mask) const OVERRIDE {
+    SkScalar w = SkIntToScalar(view->width());
+    SkScalar h = SkIntToScalar(view->height());
+
+    // Create a triangular mask within the bounds of |view|.
+    mask->moveTo(w / 2, 0);
+    mask->lineTo(w, h);
+    mask->lineTo(0, h);
+    mask->close();
+
+    return true;
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(TestMaskedViewTargeter);
+};
+
 namespace test {
 
 typedef ViewsTestBase ViewTargeterTest;
@@ -190,5 +217,72 @@ TEST_F(ViewTargeterTest, SubtreeShouldBeExploredForEvent) {
   // and into here. See crbug.com/355425.
 }
 
+// Tests that FindTargetForEvent() returns the correct target when some
+// views in the view tree have a MaskedViewTargeter installed, i.e.,
+// they have a custom-shaped hit test mask.
+TEST_F(ViewTargeterTest, MaskedViewTargeter) {
+  Widget widget;
+  Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
+  params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
+  params.bounds = gfx::Rect(0, 0, 650, 650);
+  widget.Init(params);
+
+  ui::EventTargeter* targeter = new ViewTargeter();
+  internal::RootView* root_view =
+      static_cast<internal::RootView*>(widget.GetRootView());
+  root_view->SetEventTargeter(make_scoped_ptr(targeter));
+
+  // The coordinates used for SetBounds() are in the parent coordinate space.
+  View masked_view, unmasked_view, masked_child;
+  masked_view.SetBounds(0, 0, 200, 200);
+  unmasked_view.SetBounds(300, 0, 300, 300);
+  masked_child.SetBounds(0, 0, 100, 100);
+  root_view->AddChildView(&masked_view);
+  root_view->AddChildView(&unmasked_view);
+  unmasked_view.AddChildView(&masked_child);
+
+  // Install event targeters of type TestMaskedViewTargeter on the two masked
+  // views to define their hit test masks.
+  ui::EventTargeter* masked_targeter = new TestMaskedViewTargeter(&masked_view);
+  masked_view.SetEventTargeter(make_scoped_ptr(masked_targeter));
+  masked_targeter = new TestMaskedViewTargeter(&masked_child);
+  masked_child.SetEventTargeter(make_scoped_ptr(masked_targeter));
+
+  // Note that the coordinates used below are in the coordinate space of
+  // the root view.
+
+  // Event located within the hit test mask of |masked_view|.
+  ui::ScrollEvent scroll(ui::ET_SCROLL,
+                         gfx::Point(100, 190),
+                         ui::EventTimeForNow(),
+                         0,
+                         0,
+                         3,
+                         0,
+                         3,
+                         2);
+  ui::EventTarget* current_target =
+      targeter->FindTargetForEvent(root_view, &scroll);
+  EXPECT_EQ(&masked_view, static_cast<View*>(current_target));
+
+  // Event located outside the hit test mask of |masked_view|.
+  scroll.set_location(gfx::Point(10, 10));
+  current_target = targeter->FindTargetForEvent(root_view, &scroll);
+  EXPECT_EQ(root_view, static_cast<View*>(current_target));
+
+  // Event located within the hit test mask of |masked_child|.
+  scroll.set_location(gfx::Point(350, 3));
+  current_target = targeter->FindTargetForEvent(root_view, &scroll);
+  EXPECT_EQ(&masked_child, static_cast<View*>(current_target));
+
+  // Event located within the hit test mask of |masked_child|.
+  scroll.set_location(gfx::Point(300, 12));
+  current_target = targeter->FindTargetForEvent(root_view, &scroll);
+  EXPECT_EQ(&unmasked_view, static_cast<View*>(current_target));
+
+  // TODO(tdanderson): We should also test that targeting of masked views
+  //                   works correctly with gestures. See crbug.com/375822.
+}
+
 }  // namespace test
 }  // namespace views

ui/views/views.gyp

@@ -306,6 +306,8 @@
         'linux_ui/status_icon_linux.cc',
         'linux_ui/window_button_order_observer.h',
         'linux_ui/window_button_order_provider.cc',
+        'masked_view_targeter.cc',
+        'masked_view_targeter.h',
         'metrics.cc',
         'metrics.h',
         'metrics_aura.cc',