mash: changes can_accept_events to an enum

services/ui/ws/event_dispatcher_unittest.cc

 // Copyright 2015 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 "services/ui/ws/event_dispatcher.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
@@ skipping 268 matching lines @@
   event_dispatcher_.reset();
 }
 
 std::unique_ptr<ServerWindow> EventDispatcherTest::CreateChildWindowWithParent(
     const WindowId& id,
     ServerWindow* parent) {
   std::unique_ptr<ServerWindow> child(
       new ServerWindow(window_delegate_.get(), id));
   parent->Add(child.get());
   child->SetVisible(true);
-  EnableHitTest(child.get());
   return child;
 }
 
 std::unique_ptr<ServerWindow> EventDispatcherTest::CreateChildWindow(
     const WindowId& id) {
   return CreateChildWindowWithParent(id, root_window_.get());
 }
 
 bool EventDispatcherTest::IsMouseButtonDown() const {
   return EventDispatcherTestApi(event_dispatcher_.get()).is_mouse_button_down();
@@ skipping 16 matching lines @@
       EventDispatcherTestApi(event_dispatcher_.get()).modal_window_controller();
   return ModalWindowControllerTestApi(mwc).GetActiveSystemModalWindow();
 }
 
 void EventDispatcherTest::SetUp() {
   testing::Test::SetUp();
 
   window_delegate_ = base::MakeUnique<TestServerWindowDelegate>();
   root_window_ =
       base::MakeUnique<ServerWindow>(window_delegate_.get(), WindowId(1, 2));
-  EnableHitTest(root_window_.get());
+  root_window_->set_event_targeting_policy(
+      mojom::EventTargetingPolicy::TARGET_AND_DESCENDANTS);

[sadrul, 2017/02/01 20:42:00]

Probably not needed since the default?

[sky, 2017/02/01 21:13:50]

Done.

   window_delegate_->set_root_window(root_window_.get());
   root_window_->SetVisible(true);
 
   test_event_dispatcher_delegate_ =
       base::MakeUnique<TestEventDispatcherDelegate>(this);
   event_dispatcher_ =
       base::MakeUnique<EventDispatcher>(test_event_dispatcher_delegate_.get());
   test_event_dispatcher_delegate_->set_root(root_window_.get());
 }
 
