mash: changes can_accept_events to an enum

services/ui/ws/window_tree_unittest.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 "services/ui/ws/window_tree.h"
 
 #include <stdint.h>
 
 #include <string>
 #include <vector>
@@ skipping 205 matching lines @@
       wm_tree()->NewWindow(embed_window_id, ServerWindow::Properties()));
   ServerWindow* embed_window = wm_tree()->GetWindowByClientId(embed_window_id);
   ASSERT_TRUE(embed_window);
   EXPECT_TRUE(wm_tree()->SetWindowVisibility(embed_window_id, true));
   ASSERT_TRUE(FirstRoot(wm_tree()));
   const ClientWindowId wm_root_id = FirstRootId(wm_tree());
   EXPECT_TRUE(wm_tree()->AddWindow(wm_root_id, embed_window_id));
   ServerWindow* wm_root = FirstRoot(wm_tree());
   ASSERT_TRUE(wm_root);
   wm_root->SetBounds(gfx::Rect(0, 0, 100, 100));
-  EnableHitTest(wm_root);
+  // This tests expects |wm_root| to be a possible target.
+  wm_root->set_event_targeting_policy(
+      mojom::EventTargetingPolicy::TARGET_AND_DESCENDANTS);
   display()->root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
   mojom::WindowTreeClientPtr client;
   mojom::WindowTreeClientRequest client_request(&client);
   wm_client()->Bind(std::move(client_request));
   const uint32_t embed_flags = 0;
   wm_tree()->Embed(embed_window_id, std::move(client), embed_flags);
   WindowTree* tree1 = window_server()->GetTreeWithRoot(embed_window);
   ASSERT_TRUE(tree1 != nullptr);
   ASSERT_NE(tree1, wm_tree());
 
   embed_window->SetBounds(gfx::Rect(0, 0, 50, 50));
 
   const ClientWindowId child1_id(BuildClientWindowId(tree1, 1));
   EXPECT_TRUE(tree1->NewWindow(child1_id, ServerWindow::Properties()));
   EXPECT_TRUE(tree1->AddWindow(ClientWindowIdForWindow(tree1, embed_window),
                                child1_id));
   ServerWindow* child1 = tree1->GetWindowByClientId(child1_id);
   ASSERT_TRUE(child1);
   child1->SetVisible(true);
   child1->SetBounds(gfx::Rect(20, 20, 20, 20));
-  EnableHitTest(child1);
 
   TestWindowTreeClient* tree1_client = last_window_tree_client();
   tree1_client->tracker()->changes()->clear();
   wm_client()->tracker()->changes()->clear();
 
   // Focus should not go to |child1| yet, since the parent still doesn't allow
   // active children.
   DispatchEventAndAckImmediately(CreatePointerDownEvent(21, 22));
   Display* display1 = tree1->GetDisplay(embed_window);
   EXPECT_EQ(nullptr, display1->GetFocusedWindow());
@@ skipping 316 matching lines @@
 
   // Create a second window right over the first.
   const ClientWindowId embed_window_id(FirstRootId(tree));
   const ClientWindowId child2_id(BuildClientWindowId(tree, 2));
   EXPECT_TRUE(tree->NewWindow(child2_id, ServerWindow::Properties()));
   ServerWindow* child2 = tree->GetWindowByClientId(child2_id);
   ASSERT_TRUE(child2);
   EXPECT_TRUE(tree->AddWindow(embed_window_id, child2_id));
   child2->SetVisible(true);
   child2->SetBounds(gfx::Rect(20, 20, 20, 20));
