Keep root_location to be in pixels and display coordinates in WS.

services/ui/ws/window_manager_state_unittest.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 "services/ui/ws/window_manager_state.h"
 
 #include <memory>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 29 matching lines @@
 
   std::unique_ptr<Accelerator> CreateAccelerator();
 
   // Creates a child |server_window| with associataed |window_tree| and
   // |test_client|. The window is setup for processing input.
   void CreateSecondaryTree(TestWindowTreeClient** test_client,
                            WindowTree** window_tree,
                            ServerWindow** server_window);
 
   void DispatchInputEventToWindow(ServerWindow* target,
+                                  const int64_t display_id,
                                   const ui::Event& event,
                                   Accelerator* accelerator);
   void OnEventAckTimeout(ClientSpecificId client_id);
 
   // This is the tree associated with the WindowManagerState. That is, this is
   // the WindowTree of the WindowManager.
   WindowTree* tree() {
     return window_event_targeting_helper_.window_server()->GetTreeWithId(1);
   }
   // This is *not* the tree associated with the WindowManagerState, use tree()
@@ skipping 71 matching lines @@
     TestWindowTreeClient** test_client,
     WindowTree** window_tree,
     ServerWindow** server_window) {
   window_event_targeting_helper_.CreateSecondaryTree(
       window_, gfx::Rect(20, 20, 20, 20), test_client, window_tree,
       server_window);
 }
 
 void WindowManagerStateTest::DispatchInputEventToWindow(
     ServerWindow* target,
+    const int64_t display_id,
     const ui::Event& event,
     Accelerator* accelerator) {
   WindowManagerStateTestApi test_api(window_manager_state_);
   ClientSpecificId client_id = test_api.GetEventTargetClientId(target, false);
-  test_api.DispatchInputEventToWindow(target, client_id, event, accelerator);
+  test_api.DispatchInputEventToWindow(target, client_id, display_id, event,
+                                      accelerator);
 }
 
 void WindowManagerStateTest::OnEventAckTimeout(
     ClientSpecificId client_id) {
   WindowManagerStateTestApi test_api(window_manager_state_);
   test_api.OnEventAckTimeout(client_id);
 }
 
 void WindowManagerStateTest::SetUp() {
   window_event_targeting_helper_.SetTaskRunner(task_runner_);
@@ skipping 19 matching lines @@
   }
 }
 
 // Tests that when an event is dispatched with no accelerator, that post target
 // accelerator is not triggered.
 TEST_F(WindowManagerStateTest, NullAccelerator) {
   WindowManagerState* state = window_manager_state();
   EXPECT_TRUE(state);
 
   ServerWindow* target = window();
+  const Display* display = window_tree()->GetDisplay(target);
+  DCHECK(display);
   ui::KeyEvent key(ui::ET_KEY_PRESSED, ui::VKEY_W, ui::EF_CONTROL_DOWN);
-  DispatchInputEventToWindow(target, key, nullptr);
+  DispatchInputEventToWindow(target, display->GetId(), key, nullptr);
   WindowTree* target_tree = window_tree();
   TestChangeTracker* tracker = window_tree_client()->tracker();
   ASSERT_EQ(1u, tracker->changes()->size());
   EXPECT_EQ("InputEvent window=1,1 event_action=7",
             ChangesToDescription1(*tracker->changes())[0]);
 
   WindowTreeTestApi(target_tree).AckOldestEvent();
   EXPECT_FALSE(window_manager()->on_accelerator_called());
 }
 
 // Tests that when a post target accelerator is provided on an event, that it is
 // called on ack.
 TEST_F(WindowManagerStateTest, PostTargetAccelerator) {
   ui::KeyEvent key(ui::ET_KEY_PRESSED, ui::VKEY_W, ui::EF_CONTROL_DOWN);
   std::unique_ptr<Accelerator> accelerator = CreateAccelerator();
 
   ServerWindow* target = window();
-  DispatchInputEventToWindow(target, key, accelerator.get());
+  const Display* display = window_tree()->GetDisplay(target);
+  DCHECK(display);
+  DispatchInputEventToWindow(target, display->GetId(), key, accelerator.get());
   TestChangeTracker* tracker = window_tree_client()->tracker();
   ASSERT_EQ(1u, tracker->changes()->size());
   EXPECT_EQ("InputEvent window=1,1 event_action=7",
             ChangesToDescription1(*tracker->changes())[0]);
 
   WindowTreeTestApi(window_tree()).AckOldestEvent();
   EXPECT_TRUE(window_manager()->on_accelerator_called());
   EXPECT_EQ(accelerator->id(), window_manager()->on_accelerator_id());
 }
 
