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 138 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),
       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) {

[sky, 2016/01/22 00:55:00]

You need to also pass in in_nonclient_area. I think that should be determined
based on who is making the request.

[jonross, 2016/01/22 20:31:28]

I'm not sure if that is needed. There will not always be a direct connection
between an input event and a request to SetCaptureWindow.

Eg. A window launches which desires capture, like a menu.

[sky, 2016/01/22 22:15:37]

For windows with no one embedded in them there is only one client that gets
event. OTOH windows with another client embedded in them have two clients that
may get the event. The owner and the embedded client. If the owner does the
SetCapture, it should get the events. If the embedded app does the capture, it
should get the events. in_nonclient_frame is used to distinguish these two
cases. in_nonclient_frame means the owner gets the event, otherwise it goes to
the embedded app. It's probably worth renaming the value to make this clearer.
Make sense?

[jonross, 2016/01/26 18:38:50]

That makes sense. I'm passing this in now based on which WindowTreeImpl is
performing the call, the owner, or the embedded app.

A rename may be a good idea. My initial interpretation was skewed by 
IsLocationInNonclientArea which tied the concept to a click location. I had not
realized that this mapped to different WindowTreeImpl in 
WindowTreeHostImpl::DispatchInputEventToWindowImpl.

WindowTreeHostImpl::OnFocusChanged also uses the owning vs embedded
nomenclature, so maybe a term such as "in_owning_client"

+  if (window == capture_window_)
+    return;
+
+  // Cancel implicit capture to all other windows.
+  PointerIdToTargetMap window_implicit_targets;
+  std::set<ServerWindow*> unobserved_windows;

[jonross, 2016/01/21 22:01:12]

There was a comment in the previous review:

"The windows should see a cancel when this happens."

I was not sure if that was related to OnLostCapture, which is on line 187 now,
or some other notification.

I didn't see any notification in the other areas where window tracking stops.

[jonross, 2016/01/26 18:38:50]

Done.

+  if (capture_window_) {
+    delegate_->OnLostCapture(capture_window_);
+    unobserved_windows.insert(capture_window_);
+    capture_window_->RemoveObserver(this);
+  }
+
+  for (const auto& pair : pointer_targets_) {
+    ServerWindow* target = pair.second.window;
+    if (!target)
+      continue;
+    if (target == window)
+      window_implicit_targets[pair.first] = pair.second;

[sky, 2016/01/22 00:55:00]

Why do you need to maintain pointer_targets_ when there is a capture window?
Seems like we should just empty it out.

[jonross, 2016/01/22 20:31:28]

This was based on a comment in the original review querying the removal of all
pointer targets. However I would agree that it isn't necessary while we have a
capture window. I'll switch this to clearing out the pointer_targets_

[jonross, 2016/01/26 18:38:50]

Done.

+    else if (unobserved_windows.insert(target).second)
+      target->RemoveObserver(this);

[sky, 2016/01/22 00:55:00]

You should send POINTER_CANCEL here.

[jonross, 2016/01/26 18:38:50]

Done.

+  }
+  pointer_targets_.swap(window_implicit_targets);
+
+  capture_window_ = window;
+  // Begin tracking the capture window if it is not yet being observed.
+  if (window && pointer_targets_.empty())
+    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 43 matching lines @@
 
 void EventDispatcher::ProcessKeyEvent(mojom::EventPtr event) {
   ServerWindow* focused_window =
       delegate_->GetFocusedWindowForEventDispatcher();
   if (focused_window)
     delegate_->DispatchInputEventToWindow(focused_window, false,
                                           std::move(event));
 }
 
 void EventDispatcher::ProcessPointerEvent(mojom::EventPtr event) {
+  if (capture_window_) {
+    PointerTarget pointer_target;
+    pointer_target.window = capture_window_;
+    DispatchToPointerTarget(pointer_target, std::move(event));
+    return;
+  }
+
   const bool is_mouse_event =
       event->pointer_data &&
       event->pointer_data->kind == mojom::PointerKind::POINTER_KIND_MOUSE;
 
   if (is_mouse_event)
     mouse_pointer_last_location_ = EventLocationToPoint(*event);
 
   const int32_t pointer_id = event->pointer_data->pointer_id;
   if (!IsTrackingPointer(pointer_id) ||
       !pointer_targets_[pointer_id].is_pointer_down) {
@@ skipping 130 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);
+    return;

[sky, 2016/01/22 00:55:00]

Why the early out here? Don't we still need to reset pointer_targets_?

[jonross, 2016/01/26 18:38:50]

With the change to always clear pointer_targets_ in SetCaptureWindow there will
no longer be any to clear here. So the early exit is now correct. However
there's no harm removing it if desired.

+  }
+
   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