Introduce View::CanProcessEventsWithinSubtree()

ui/views/view_unittest.cc

 // Copyright (c) 2012 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 <map>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/rand_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 185 matching lines @@
 
 }  // namespace
 
 namespace views {
 
 typedef ViewsTestBase ViewTest;
 
 // A derived class for testing purpose.
 class TestView : public View {
  public:
-  TestView() : View(), delete_on_pressed_(false), native_theme_(NULL) {}
+  TestView()
+      : View(),
+        delete_on_pressed_(false),
+        native_theme_(NULL),
+        can_process_events_within_subtree_(true) {}
   virtual ~TestView() {}
 
   // Reset all test state
   void Reset() {
     did_change_bounds_ = false;
     last_mouse_event_type_ = 0;
     location_.SetPoint(0, 0);
     received_mouse_enter_ = false;
     received_mouse_exit_ = false;
     last_gesture_event_type_ = 0;
     last_gesture_event_was_handled_ = false;
     last_clip_.setEmpty();
     accelerator_count_map_.clear();
+    can_process_events_within_subtree_ = true;
   }
 
   // Exposed as public for testing.
   void DoFocus() {
     views::View::Focus();
   }
 
   void DoBlur() {
     views::View::Blur();
   }
 
   bool focusable() const { return View::focusable(); }
 
+  void set_can_process_events_within_subtree(bool can_process) {
+    can_process_events_within_subtree_ = can_process;
+  }
+
+  virtual bool CanProcessEventsWithinSubtree() const OVERRIDE {
+    return can_process_events_within_subtree_;
+  }
+
   virtual void OnBoundsChanged(const gfx::Rect& previous_bounds) OVERRIDE;
   virtual bool OnMousePressed(const ui::MouseEvent& event) OVERRIDE;
   virtual bool OnMouseDragged(const ui::MouseEvent& event) OVERRIDE;
   virtual void OnMouseReleased(const ui::MouseEvent& event) OVERRIDE;
   virtual void OnMouseEntered(const ui::MouseEvent& event) OVERRIDE;
   virtual void OnMouseExited(const ui::MouseEvent& event) OVERRIDE;
 
   // Ignores GestureEvent by default.
   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
 
@@ skipping 23 matching lines @@
   bool last_gesture_event_was_handled_;
 
   // Painting.
   SkRect last_clip_;
 
   // Accelerators.
   std::map<ui::Accelerator, int> accelerator_count_map_;
 
   // Native theme.
   const ui::NativeTheme* native_theme_;
+
+  // Value to return from CanProcessEventsWithinSubtree().
+  bool can_process_events_within_subtree_;
 };
 
 // A view subclass that consumes all Gesture events for testing purposes.
 class TestViewConsumeGesture : public TestView {
  public:
   TestViewConsumeGesture() : TestView() {}
   virtual ~TestViewConsumeGesture() {}
 
  protected:
   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
@@ skipping 919 matching lines @@
   // A mouse click on the center of |v5| and |v51| should target
   // the child view.
   touch_rect.SetRect(465, 215, 1, 1);
   result_view = root_view->GetEventHandlerForRect(touch_rect);
   EXPECT_EQ(v51, result_view);
   result_view = NULL;
 
   widget->CloseNow();
 }
 
+// Tests that GetEventHandlerForRect() and GetTooltipHandlerForPoint() behave
+// as expected when different views in the view hierarchy return false
+// when CanProcessEventsWithinSubtree() is called.
+TEST_F(ViewTest, CanProcessEventsWithinSubtree) {
+  Widget* widget = new Widget;
+  Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
+  widget->Init(params);
+  View* root_view = widget->GetRootView();
+  root_view->SetBoundsRect(gfx::Rect(0, 0, 500, 500));
+
+  // Have this hierarchy of views (the coords here are in the coordinate
+  // space of the root view):
+  // v (0, 0, 100, 100)
+  //  - v_child (0, 0, 20, 30)
+  //    - v_grandchild (5, 5, 5, 15)
+
+  TestView* v = new TestView;
+  v->SetBounds(0, 0, 100, 100);
+  root_view->AddChildView(v);
+  v->set_notify_enter_exit_on_child(true);
+
+  TestView* v_child = new TestView;
+  v_child->SetBounds(0, 0, 20, 30);
+  v->AddChildView(v_child);
+
+  TestView* v_grandchild = new TestView;
+  v_grandchild->SetBounds(5, 5, 5, 15);
+  v_child->AddChildView(v_grandchild);
+
+  v->Reset();
+  v_child->Reset();
+  v_grandchild->Reset();
+
+  // Define rects and points within the views in the hierarchy.
+  gfx::Rect rect_in_v_grandchild(7, 7, 3, 3);
+  gfx::Point point_in_v_grandchild(rect_in_v_grandchild.origin());
+  gfx::Rect rect_in_v_child(12, 3, 5, 5);
+  gfx::Point point_in_v_child(rect_in_v_child.origin());
+  gfx::Rect rect_in_v(50, 50, 25, 30);
+  gfx::Point point_in_v(rect_in_v.origin());
+
+  // When all three views return true when CanProcessEventsWithinSubtree()
+  // is called, targeting should behave as expected.
+
+  View* result_view = root_view->GetEventHandlerForRect(rect_in_v_grandchild);
+  EXPECT_EQ(v_grandchild, result_view);
+  result_view = NULL;
+  result_view = root_view->GetTooltipHandlerForPoint(point_in_v_grandchild);
+  EXPECT_EQ(v_grandchild, result_view);
+  result_view = NULL;
+
+  result_view = root_view->GetEventHandlerForRect(rect_in_v_child);
+  EXPECT_EQ(v_child, result_view);
+  result_view = NULL;
+  result_view = root_view->GetTooltipHandlerForPoint(point_in_v_child);
+  EXPECT_EQ(v_child, result_view);
+  result_view = NULL;
+
+  result_view = root_view->GetEventHandlerForRect(rect_in_v);
+  EXPECT_EQ(v, result_view);
+  result_view = NULL;
+  result_view = root_view->GetTooltipHandlerForPoint(point_in_v);
+  EXPECT_EQ(v, result_view);
+  result_view = NULL;
+
+  // When |v_grandchild| returns false when CanProcessEventsWithinSubtree()
+  // is called, then |v_grandchild| cannot be returned as a target.
+
+  v_grandchild->set_can_process_events_within_subtree(false);
+
+  result_view = root_view->GetEventHandlerForRect(rect_in_v_grandchild);
+  EXPECT_EQ(v_child, result_view);
+  result_view = NULL;
+  result_view = root_view->GetTooltipHandlerForPoint(point_in_v_grandchild);
+  EXPECT_EQ(v_child, result_view);
+  result_view = NULL;
+
+  result_view = root_view->GetEventHandlerForRect(rect_in_v_child);
+  EXPECT_EQ(v_child, result_view);
+  result_view = NULL;
+  result_view = root_view->GetTooltipHandlerForPoint(point_in_v_child);
+  EXPECT_EQ(v_child, result_view);
+  result_view = NULL;
+
+  result_view = root_view->GetEventHandlerForRect(rect_in_v);
+  EXPECT_EQ(v, result_view);
+  result_view = NULL;
+  result_view = root_view->GetTooltipHandlerForPoint(point_in_v);
+  EXPECT_EQ(v, result_view);
+  result_view = NULL;
+
+  // When |v_child| returns false when CanProcessEventsWithinSubtree()
+  // is called, then neither |v_child| nor |v_grandchild| can be returned
+  // as a target (|v| should be returned as the target for each case).
+
+  v_grandchild->Reset();
+  v_child->set_can_process_events_within_subtree(false);
+
+  result_view = root_view->GetEventHandlerForRect(rect_in_v_grandchild);
+  EXPECT_EQ(v, result_view);
+  result_view = NULL;
+  result_view = root_view->GetTooltipHandlerForPoint(point_in_v_grandchild);
+  EXPECT_EQ(v, result_view);
+  result_view = NULL;
+
+  result_view = root_view->GetEventHandlerForRect(rect_in_v_child);
+  EXPECT_EQ(v, result_view);
+  result_view = NULL;
+  result_view = root_view->GetTooltipHandlerForPoint(point_in_v_child);
+  EXPECT_EQ(v, result_view);
+  result_view = NULL;
+
+  result_view = root_view->GetEventHandlerForRect(rect_in_v);
+  EXPECT_EQ(v, result_view);
+  result_view = NULL;
+  result_view = root_view->GetTooltipHandlerForPoint(point_in_v);
+  EXPECT_EQ(v, result_view);
+  result_view = NULL;
+
+  // When |v| returns false when CanProcessEventsWithinSubtree()
+  // is called, then none of |v|, |v_child|, and |v_grandchild| can be returned
+  // as a target (|root_view| should be returned as the target for each case).
+
+  v_child->Reset();
+  v->set_can_process_events_within_subtree(false);
+
+  result_view = root_view->GetEventHandlerForRect(rect_in_v_grandchild);
+  EXPECT_EQ(root_view, result_view);
+  result_view = NULL;
+  result_view = root_view->GetTooltipHandlerForPoint(point_in_v_grandchild);
+  EXPECT_EQ(root_view, result_view);
+  result_view = NULL;
+
+  result_view = root_view->GetEventHandlerForRect(rect_in_v_child);
+  EXPECT_EQ(root_view, result_view);
+  result_view = NULL;
+  result_view = root_view->GetTooltipHandlerForPoint(point_in_v_child);
+  EXPECT_EQ(root_view, result_view);
+  result_view = NULL;
+
+  result_view = root_view->GetEventHandlerForRect(rect_in_v);
+  EXPECT_EQ(root_view, result_view);
+  result_view = NULL;
+  result_view = root_view->GetTooltipHandlerForPoint(point_in_v);
+  EXPECT_EQ(root_view, result_view);
+}
+
 TEST_F(ViewTest, NotifyEnterExitOnChild) {
   Widget* widget = new Widget;
   Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
   widget->Init(params);
   View* root_view = widget->GetRootView();
   root_view->SetBoundsRect(gfx::Rect(0, 0, 500, 500));
 
   // Have this hierarchy of views (the coords here are in root coord):
   // v1 (0, 0, 100, 100)
   //  - v11 (0, 0, 20, 30)
@@ skipping 2708 matching lines @@
   // notification.
   TestView* test_view_child_2 = new TestView();
   test_view->AddChildView(test_view_child_2);
   EXPECT_TRUE(test_view_child_2->native_theme_);
   EXPECT_EQ(widget->GetNativeTheme(), test_view_child_2->native_theme_);
 
   widget->CloseNow();
 }
 
 }  // namespace views