@@ skipping 128 matching lines @@
   EXPECT_TRUE((*tracker2->changes())[0].key_event_properties.empty());
 }
 
 // Tests that when a client handles an event that post target accelerators are
 // not called.
 TEST_F(WindowManagerStateTest, ClientHandlesEvent) {
   ui::KeyEvent key(ui::ET_KEY_PRESSED, ui::VKEY_W, ui::EF_CONTROL_DOWN);
   std::unique_ptr<Accelerator> accelerator = CreateAccelerator();
 
   ServerWindow* target = window();
-  DispatchInputEventToWindow(target, key, accelerator.get());
+  const Display* display = window_tree()->GetDisplay(target);
+  DCHECK(display);
+  DispatchInputEventToWindow(target, display->GetId(), key, accelerator.get());
   TestChangeTracker* tracker = window_tree_client()->tracker();
   ASSERT_EQ(1u, tracker->changes()->size());
   EXPECT_EQ("InputEvent window=1,1 event_action=7",
             ChangesToDescription1(*tracker->changes())[0]);
 
   EXPECT_TRUE(WindowManagerStateTestApi(window_manager_state())
                   .AckInFlightEvent(mojom::EventResult::HANDLED));
   EXPECT_FALSE(window_manager()->on_accelerator_called());
 }
 
 // Tests that when an accelerator is deleted before an ack, that it is not
 // called.
 TEST_F(WindowManagerStateTest, AcceleratorDeleted) {
   ui::KeyEvent key(ui::ET_KEY_PRESSED, ui::VKEY_W, ui::EF_CONTROL_DOWN);
   std::unique_ptr<Accelerator> accelerator(CreateAccelerator());
 
   ServerWindow* target = window();
-  DispatchInputEventToWindow(target, key, accelerator.get());
+  const Display* display = window_tree()->GetDisplay(target);
+  DCHECK(display);
+  DispatchInputEventToWindow(target, display->GetId(), key, accelerator.get());
   TestChangeTracker* tracker = window_tree_client()->tracker();
   ASSERT_EQ(1u, tracker->changes()->size());
   EXPECT_EQ("InputEvent window=1,1 event_action=7",
             ChangesToDescription1(*tracker->changes())[0]);
 
   accelerator.reset();
   EXPECT_TRUE(WindowManagerStateTestApi(window_manager_state())
                   .AckInFlightEvent(mojom::EventResult::UNHANDLED));
   EXPECT_FALSE(window_manager()->on_accelerator_called());
 }
 
 // Tests that a events arriving before an ack don't notify the tree until the
 // ack arrives, and that the correct accelerator is called.
 TEST_F(WindowManagerStateTest, EnqueuedAccelerators) {
   ui::KeyEvent key(ui::ET_KEY_PRESSED, ui::VKEY_W, ui::EF_CONTROL_DOWN);
   std::unique_ptr<Accelerator> accelerator(CreateAccelerator());
 
   ServerWindow* target = window();
-  DispatchInputEventToWindow(target, key, accelerator.get());
+  const Display* display = window_tree()->GetDisplay(target);
+  DCHECK(display);
+  DispatchInputEventToWindow(target, display->GetId(), key, accelerator.get());
   TestChangeTracker* tracker = window_tree_client()->tracker();
   ASSERT_EQ(1u, tracker->changes()->size());
   EXPECT_EQ("InputEvent window=1,1 event_action=7",
             ChangesToDescription1(*tracker->changes())[0]);
 
   tracker->changes()->clear();
   ui::KeyEvent key2(ui::ET_KEY_PRESSED, ui::VKEY_Y, ui::EF_CONTROL_DOWN);
   mojom::EventMatcherPtr matcher = ui::CreateKeyMatcher(
       ui::mojom::KeyboardCode::Y, ui::mojom::kEventFlagControlDown);
   matcher->accelerator_phase = ui::mojom::AcceleratorPhase::POST_TARGET;
   uint32_t accelerator_id = 2;
   std::unique_ptr<Accelerator> accelerator2(
       new Accelerator(accelerator_id, *matcher));
-  DispatchInputEventToWindow(target, key2, accelerator2.get());
+  DispatchInputEventToWindow(target, display->GetId(), key2,
+                             accelerator2.get());
   EXPECT_TRUE(tracker->changes()->empty());
 
   WindowTreeTestApi(window_tree()).AckOldestEvent();
   ASSERT_EQ(1u, tracker->changes()->size());
   EXPECT_EQ("InputEvent window=1,1 event_action=7",
             ChangesToDescription1(*tracker->changes())[0]);
   EXPECT_TRUE(window_manager()->on_accelerator_called());
   EXPECT_EQ(accelerator->id(), window_manager()->on_accelerator_id());
 }
 
 // Tests that the accelerator is not sent when the tree is dying.
 TEST_F(WindowManagerStateTest, DeleteTree) {
   ui::KeyEvent key(ui::ET_KEY_PRESSED, ui::VKEY_W, ui::EF_CONTROL_DOWN);
   std::unique_ptr<Accelerator> accelerator = CreateAccelerator();
 
   ServerWindow* target = window();
-  DispatchInputEventToWindow(target, key, accelerator.get());
+  const Display* display = window_tree()->GetDisplay(target);
+  DCHECK(display);
+  DispatchInputEventToWindow(target, display->GetId(), key, accelerator.get());
   TestChangeTracker* tracker = window_tree_client()->tracker();
   ASSERT_EQ(1u, tracker->changes()->size());
   EXPECT_EQ("InputEvent window=1,1 event_action=7",
             ChangesToDescription1(*tracker->changes())[0]);
 
   window_manager_state()->OnWillDestroyTree(tree());
   EXPECT_FALSE(window_manager()->on_accelerator_called());
 }
 
 // Tests that if a tree is destroyed before acking, that the accelerator is
 // still sent if it is not the root tree.
 TEST_F(WindowManagerStateTest, DeleteNonRootTree) {
   TestWindowTreeClient* embed_connection = nullptr;
   WindowTree* target_tree = nullptr;
   ServerWindow* target = nullptr;
   CreateSecondaryTree(&embed_connection, &target_tree, &target);
   TestWindowManager target_window_manager;
   WindowTreeTestApi(target_tree)
       .set_window_manager_internal(&target_window_manager);
 
   ui::KeyEvent key(ui::ET_KEY_PRESSED, ui::VKEY_W, ui::EF_CONTROL_DOWN);
   std::unique_ptr<Accelerator> accelerator = CreateAccelerator();
-  DispatchInputEventToWindow(target, key, accelerator.get());
+  const Display* display = target_tree->GetDisplay(target);
+  DCHECK(display);
+  DispatchInputEventToWindow(target, display->GetId(), key, accelerator.get());
   TestChangeTracker* tracker = embed_connection->tracker();
   ASSERT_EQ(1u, tracker->changes()->size());
   EXPECT_EQ("InputEvent window=2,1 event_action=7",
             ChangesToDescription1(*tracker->changes())[0]);
   EXPECT_TRUE(wm_client()->tracker()->changes()->empty());
 
   window_manager_state()->OnWillDestroyTree(target_tree);
   EXPECT_FALSE(target_window_manager.on_accelerator_called());
   EXPECT_TRUE(window_manager()->on_accelerator_called());
 }
 
 // Tests that if a tree is destroyed before acking an event, that mus won't
 // then try to send any queued events.
 TEST_F(WindowManagerStateTest, DontSendQueuedEventsToADeadTree) {
   ServerWindow* target = window();
   TestChangeTracker* tracker = window_tree_client()->tracker();
 
+  const Display* display = window_tree()->GetDisplay(target);
+  DCHECK(display);
   ui::MouseEvent press(ui::ET_MOUSE_PRESSED, gfx::Point(5, 5), gfx::Point(5, 5),
                        base::TimeTicks(), EF_LEFT_MOUSE_BUTTON,
                        EF_LEFT_MOUSE_BUTTON);
-  DispatchInputEventToWindow(target, press, nullptr);
+  DispatchInputEventToWindow(target, display->GetId(), press, nullptr);
   ASSERT_EQ(1u, tracker->changes()->size());
   EXPECT_EQ("InputEvent window=1,1 event_action=1",
             ChangesToDescription1(*tracker->changes())[0]);
   tracker->changes()->clear();
   // The above is not setting TreeAwaitingInputAck.
 
   // Queue the key release event; it should not be immediately dispatched
   // because there's no ACK for the last one.
   ui::MouseEvent release(ui::ET_MOUSE_RELEASED, gfx::Point(5, 5),
                          gfx::Point(5, 5), base::TimeTicks(),
                          EF_LEFT_MOUSE_BUTTON, EF_LEFT_MOUSE_BUTTON);
-  DispatchInputEventToWindow(target, release, nullptr);
+  DispatchInputEventToWindow(target, display->GetId(), release, nullptr);
   EXPECT_EQ(0u, tracker->changes()->size());
 
   // Destroying a window tree with an event in queue shouldn't crash.
   DestroyWindowTree();
 }
 
 // Tests that when an ack times out that the accelerator is notified.
 TEST_F(WindowManagerStateTest, AckTimeout) {
   ui::KeyEvent key(ui::ET_KEY_PRESSED, ui::VKEY_W, ui::EF_CONTROL_DOWN);
   std::unique_ptr<Accelerator> accelerator = CreateAccelerator();
-  DispatchInputEventToWindow(window(), key, accelerator.get());
+  const Display* display = window_tree()->GetDisplay(window());
+  DCHECK(display);
+  DispatchInputEventToWindow(window(), display->GetId(), key,
+                             accelerator.get());
   TestChangeTracker* tracker = window_tree_client()->tracker();
   ASSERT_EQ(1u, tracker->changes()->size());
   EXPECT_EQ("InputEvent window=1,1 event_action=7",
             ChangesToDescription1(*tracker->changes())[0]);
 
   OnEventAckTimeout(window()->id().client_id);
   EXPECT_TRUE(window_manager()->on_accelerator_called());
   EXPECT_EQ(accelerator->id(), window_manager()->on_accelerator_id());
 }
 