@@ skipping 1319 matching lines @@
   EXPECT_EQ(w3.get(), GetActiveSystemModalWindow());
 
   // Remove the last remaining system modal window. There should be no active
   // one anymore.
   w3.reset();
   EXPECT_EQ(nullptr, GetActiveSystemModalWindow());
 }
 
 TEST_F(EventDispatcherTest, CaptureNotResetOnParentChange) {
   std::unique_ptr<ServerWindow> w1 = CreateChildWindow(WindowId(1, 3));
-  DisableHitTest(w1.get());
+  w1->set_event_targeting_policy(mojom::EventTargetingPolicy::DESCENDANTS_ONLY);
   std::unique_ptr<ServerWindow> w11 =
       CreateChildWindowWithParent(WindowId(1, 4), w1.get());
   std::unique_ptr<ServerWindow> w2 = CreateChildWindow(WindowId(1, 5));
-  DisableHitTest(w2.get());
+  w2->set_event_targeting_policy(mojom::EventTargetingPolicy::DESCENDANTS_ONLY);
 
   root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   w1->SetBounds(gfx::Rect(0, 0, 100, 100));
   w11->SetBounds(gfx::Rect(10, 10, 10, 10));
   w2->SetBounds(gfx::Rect(0, 0, 100, 100));
 
   // Send event that is over |w11|.
   const ui::PointerEvent mouse_pressed(ui::MouseEvent(
       ui::ET_MOUSE_PRESSED, gfx::Point(15, 15), gfx::Point(15, 15),
       base::TimeTicks(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
@@ skipping 25 matching lines @@
   // Changing capture from client to non-client should notify the delegate.
   // The delegate can decide if it really wants to forward the event or not.
   EXPECT_EQ(child.get(),
             test_event_dispatcher_delegate()->lost_capture_window());
   EXPECT_EQ(child.get(), event_dispatcher()->capture_window());
   EXPECT_EQ(kClientAreaId, event_dispatcher()->capture_window_client_id());
 }
 
 TEST_F(EventDispatcherTest, MoveMouseFromNoTargetToValidTarget) {
   ServerWindow* root = root_window();
-  DisableHitTest(root);
+  root->set_event_targeting_policy(
+      mojom::EventTargetingPolicy::DESCENDANTS_ONLY);
   std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
   root->SetBounds(gfx::Rect(0, 0, 100, 100));
   child->SetBounds(gfx::Rect(10, 10, 20, 20));
 
   MouseEventTest tests[] = {
       // Send a mouse down over the root, but not the child. No event should
       // be generated.
       {ui::MouseEvent(ui::ET_MOUSE_MOVED, gfx::Point(5, 5), gfx::Point(5, 5),
                       base::TimeTicks(), 0, 0),
        nullptr, gfx::Point(), gfx::Point(), nullptr, gfx::Point(),
        gfx::Point()},
 
       // Move into child.
       {ui::MouseEvent(ui::ET_MOUSE_MOVED, gfx::Point(12, 12),
                       gfx::Point(12, 12), base::TimeTicks(), 0, 0),
        child.get(), gfx::Point(12, 12), gfx::Point(2, 2), nullptr, gfx::Point(),
        gfx::Point()}};
   RunMouseEventTests(event_dispatcher(), test_event_dispatcher_delegate(),
                      tests, arraysize(tests));
 }
 
 TEST_F(EventDispatcherTest, NoTargetToTargetWithMouseDown) {
   ServerWindow* root = root_window();
-  DisableHitTest(root);
+  root->set_event_targeting_policy(
+      mojom::EventTargetingPolicy::DESCENDANTS_ONLY);
   std::unique_ptr<ServerWindow> child = CreateChildWindow(WindowId(1, 3));
 
   root->SetBounds(gfx::Rect(0, 0, 100, 100));
   child->SetBounds(gfx::Rect(10, 10, 20, 20));
 
   MouseEventTest tests[] = {
       // Mouse over the root, but not the child. No event should be generated.
       {ui::MouseEvent(ui::ET_MOUSE_MOVED, gfx::Point(5, 5), gfx::Point(5, 5),
                       base::TimeTicks(), 0, 0),
        nullptr, gfx::Point(), gfx::Point(), nullptr, gfx::Point(),
@@ skipping 11 matching lines @@
                       gfx::Point(12, 12), base::TimeTicks(),
                       ui::EF_LEFT_MOUSE_BUTTON, 0),
        nullptr, gfx::Point(), gfx::Point(), nullptr, gfx::Point(),
        gfx::Point()}};
   RunMouseEventTests(event_dispatcher(), test_event_dispatcher_delegate(),
                      tests, arraysize(tests));
 }
 
 TEST_F(EventDispatcherTest, DontSendExitToSameClientWhenCaptureChanges) {
   ServerWindow* root = root_window();
-  DisableHitTest(root);
+  root->set_event_targeting_policy(
+      mojom::EventTargetingPolicy::DESCENDANTS_ONLY);
   std::unique_ptr<ServerWindow> c1 = CreateChildWindow(WindowId(1, 3));
   std::unique_ptr<ServerWindow> c2 = CreateChildWindow(WindowId(1, 4));
 
   root->SetBounds(gfx::Rect(0, 0, 100, 100));
   c1->SetBounds(gfx::Rect(10, 10, 20, 20));
   c2->SetBounds(gfx::Rect(15, 15, 20, 20));
 
   MouseEventTest tests[] = {
       // Mouse over |c2|.
       {ui::MouseEvent(ui::ET_MOUSE_MOVED, gfx::Point(16, 16),
@@ skipping 12 matching lines @@
 
   // Set capture on |c1|. No events should be sent as |c1| is in the same
   // client.
   event_dispatcher()->SetCaptureWindow(c1.get(), kClientAreaId);
   EXPECT_FALSE(test_event_dispatcher_delegate()->has_queued_events());
 }
 
 }  // namespace test
 }  // namespace ws
 }  // namespace ui