-  EnableHitTest(child2);
 
   // Give each window a different cursor.
   window1->SetPredefinedCursor(mojom::Cursor::IBEAM);
   child2->SetPredefinedCursor(mojom::Cursor::HAND);
 
   // We expect window2 to be over window1 now.
   DispatchEventAndAckImmediately(CreateMouseMoveEvent(22, 22));
   EXPECT_EQ(mojom::Cursor::HAND, cursor_id());
 
   // But when we put window2 at the bottom, we should adapt window1's cursor.
   child2->parent()->StackChildAtBottom(child2);
   EXPECT_EQ(mojom::Cursor::IBEAM, cursor_id());
 }
 
 TEST_F(WindowTreeTest, EventAck) {
   const ClientWindowId embed_window_id = BuildClientWindowId(wm_tree(), 1);
   EXPECT_TRUE(
       wm_tree()->NewWindow(embed_window_id, ServerWindow::Properties()));
   EXPECT_TRUE(wm_tree()->SetWindowVisibility(embed_window_id, true));
   ASSERT_TRUE(FirstRoot(wm_tree()));
   EXPECT_TRUE(wm_tree()->AddWindow(FirstRootId(wm_tree()), embed_window_id));
   ASSERT_EQ(1u, display()->root_window()->children().size());
   ServerWindow* wm_root = FirstRoot(wm_tree());
   ASSERT_TRUE(wm_root);
   wm_root->SetBounds(gfx::Rect(0, 0, 100, 100));
-  EnableHitTest(wm_root);
+  // This tests expects |wm_root| to be a possible target.
+  wm_root->set_event_targeting_policy(
+      mojom::EventTargetingPolicy::TARGET_AND_DESCENDANTS);
 
   wm_client()->tracker()->changes()->clear();
   DispatchEventWithoutAck(CreateMouseMoveEvent(21, 22));
   ASSERT_EQ(1u, wm_client()->tracker()->changes()->size());
   EXPECT_EQ("InputEvent window=0,3 event_action=17",
             ChangesToDescription1(*wm_client()->tracker()->changes())[0]);
   wm_client()->tracker()->changes()->clear();
 
   // Send another event. This event shouldn't reach the client.
   DispatchEventWithoutAck(CreateMouseMoveEvent(21, 22));
@@ skipping 677 matching lines @@
   EXPECT_EQ("ChangeCompleted id=8 sucess=false",
             SingleChangeToDescription(*embed_client->tracker()->changes()));
 }
 
 TEST_F(WindowTreeTest, SetCanAcceptEvents) {
   TestWindowTreeClient* embed_client = nullptr;
   WindowTree* tree = nullptr;
   ServerWindow* window = nullptr;
   EXPECT_NO_FATAL_FAILURE(SetupEventTargeting(&embed_client, &tree, &window));
 
-  EXPECT_TRUE(window->can_accept_events());
-  WindowTreeTestApi(tree).SetCanAcceptEvents(
-      ClientWindowIdForWindow(tree, window).id, false);
-  EXPECT_FALSE(window->can_accept_events());
+  EXPECT_EQ(mojom::EventTargetingPolicy::TARGET_AND_DESCENDANTS,
+            window->event_targeting_policy());
+  WindowTreeTestApi(tree).SetEventTargetingPolicy(
+      ClientWindowIdForWindow(tree, window).id,
+      mojom::EventTargetingPolicy::NONE);
+  EXPECT_EQ(mojom::EventTargetingPolicy::NONE,
+            window->event_targeting_policy());
 }
 
 // Verifies wm observers capture changes in client.
 TEST_F(WindowTreeTest, CaptureNotifiesWm) {
   ServerWindow* window = window_event_targeting_helper_.CreatePrimaryTree(
       gfx::Rect(0, 0, 100, 100), gfx::Rect(0, 0, 50, 50));
   TestWindowTreeClient* embed_client = last_window_tree_client();
   WindowTree* owning_tree =
       window_server()->GetTreeWithId(window->id().client_id);
   WindowTree* embed_tree = window_server()->GetTreeWithRoot(window);
@@ skipping 60 matching lines @@
     client->tracker()->changes()->clear();
   }
 
   // Client should not have got any messages after shutdown.
   EXPECT_TRUE(client->tracker()->changes()->empty());
 }
 
 }  // namespace test
 }  // namespace ws
 }  // namespace ui