@@ skipping 14 matching lines @@
   {
     // Do a normal embed.
     const uint32_t embed_flags = 0;
     WindowTree* embed_tree = nullptr;
     TestWindowTreeClient* embed_client_proxy = nullptr;
     EmbedAt(embedder_tree, embed_window_id, embed_flags, &embed_tree,
             &embed_client_proxy);
     ASSERT_TRUE(embed_client_proxy);
 
     // Send an event to the embed window. It should go to the embedded client.
+    const Display* display = embed_tree->GetDisplay(embedder_window);
+    DCHECK(display);
     ui::MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(), gfx::Point(),
                          base::TimeTicks(), 0, 0);
-    DispatchInputEventToWindow(embedder_window, mouse, nullptr);
+    DispatchInputEventToWindow(embedder_window, display->GetId(), mouse,
+                               nullptr);
     ASSERT_EQ(1u, embed_client_proxy->tracker()->changes()->size());
     EXPECT_EQ(CHANGE_TYPE_INPUT_EVENT,
               (*embed_client_proxy->tracker()->changes())[0].type);
     WindowTreeTestApi(embed_tree).AckLastEvent(mojom::EventResult::UNHANDLED);
     embed_client_proxy->tracker()->changes()->clear();
   }
 
   {
     // Do an embed where the embedder wants to intercept events to the embedded
     // tree.
     const uint32_t embed_flags = mojom::kEmbedFlagEmbedderInterceptsEvents;
     WindowTree* embed_tree = nullptr;
     TestWindowTreeClient* embed_client_proxy = nullptr;
     EmbedAt(embedder_tree, embed_window_id, embed_flags, &embed_tree,
             &embed_client_proxy);
     ASSERT_TRUE(embed_client_proxy);
     embedder_client->tracker()->changes()->clear();
 
     // Send an event to the embed window. But this time, it should reach the
     // embedder.
+    const Display* display = embed_tree->GetDisplay(embedder_window);
+    DCHECK(display);
     ui::MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(), gfx::Point(),
                          base::TimeTicks(), 0, 0);
