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 74 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 51 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()
+                  ->event_targeter()
+                  ->IsHitTestInFlight());
+  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.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()
+                  ->event_targeter()
+                  ->IsHitTestInFlight());
+  EXPECT_FALSE(test_api.event_queue_empty());
+  task_runner_->RunUntilIdle();
+  EXPECT_TRUE(test_api.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