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 "base/time/time.h"
 #include "cc/surfaces/surface_hittest.h"
 #include "components/mus/surfaces/surfaces_state.h"
 #include "components/mus/ws/event_dispatcher_delegate.h"
 #include "components/mus/ws/server_window.h"
 #include "components/mus/ws/server_window_delegate.h"
 #include "components/mus/ws/window_coordinate_conversions.h"
 #include "components/mus/ws/window_finder.h"
 #include "components/mus/ws/window_tree_host_impl.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "ui/gfx/geometry/point.h"
@@ skipping 131 matching lines @@
   mojom::KeyboardCode keyboard_code_;
   mojom::PointerKind pointer_kind_;
   gfx::RectF pointer_region_;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 EventDispatcher::EventDispatcher(EventDispatcherDelegate* delegate)
     : delegate_(delegate),
       root_(nullptr),
+      capture_window_(nullptr),
+      capture_window_in_nonclient_area_(false),
       mouse_button_down_(false),
       mouse_cursor_source_window_(nullptr) {}
 
 EventDispatcher::~EventDispatcher() {
   std::set<ServerWindow*> pointer_targets;
+  if (capture_window_) {
+    pointer_targets.insert(capture_window_);
+    capture_window_->RemoveObserver(this);
+    capture_window_ = nullptr;
+  }
   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::SetCaptureWindow(ServerWindow* window,
+                                       bool in_nonclient_area) {
+  if (window == capture_window_)
+    return;
+
+  if (capture_window_) {
+    // Stop observing old capture window. |pointer_targets_| are cleared on
+    // intial setting of a capture window.
+    delegate_->OnLostCapture(capture_window_);
+    capture_window_->RemoveObserver(this);
+  } else {
+    // Cancel implicit capture to all other windows.
+    std::set<ServerWindow*> unobserved_windows;
+    for (const auto& pair : pointer_targets_) {
+      ServerWindow* target = pair.second.window;
+      if (!target)
+        continue;
+      if (unobserved_windows.insert(target).second)
+        target->RemoveObserver(this);
+      if (target == window)
+        continue;
+      mojom::EventPtr cancel_event = mojom::Event::New();
+      cancel_event->action = mojom::EventType::POINTER_CANCEL;
+      cancel_event->flags = mojom::kEventFlagNone;
+      cancel_event->time_stamp = base::TimeTicks::Now().ToInternalValue();
+      cancel_event->pointer_data = mojom::PointerData::New();
+      // TODO(jonross): Track previous location in PointerTarget for sending
+      // cancels
+      cancel_event->pointer_data->location = mojom::LocationData::New();
+      cancel_event->pointer_data->pointer_id = pair.first;
+      DispatchToPointerTarget(pair.second, std::move(cancel_event));
+    }
+    pointer_targets_.clear();
+  }
+  capture_window_ = window;
+  capture_window_in_nonclient_area_ = in_nonclient_area;
+  // Begin tracking the capture window if it is not yet being observed.
+  if (window)
+    window->AddObserver(this);
 }
 
 void EventDispatcher::UpdateCursorProviderByLastKnownLocation() {
   if (!mouse_button_down_) {
     gfx::Point location = mouse_pointer_last_location_;
     mouse_cursor_source_window_ =
         FindDeepestVisibleWindowForEvents(root_, surface_id_, &location);
   }
 }
 
@@ skipping 49 matching lines @@
                                           std::move(event));
 }
 
 void EventDispatcher::ProcessPointerEvent(mojom::EventPtr event) {
   const bool is_mouse_event = event->pointer_data &&
                         event->pointer_data->kind == mojom::PointerKind::MOUSE;
 
   if (is_mouse_event)
     mouse_pointer_last_location_ = EventLocationToPoint(*event);
 
+  if (capture_window_) {
+    PointerTarget pointer_target;
+    pointer_target.window = capture_window_;
+    pointer_target.in_nonclient_area = capture_window_in_nonclient_area_;
+    mouse_button_down_ = event->action == mojom::EventType::POINTER_DOWN;

[sky, 2016/02/01 20:43:33]

This isn't right. For setting to true you want to duplicate the logic around
311, and for setting to false duplicate the logic around 321-334.

[jonross, 2016/02/03 18:52:17]

Yeah I was mistaken here. Done.

+    mouse_cursor_source_window_ = capture_window_;
+    DispatchToPointerTarget(pointer_target, std::move(event));
+    return;
+  }
+
   const int32_t pointer_id = event->pointer_data->pointer_id;
   if (!IsTrackingPointer(pointer_id) ||
       !pointer_targets_[pointer_id].is_pointer_down) {
     const bool any_pointers_down = AreAnyPointersDown();
     UpdateTargetForPointer(*event);
     if (is_mouse_event)
       mouse_cursor_source_window_ = pointer_targets_[pointer_id].window;
 
     PointerTarget& pointer_target = pointer_targets_[pointer_id];
     if (pointer_target.is_pointer_down) {
@@ skipping 14 matching lines @@
       (event->pointer_data->kind != mojom::PointerKind::MOUSE ||
        IsOnlyOneMouseButtonDown(event->flags));
 
   if (is_pointer_going_up && is_mouse_event) {
     // When we release the mouse button, we want the cursor to be sourced from
     // the window under the mouse pointer, even though we're sending the button
     // up event to the window that had implicit capture. We have to set this
     // before we perform dispatch because the Delegate is going to read this
     // information from us.
     mouse_button_down_ = false;
-    gfx::Point location(EventLocationToPoint(*event));
-    mouse_cursor_source_window_ =
-        FindDeepestVisibleWindowForEvents(root_, surface_id_, &location);
+    UpdateCursorProviderByLastKnownLocation();
   }
 
   DispatchToPointerTarget(pointer_targets_[pointer_id], std::move(event));
 
   if (is_pointer_going_up) {
     if (is_mouse_event)
       pointer_targets_[pointer_id].is_pointer_down = false;
     else
       StopTrackingPointer(pointer_id);
   }
@@ skipping 86 matching lines @@
   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,
                                         std::move(event));
 }
 
 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);
+    mouse_button_down_ = false;
+    UpdateCursorProviderByLastKnownLocation();
+    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)
       return true;
@@ skipping 25 matching lines @@
 
 void EventDispatcher::OnWindowDestroyed(ServerWindow* window) {
   CancelPointerEventsToTarget(window);
 
   if (mouse_cursor_source_window_ == window)
     mouse_cursor_source_window_ = nullptr;
 }
 
 }  // namespace ws
 }  // namespace mus