mus Window Server: implement event capture

components/mus/ws/window_tree_unittest.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 <stdint.h>
 
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
@@ skipping 115 matching lines @@
                mus::mojom::WindowTreePtr tree,
                Id focused_window_id,
                uint32_t access_policy) override {
     // TODO(sky): add test coverage of |focused_window_id|.
     tracker_.OnEmbed(connection_id, std::move(root));
   }
   void OnEmbeddedAppDisconnected(uint32_t window) override {
     tracker_.OnEmbeddedAppDisconnected(window);
   }
   void OnUnembed(Id window_id) override { tracker_.OnUnembed(window_id); }
+  void OnLostCapture(Id window_id) override {}
   void OnTopLevelCreated(uint32_t change_id,
                          mojom::WindowDataPtr data) override {
     tracker_.OnTopLevelCreated(change_id, std::move(data));
   }
   void OnWindowBoundsChanged(uint32_t window,
                              mojo::RectPtr old_bounds,
                              mojo::RectPtr new_bounds) override {
     tracker_.OnWindowBoundsChanged(window, std::move(old_bounds),
                                    std::move(new_bounds));
   }
@@ skipping 170 matching lines @@
     // root-window is created).
     mojom::ViewportMetrics metrics;
     metrics.size_in_pixels = mojo::Size::From(gfx::Size(400, 300));
     metrics.device_pixel_ratio = 1.f;
     delegate->OnViewportMetricsChanged(mojom::ViewportMetrics(), metrics);
   }
   void SchedulePaint(const ServerWindow* window,
                      const gfx::Rect& bounds) override {}
   void SetViewportSize(const gfx::Size& size) override {}
   void SetTitle(const base::string16& title) override {}
+  void SetCapture() override {}
+  void ReleaseCapture() override {}
   void SetCursorById(int32_t cursor) override { *cursor_id_storage_ = cursor; }
   mojom::Rotation GetRotation() override { return mojom::Rotation::VALUE_0; }
   const mojom::ViewportMetrics& GetViewportMetrics() override {
     return display_metrices_;
   }
   void UpdateTextInputState(const ui::TextInputState& state) override {}
   void SetImeVisibility(bool visible) override {}
   bool IsFramePending() const override { return false; }
   void RequestCopyOfOutput(
       scoped_ptr<cc::CopyOutputRequest> output_request) override {}
@@ skipping 555 matching lines @@
                     WindowIdFromTransportId(embed_window_id2_in_child.id)) +
                 " visible=true",
             SingleChangeToDescription(*embed_connection->tracker()->changes()));
 
   // Set the visibility from the child using the client assigned id.
   ASSERT_TRUE(window_tree_connection->SetWindowVisibility(
       embed_window_id2_in_child, false));
   EXPECT_FALSE(embed_window->visible());
 }
 
+// Tests that setting capture only works while an input event is being
+// processed, and the only the capture window can release capture.
+TEST_F(WindowTreeTest, ExplicitSetCapture) {
+  TestWindowTreeClient* embed_connection = nullptr;
+  WindowTreeImpl* window_tree_connection = nullptr;
+  ServerWindow* window = nullptr;
+  EXPECT_NO_FATAL_FAILURE(
+      SetupEventTargeting(&embed_connection, &window_tree_connection, &window));
+  const ServerWindow* root_window = *window_tree_connection->roots().begin();
+  window_tree_connection->AddWindow(
+      FirstRootId(window_tree_connection),
+      ClientWindowIdForWindow(window_tree_connection, window));
+  window->SetBounds(gfx::Rect(0, 0, 100, 100));
+  ASSERT_TRUE(window_tree_connection->GetHost(window));
+
+  // Setting capture should fail when there are no active events
+  mojom::WindowTree* mojom_window_tree =
+      static_cast<mojom::WindowTree*>(window_tree_connection);
+  uint32_t change_id = 42;
+  mojom_window_tree->SetCapture(change_id, WindowIdToTransportId(window->id()));
+  WindowTreeHostImpl* host = window_tree_connection->GetHost(window);
+  EXPECT_NE(window, host->GetCaptureWindow());
+
+  // Setting capture after the event is acknowledged should fail
+  DispatchEventAndAckImmediately(CreatePointerDownEvent(10, 10));
+  mojom_window_tree->SetCapture(++change_id,
+                                WindowIdToTransportId(window->id()));
+  EXPECT_NE(window, host->GetCaptureWindow());
+
+  // Settings while the event is being process should pass
+  DispatchEventWithoutAck(CreatePointerDownEvent(10, 10));
+  mojom_window_tree->SetCapture(++change_id,
+                                WindowIdToTransportId(window->id()));
+  EXPECT_EQ(window, host->GetCaptureWindow());
+  AckPreviousEvent();
+
+  // Only the capture window should be able to release capture
+  mojom_window_tree->ReleaseCapture(++change_id,
+                                    WindowIdToTransportId(root_window->id()));
+  EXPECT_EQ(window, host->GetCaptureWindow());
+  mojom_window_tree->ReleaseCapture(++change_id,
+                                    WindowIdToTransportId(window->id()));
+  EXPECT_EQ(nullptr, host->GetCaptureWindow());
+}
+
 }  // namespace ws
 }  // namespace mus