Make event-targeting asynchronous in window server.

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/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "services/service_manager/public/interfaces/connector.mojom.h"
 #include "services/ui/common/accelerator_util.h"
 #include "services/ui/ws/accelerator.h"
 #include "services/ui/ws/display.h"
 #include "services/ui/ws/display_manager.h"
@@ skipping 21 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,
+                                  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 32 matching lines @@
   }
 
   void DestroyWindowTree() {
     window_event_targeting_helper_.window_server()->DestroyTree(window_tree_);
     window_tree_ = nullptr;
   }
 
   // testing::Test:
   void SetUp() override;
 
+ protected:
+  // Handles WindowStateManager ack timeouts.
+  scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
+
  private:
   WindowEventTargetingHelper window_event_targeting_helper_;
 
   WindowManagerState* window_manager_state_;
 
-  // Handles WindowStateManager ack timeouts.
-  scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   TestWindowManager window_manager_;
   ServerWindow* window_ = nullptr;
   WindowTree* window_tree_ = nullptr;
   TestWindowTreeClient* window_tree_client_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(WindowManagerStateTest);
 };
 
 WindowManagerStateTest::WindowManagerStateTest()
     : task_runner_(new base::TestSimpleTaskRunner) {}
@@ skipping 12 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,
+    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, display_id, event,
                                       accelerator);
 }
 
 void WindowManagerStateTest::OnEventAckTimeout(
     ClientSpecificId client_id) {
@@ skipping 18 matching lines @@
   window_tree_client_->tracker()->changes()->clear();
 }
 
 void SetCanFocusUp(ServerWindow* window) {
   while (window) {
     window->set_can_focus(true);
     window = window->parent();
   }
 }
 
+class WindowManagerStateTestAsync : public WindowManagerStateTest {
+ public:
+  WindowManagerStateTestAsync() {}
+  ~WindowManagerStateTestAsync() override {}
+
+  // WindowManagerStateTest:
+  void SetUp() override {
+    base::CommandLine::ForCurrentProcess()->AppendSwitch(
+        "enable-async-event-targeting");
+    WindowManagerStateTest::SetUp();
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(WindowManagerStateTestAsync);
+};
+
 // 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);
@@ skipping 501 matching lines @@
   ui::PointerEvent move(
       ui::ET_POINTER_MOVED, gfx::Point(25, 25), gfx::Point(25, 25), 0, 0,
       ui::PointerDetails(EventPointerType::POINTER_TYPE_MOUSE, 0),
       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());
 }
 
+TEST_F(WindowManagerStateTestAsync, CursorResetOverNoTargetAsync) {
+  ASSERT_EQ(1u, window_server()->display_manager()->displays().size());
+  const ClientWindowId child_window_id(11);
+  window_tree()->NewWindow(child_window_id, ServerWindow::Properties());
+  ServerWindow* child_window =
+      window_tree()->GetWindowByClientId(child_window_id);
+  window_tree()->AddWindow(FirstRootId(window_tree()), child_window_id);
+  // Setup steps already do hit-test for mouse cursor update so this should go
+  // to the queue in EventDispatcher.
+  EXPECT_TRUE(window_manager_state()->event_dispatcher()->IsProcessingEvent());
+  child_window->SetVisible(true);
+  child_window->SetBounds(gfx::Rect(0, 0, 20, 20));
+  child_window->parent()->SetCursor(ui::CursorData(ui::CursorType::kCopy));
+  // Move the mouse outside the bounds of the child, so that the mouse is not
+  // over any valid windows. Cursor should change to POINTER.
+  ui::PointerEvent move(
+      ui::ET_POINTER_MOVED, gfx::Point(25, 25), gfx::Point(25, 25), 0, 0,
+      ui::PointerDetails(EventPointerType::POINTER_TYPE_MOUSE, 0),
+      base::TimeTicks());
+  WindowManagerStateTestApi test_api(window_manager_state());
+  EXPECT_TRUE(test_api.is_event_queue_empty());
+  window_manager_state()->ProcessEvent(move, 0);
+  // There's no event dispatching in flight but there's hit-test in flight in
+  // EventDispatcher so we still put event processing request into the queue
+  // in WindowManagerState.
+  EXPECT_FALSE(test_api.tree_awaiting_input_ack());
+  EXPECT_TRUE(window_manager_state()->event_dispatcher()->IsProcessingEvent());
+  EXPECT_FALSE(test_api.is_event_queue_empty());
+  task_runner_->RunUntilIdle();
+  EXPECT_TRUE(test_api.is_event_queue_empty());
+  // 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