mus Window Server: implement event capture

components/mus/ws/window_tree_apptest.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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 273 matching lines @@
     tree_ = std::move(tree);
     connection_id_ = connection_id;
     tracker()->OnEmbed(connection_id, std::move(root));
     if (embed_run_loop_)
       embed_run_loop_->Quit();
   }
   void OnEmbeddedAppDisconnected(Id window_id) override {
     tracker()->OnEmbeddedAppDisconnected(window_id);
   }
   void OnUnembed(Id window_id) override { tracker()->OnUnembed(window_id); }
+  void OnLostCapture(Id window_id) override {
+    tracker()->OnLostCapture(window_id);
+  }
   void OnTopLevelCreated(uint32_t change_id,
                          mojom::WindowDataPtr data) override {
     tracker()->OnTopLevelCreated(change_id, std::move(data));
   }
   void OnWindowBoundsChanged(Id window_id,
                              RectPtr old_bounds,
                              RectPtr new_bounds) override {
     // The bounds of the root may change during startup on Android at random
     // times. As this doesn't matter, and shouldn't impact test exepctations,
     // it is ignored.
@@ skipping 37 matching lines @@
   }
   void OnWindowVisibilityChanged(uint32_t window, bool visible) override {
     tracker()->OnWindowVisibilityChanged(window, visible);
   }
   void OnWindowDrawnStateChanged(uint32_t window, bool drawn) override {
     tracker()->OnWindowDrawnStateChanged(window, drawn);
   }
   void OnWindowInputEvent(uint32_t event_id,
                           Id window_id,
                           EventPtr event) override {
+    // Ack input events to clear the state on the server. These can be received
+    // during test startup. X11Window::DispatchEvent sends a synthetic move
+    // event to notify of entry.
+    tree()->OnWindowInputEventAck(event_id);
     // Don't log input events as none of the tests care about them and they
     // may come in at random points.
   }
   void OnWindowSharedPropertyChanged(uint32_t window,
                                      const String& name,
                                      Array<uint8_t> new_data) override {
     tracker_.OnWindowSharedPropertyChanged(window, name, std::move(new_data));
   }
   // TODO(sky): add testing coverage.
   void OnWindowFocused(uint32_t focused_window_id) override {}
@@ skipping 1491 matching lines @@
   // Remove 2_101 from wm, client1 should see the change.
   ws1()->RemoveWindowFromParent(12, window_2_101_in_ws1);
   ASSERT_TRUE(ws_client1()->WaitForChangeCompleted(12));
   ws_client2()->WaitForChangeCount(1);
   EXPECT_EQ("HierarchyChanged window=" + IdToString(window_2_101) +
                 " new_parent=null old_parent=" +
                 IdToString(window_1_100_in_ws2),
             SingleChangeToDescription(*changes2()));
 }
 
+// Tests that setting capture fails when no input event has occurred, and there
+// is no notification of lost capture.
+TEST_F(WindowTreeAppTest, ExplicitCaptureWithoutInput) {
+  Id window_1_1 = ws_client1()->NewWindow(1);
+
+  // Add the window to the root, so that they have a WindowTreeHostImpl to
+  // handle input capture.
+  ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_1));
+  changes1()->clear();
+
+  // Since there has been no input, capture should not succeed. No lost capture
+  // message is expected.
+  ws1()->SetCapture(1, window_1_1);
+  ws_client1_->WaitForAllMessages();
+  EXPECT_TRUE(changes1()->empty());
+
+  // Since there is no window with capture, lost capture should not be notified.
+  ws1()->ReleaseCapture(3, window_1_1);
+  ws_client1_->WaitForAllMessages();
+  EXPECT_TRUE(changes1()->empty());
+}
+
+// TODO(jonross): Enable this once apptests can send input events to the server.
+// Enabling capture requires that the connection be processing events.
+TEST_F(WindowTreeAppTest, DISABLED_ExplicitCapturePropagation) {
+  Id window_1_1 = ws_client1()->NewWindow(1);
+  Id window_1_2 = ws_client1()->NewWindow(2);
+
+  // Add the windows to the root, so that they have a WindowTreeHostImpl to
+  // handle input capture.
+  ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_1));
+  ASSERT_TRUE(ws_client1()->AddWindow(root_window_id(), window_1_2));
+
+  changes1()->clear();
+  // Window 1 takes capture then Window 2 takes capture.
+  // Verify that window 1 has lost capture.
+  ws1()->SetCapture(1, window_1_1);
+  ws1()->SetCapture(2, window_1_2);
+  ws_client1_->WaitForChangeCount(1);
+
+  EXPECT_EQ("OnLostCapture window=" + IdToString(window_1_1),
+            SingleChangeToDescription(*changes1()));
+
+  changes1()->clear();
+  // Explicitly releasing capture should not notify of lost capture.
+  ws1()->ReleaseCapture(3, window_1_2);
+  ws_client1_->WaitForAllMessages();
+
+  EXPECT_TRUE(changes1()->empty());
+}
+
 // TODO(sky): need to better track changes to initial connection. For example,
 // that SetBounsdWindows/AddWindow and the like don't result in messages to the
 // originating connection.
 
 // TODO(sky): make sure coverage of what was
 // WindowManagerTest.SecondEmbedRoot_InitService and
 // WindowManagerTest.MultipleEmbedRootsBeforeWTHReady gets added to window
 // manager
 // tests.
 
 }  // namespace ws
 }  // namespace mus