mus: Implement Window Server Capture

components/mus/ws/window_tree_impl.cc

Index: components/mus/ws/window_tree_impl.cc
diff --git a/components/mus/ws/window_tree_impl.cc b/components/mus/ws/window_tree_impl.cc
index 121c7ced2d32c3ad994ce76c4eb72483e054b8d9..afdde850b09c33bcbc19880b24da56cca5e8f5da 100644
--- a/components/mus/ws/window_tree_impl.cc
+++ b/components/mus/ws/window_tree_impl.cc
@@ -550,6 +550,11 @@ bool WindowTreeImpl::ShouldRouteToWindowManager(
   return is_wm ? false : true;
 }
 
+void WindowTreeImpl::ProcessLostCapture(
+    const ServerWindow* old_capture_window) {
+  client()->OnLostCapture(WindowIdToTransportId(old_capture_window->id()));

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

You should only send this if it was not initiated by this client. By that I mean
if the client called ReleaseCapture() then don't send OnLostCapture.

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

Done.

+}
+
 bool WindowTreeImpl::IsWindowKnown(const ServerWindow* window) const {
   return known_windows_.count(WindowIdToTransportId(window->id())) > 0;
 }
@@ -910,6 +915,30 @@ void WindowTreeImpl::GetWindowTree(
   callback.Run(WindowsToWindowDatas(windows));
 }
 
+void WindowTreeImpl::SetCapture(uint32_t change_id, Id window_id) {
+  ServerWindow* window = GetWindow(WindowIdFromTransportId(window_id));
+  WindowTreeHostImpl* host = GetHost(window);
+  bool success = window && access_policy_->CanSetCapture(window) && host &&
+                 access_policy_->CanSetCapture(host->GetCaptureWindow());

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

I am worried about letting any application capture mouse events at any time.
Seems like an easy way for an app to steal events.

The places I'm aware of requesting capture are in processing a mouse or key
event. Are there other places? If so, can we only allow the capture if the
client is processing an event or already has capture?

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

I would also believe that touch events would also want to be captured.

Eg. a window which wishes to dismiss itself when a touch occurs outside of its
bounds.

I would expect valid reasons for wanting capture:
  - Already processing an event, and want to see subsequent events which exit
the region of the client
  - A pseudo-modal dialog which wishes to dismiss itself when an event occurs
outside of its bounds. I'd expect this to request capture at creation time.

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

Agreed.
Agreed.
Generally we key off activation to dismiss on blur. Is there a place in chrome
code where we setcapture as you're saying?

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

Yes: MenuController::Run eventually triggers
     MenuHost::ShowMenuHost which calls
     native_widget_private()->SetCapture()

The launch of the menu window is triggered off of an input, but the application
of capture is on a window which has not yet shown nor processed any input.

[sky, 2016/01/26 22:11:14]

While the windows are different, it's the same client right? So that if you
restrict this api to only happen when the client is processing an event it
should work. Is that right?

[jonross, 2016/01/26 22:35:15]

It should always be the same client which has processed an event.

Though it might be possible for the event to have cleared before a request to
setcapture arrives.

Server
   - mouse press
   - mouse release
          - clears client from implicit capture
   - setcapture

Client
   - mouse press
         - call setcapture
   - mouse release

However the client itself should still have an event queue in that case. I'll
add that restriction to WindowTreeImpl

[jonross, 2016/01/27 21:15:13]

sadrul@ did raise a concern that we could have situations like this with context
menus. However he felt that could be updated in the future.

mus -> event -> browser -> renderer
    <- ack   <- 
                        <- renderer
    <-capture<-

Also would be avoided entirely once mus <-> renderer is possible

+  if (success) {
+    Operation op(this, connection_manager_, OperationType::SET_CAPTURE);
+    host->SetCapture(window);
+  }
+  client_->OnChangeCompleted(change_id, success);
+}
+
+void WindowTreeImpl::ReleaseCapture(uint32_t change_id, Id window_id) {
+  ServerWindow* window = GetWindow(WindowIdFromTransportId(window_id));
+  WindowTreeHostImpl* host = GetHost(window);
+  bool success =
+      window && host && access_policy_->CanSetCapture(host->GetCaptureWindow());
+  if (success) {
+    Operation op(this, connection_manager_, OperationType::RELEASE_CAPTURE);
+    host->SetCapture(nullptr);

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

They way you have this now is set capture to null no matter what. I think this
should be set capture to null only if the window already has capture.

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

Done.

+  }
+  client_->OnChangeCompleted(change_id, success);
+}
+
 void WindowTreeImpl::SetWindowBounds(uint32_t change_id,
                                      Id window_id,
                                      mojo::RectPtr bounds) {