mus: Implement Window Server Capture

components/mus/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 "components/mus/ws/event_dispatcher.h"
 
 #include "components/mus/public/cpp/event_matcher.h"
 #include "components/mus/ws/event_dispatcher_delegate.h"
 #include "components/mus/ws/server_window.h"
 #include "components/mus/ws/test_server_window_delegate.h"
@@ skipping 49 matching lines @@
   void OnAccelerator(uint32_t accelerator, mojom::EventPtr event) override {
     EXPECT_EQ(0u, last_accelerator_);
     last_accelerator_ = accelerator;
   }
   void SetFocusedWindowFromEventDispatcher(ServerWindow* window) override {
     focused_window_ = window;
   }
   ServerWindow* GetFocusedWindowForEventDispatcher() override {
     return focused_window_;
   }
+  void OnLostCapture(ServerWindow* window) override {}
   void DispatchInputEventToWindow(ServerWindow* target,
                                   bool in_nonclient_area,
                                   mojom::EventPtr event) override {
     last_target_ = target;
     last_dispatched_event_ = event.Pass();
     last_in_nonclient_area_ = in_nonclient_area;
   }
 
   ServerWindow* root_;
   ServerWindow* focused_window_;
@@ skipping 413 matching lines @@
 
   const ui::TouchEvent drag_event1(ui::ET_TOUCH_MOVED, gfx::Point(53, 54), 1,
                                    base::TimeDelta());
   dispatcher.OnEvent(
       mojom::Event::From(static_cast<const ui::Event&>(drag_event1)));
   EXPECT_EQ(nullptr, event_dispatcher_delegate.GetAndClearLastTarget());
   EXPECT_EQ(nullptr,
             event_dispatcher_delegate.GetAndClearLastDispatchedEvent().get());
 }
 
+TEST(EventDispatcherTest, SetExplictCapture) {
+  TestServerWindowDelegate window_delegate;
+  ServerWindow root(&window_delegate, WindowId(1, 2));
+  window_delegate.set_root_window(&root);
+  root.SetVisible(true);
+
+  ServerWindow child(&window_delegate, WindowId(1, 3));
+  root.Add(&child);
+  child.SetVisible(true);
+
+  root.SetBounds(gfx::Rect(0, 0, 100, 100));
+  child.SetBounds(gfx::Rect(10, 10, 20, 20));
+
+  TestEventDispatcherDelegate event_dispatcher_delegate(&root);
+  EventDispatcher dispatcher(&event_dispatcher_delegate);
+  dispatcher.set_root(&root);
+
+  {
+    // Send all pointer events to the child.
+    dispatcher.SetCaptureWindow(&child);
+
+    // The mouse press should go to the child even though its outside its
+    // bounds.
+    const ui::MouseEvent press_event(
+        ui::ET_MOUSE_PRESSED, gfx::Point(5, 5), gfx::Point(5, 5),
+        base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
+    dispatcher.OnEvent(
+        mojom::Event::From(static_cast<const ui::Event&>(press_event)));
+
+    // Events should target child.
+    ASSERT_EQ(&child, event_dispatcher_delegate.last_target());
+  }
+
+  {
+    // Releasing capture and sending the same event will go to the root.
+    dispatcher.SetCaptureWindow(nullptr);
+    const ui::MouseEvent press_event(
+        ui::ET_MOUSE_PRESSED, gfx::Point(5, 5), gfx::Point(5, 5),
+        base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
+    dispatcher.OnEvent(
+        mojom::Event::From(static_cast<const ui::Event&>(press_event)));
+
+    // Events should target the root.
+    ASSERT_EQ(&root, event_dispatcher_delegate.last_target());
+  }
+}
+
+// This test verifies that explicit capture overrides and resets implicit
+// capture.
+TEST(EventDispatcherTest, ExplicitCaptureOverridesImplicitCapture) {
+  TestServerWindowDelegate window_delegate;
+  ServerWindow root(&window_delegate, WindowId(1, 2));
+  window_delegate.set_root_window(&root);
+  root.SetVisible(true);
+
+  ServerWindow child(&window_delegate, WindowId(1, 3));
+  root.Add(&child);
+  child.SetVisible(true);
+
+  root.SetBounds(gfx::Rect(0, 0, 100, 100));
+  child.SetBounds(gfx::Rect(10, 10, 20, 20));
+
+  TestEventDispatcherDelegate event_dispatcher_delegate(&root);
+  EventDispatcher dispatcher(&event_dispatcher_delegate);
+  dispatcher.set_root(&root);
+
+  // Run some implicit capture tests.
+  MouseEventTest tests[] = {
+      // Send a mouse down event over child with a left mouse button
+      {ui::MouseEvent(ui::ET_MOUSE_PRESSED, gfx::Point(20, 25),
+                      gfx::Point(20, 25), base::TimeDelta(),
+                      ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON),
+       &child, gfx::Point(20, 25), gfx::Point(10, 15)},
+      // Capture should be activated. Let's send a mouse move outside the bounds
+      // of the child and press the right mouse button too.
+      {ui::MouseEvent(ui::ET_MOUSE_MOVED, gfx::Point(50, 50),
+                      gfx::Point(50, 50), base::TimeDelta(),
+                      ui::EF_LEFT_MOUSE_BUTTON | ui::EF_RIGHT_MOUSE_BUTTON, 0),
+       &child, gfx::Point(50, 50), gfx::Point(40, 40)},
+      // Release the left mouse button and verify that the mouse up event goes
+      // to the child.
+      {ui::MouseEvent(ui::ET_MOUSE_RELEASED, gfx::Point(50, 50),
+                      gfx::Point(50, 50), base::TimeDelta(),
+                      ui::EF_LEFT_MOUSE_BUTTON | ui::EF_RIGHT_MOUSE_BUTTON,
+                      ui::EF_RIGHT_MOUSE_BUTTON),
+       &child, gfx::Point(50, 50), gfx::Point(40, 40)},
+      // A mouse move at (50, 50) should still go to the child.
+      {ui::MouseEvent(ui::ET_MOUSE_MOVED, gfx::Point(50, 50),
+                      gfx::Point(50, 50), base::TimeDelta(),
+                      ui::EF_LEFT_MOUSE_BUTTON, 0),
+       &child, gfx::Point(50, 50), gfx::Point(40, 40)},
+
+  };
+  RunMouseEventTests(&dispatcher, &event_dispatcher_delegate, tests,
+                     arraysize(tests));
+  ASSERT_EQ(&child, event_dispatcher_delegate.last_target());
+
+  // Verify that no window has explicit capture and hence we did indeed do
+  // implicit capture.
+  ASSERT_EQ(nullptr, dispatcher.capture_window());
+
+  // Give the root window explicit capture and verify input evnets over the
+  // child go to the root instead.
+  dispatcher.SetCaptureWindow(&root);
+  const ui::MouseEvent press_event(
+      ui::ET_MOUSE_PRESSED, gfx::Point(15, 15), gfx::Point(15, 15),
+      base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
+  dispatcher.OnEvent(
+      mojom::Event::From(static_cast<const ui::Event&>(press_event)));
+
+  // Events should target the root.
+  ASSERT_EQ(&root, event_dispatcher_delegate.last_target());
+}
+
 }  // namespace ws
 }  // namespace mus