mus: Implement Window Server Capture

components/mus/ws/event_dispatcher.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 <set>
 
 #include "cc/surfaces/surface_hittest.h"
 #include "components/mus/surfaces/surfaces_state.h"
@@ skipping 123 matching lines @@
   mojom::EventType event_type_;
   mojom::EventFlags event_flags_;
   mojom::KeyboardCode keyboard_code_;
   mojom::PointerKind pointer_kind_;
   gfx::RectF pointer_region_;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 EventDispatcher::EventDispatcher(EventDispatcherDelegate* delegate)
-    : delegate_(delegate), root_(nullptr) {}
+    : delegate_(delegate), root_(nullptr), capture_window_(nullptr) {}
 
 EventDispatcher::~EventDispatcher() {
-  std::set<ServerWindow*> pointer_targets;
-  for (const auto& pair : pointer_targets_) {
-    if (pair.second.window &&
-        pointer_targets.insert(pair.second.window).second) {
-      pair.second.window->RemoveObserver(this);
-    }
-  }
+  CancelAllPointerEvents();
+}
+
+void EventDispatcher::SetCaptureWindow(ServerWindow* window) {
+  // Cancel all implicit captures.
+  CancelAllPointerEvents();

[sky, 2015/11/17 01:06:42]

If window is in pointer_targets_ won't this incorrectly remove it?

+  capture_window_ = window;
+  // Track the lifetime of the window with explicit capture.
+  if (window)
+    window->AddObserver(this);
 }
 
 void EventDispatcher::AddAccelerator(uint32_t id,
                                      mojom::EventMatcherPtr event_matcher) {
   EventMatcher matcher(*event_matcher);
 #if !defined(NDEBUG)
   for (const auto& pair : accelerators_) {
     DCHECK_NE(pair.first, id);
     DCHECK(!matcher.Equals(pair.second));
   }
@@ skipping 34 matching lines @@
 }
 
 void EventDispatcher::ProcessKeyEvent(mojom::EventPtr event) {
   ServerWindow* focused_window =
       delegate_->GetFocusedWindowForEventDispatcher();
   if (focused_window)
     delegate_->DispatchInputEventToWindow(focused_window, false, event.Pass());
 }
 
 void EventDispatcher::ProcessPointerEvent(mojom::EventPtr event) {
+  if (capture_window_) {
+    PointerTarget pointer_target;
+    pointer_target.window = capture_window_;
+    DispatchToPointerTarget(pointer_target, event.Pass());
+    return;
+  }
+
   const int32_t pointer_id = event->pointer_data->pointer_id;
   if (event->action == mojom::EVENT_TYPE_WHEEL ||
       (event->action == mojom::EVENT_TYPE_POINTER_MOVE &&
        pointer_targets_.count(pointer_id) == 0)) {
     PointerTarget pointer_target;
     if (pointer_targets_.count(pointer_id) != 0) {
       pointer_target = pointer_targets_[pointer_id];
     } else {
       gfx::Point location(EventLocationToPoint(*event));
       pointer_target.window =
@@ skipping 47 matching lines @@
 
   gfx::Point location(EventLocationToPoint(*event));
   gfx::Transform transform(GetTransformToWindow(surface_id_, target.window));
   transform.TransformPoint(&location);
   event->pointer_data->location->x = location.x();
   event->pointer_data->location->y = location.y();
   delegate_->DispatchInputEventToWindow(target.window, target.in_nonclient_area,
                                         event.Pass());
 }
 
+void EventDispatcher::CancelAllPointerEvents() {
+  if (capture_window_) {

[sky, 2015/11/17 01:06:42]

Based on the name I wouldn't expect this to reset capture_window_ too.

+    capture_window_->RemoveObserver(this);
+    capture_window_ = nullptr;
+  }
+  std::set<ServerWindow*> pointer_targets;

[sky, 2015/11/17 01:06:42]

The windows should see a cancel when this happens.

+  for (const auto& pair : pointer_targets_) {
+    if (pair.second.window &&
+        pointer_targets.insert(pair.second.window).second) {
+      pair.second.window->RemoveObserver(this);
+    }
+  }
+  pointer_targets_.clear();
+}
+
 void EventDispatcher::CancelPointerEventsToTarget(ServerWindow* window) {
   window->RemoveObserver(this);
+  if (capture_window_ == window) {
+    capture_window_ = nullptr;
+    // A window only cares to be informed that it lost capture if it explicitly
+    // requested capture. A window can lose capture if another window gains
+    // explicit capture.
+    delegate_->OnLostCapture(window);
+    return;
+  }
 
   for (auto& pair : pointer_targets_) {
     if (pair.second.window == window)
       pair.second.window = nullptr;
   }
 }
 
 bool EventDispatcher::IsObservingWindow(ServerWindow* window) {
   for (const auto& pair : pointer_targets_) {
     if (pair.second.window == window)
@@ skipping 23 matching lines @@
 void EventDispatcher::OnWindowVisibilityChanged(ServerWindow* window) {
   CancelPointerEventsToTarget(window);
 }
 
 void EventDispatcher::OnWindowDestroyed(ServerWindow* window) {
   CancelPointerEventsToTarget(window);
 }
 
 }  // namespace ws
 }  // namespace mus