-    DispatchInputEventToWindow(embedder_window, mouse, nullptr);
+    DispatchInputEventToWindow(embedder_window, display->GetId(), mouse,
+                               nullptr);
     ASSERT_EQ(0u, embed_client_proxy->tracker()->changes()->size());
     ASSERT_EQ(1u, embedder_client->tracker()->changes()->size());
     EXPECT_EQ(CHANGE_TYPE_INPUT_EVENT,
               (*embedder_client->tracker()->changes())[0].type);
     WindowTreeTestApi(embedder_tree)
         .AckLastEvent(mojom::EventResult::UNHANDLED);
     embedder_client->tracker()->changes()->clear();
 
     // Embed another tree in the embedded tree.
     const ClientWindowId nested_embed_window_id(
@@ skipping 11 matching lines @@
     embed_client_proxy->tracker()->changes()->clear();
     embedder_client->tracker()->changes()->clear();
 
     // Send an event to the nested embed window. The event should still reach
     // the outermost embedder.
     ServerWindow* nested_embed_window =
         embed_tree->GetWindowByClientId(nested_embed_window_id);
     DCHECK(nested_embed_window->parent());
     mouse = ui::MouseEvent(ui::ET_MOUSE_MOVED, gfx::Point(), gfx::Point(),
                            base::TimeTicks(), 0, 0);
-    DispatchInputEventToWindow(nested_embed_window, mouse, nullptr);
+    DispatchInputEventToWindow(nested_embed_window, display->GetId(), mouse,
+                               nullptr);
     ASSERT_EQ(0u, nested_embed_client_proxy->tracker()->changes()->size());
     ASSERT_EQ(0u, embed_client_proxy->tracker()->changes()->size());
 
     ASSERT_EQ(1u, embedder_client->tracker()->changes()->size());
     EXPECT_EQ(CHANGE_TYPE_INPUT_EVENT,
               (*embedder_client->tracker()->changes())[0].type);
     WindowTreeTestApi(embedder_tree)
         .AckLastEvent(mojom::EventResult::UNHANDLED);
   }
 }
 
 // Ensures accelerators are forgotten between events.
 TEST_F(WindowManagerStateTest, PostAcceleratorForgotten) {
   // Send an event that matches the accelerator and have the target respond
   // that it handled the event so that the accelerator isn't called.
   ui::KeyEvent accelerator_key(ui::ET_KEY_PRESSED, ui::VKEY_W,
                                ui::EF_CONTROL_DOWN);
   std::unique_ptr<Accelerator> accelerator = CreateAccelerator();
   ServerWindow* target = window();
-  DispatchInputEventToWindow(target, accelerator_key, accelerator.get());
+  const Display* display = window_tree()->GetDisplay(target);
+  DCHECK(display);
+  DispatchInputEventToWindow(target, display->GetId(), accelerator_key,
+                             accelerator.get());
   TestChangeTracker* tracker = window_tree_client()->tracker();
   ASSERT_EQ(1u, tracker->changes()->size());
   EXPECT_EQ("InputEvent window=1,1 event_action=7",
             ChangesToDescription1(*tracker->changes())[0]);
   tracker->changes()->clear();
   WindowTreeTestApi(window_tree()).AckLastEvent(mojom::EventResult::HANDLED);
   EXPECT_FALSE(window_manager()->on_accelerator_called());
 
   // Send another event that doesn't match the accelerator, the accelerator
   // shouldn't be called.
   ui::KeyEvent non_accelerator_key(ui::ET_KEY_PRESSED, ui::VKEY_T,
                                    ui::EF_CONTROL_DOWN);
-  DispatchInputEventToWindow(target, non_accelerator_key, nullptr);
+  DispatchInputEventToWindow(target, display->GetId(), non_accelerator_key,
+                             nullptr);
   ASSERT_EQ(1u, tracker->changes()->size());
   EXPECT_EQ("InputEvent window=1,1 event_action=7",
             ChangesToDescription1(*tracker->changes())[0]);
   WindowTreeTestApi(window_tree()).AckLastEvent(mojom::EventResult::UNHANDLED);
   EXPECT_FALSE(window_manager()->on_accelerator_called());
 }
 
 // Verifies there is no crash if the WindowTree of a window manager is destroyed
 // with no roots.
 TEST(WindowManagerStateShutdownTest, DestroyTreeBeforeDisplay) {
@@ skipping 37 matching lines @@
       base::TimeTicks());
   window_manager_state()->ProcessEvent(move, 0);
   // The event isn't over a valid target, which should trigger resetting the
   // cursor to POINTER.
   EXPECT_EQ(ui::CursorType::kPointer, cursor_type());
 }
 
 }  // namespace test
 }  // namespace ws
 }  // namespace ui