mus: Implement Window Server Capture

components/mus/ws/window_tree_impl.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 "components/mus/ws/window_tree_impl.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 532 matching lines @@
   if (!host || !host->GetWindowTree() ||
       !host->GetWindowTree()->window_manager_internal_) {
     return false;
   }
 
   // Requests coming from the WM should not be routed through the WM again.
   const bool is_wm = host->GetWindowTree() == this;
   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;
 }
 
 bool WindowTreeImpl::IsValidIdForNewWindow(const WindowId& id) const {
   return id.connection_id == id_ && embed_to_real_id_map_.count(id) == 0 &&
          window_map_.count(id.window_id) == 0;
 }
 
 bool WindowTreeImpl::CanReorderWindow(const ServerWindow* window,
@@ skipping 340 matching lines @@
 }
 
 void WindowTreeImpl::GetWindowTree(
     Id window_id,
     const Callback<void(Array<mojom::WindowDataPtr>)>& callback) {
   std::vector<const ServerWindow*> windows(
       GetWindowTree(MapWindowIdFromClient(window_id)));
   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) {
   ServerWindow* window = GetWindow(MapWindowIdFromClient(window_id));
   if (window && ShouldRouteToWindowManager(window)) {
     const uint32_t wm_change_id =
         connection_manager_->GenerateWindowManagerChangeId(this, change_id);
     // |window_id| may be a client id, use the id from the window to ensure
     // the windowmanager doesn't get an id it doesn't know about.
     GetHost(window)->GetWindowTree()->window_manager_internal_->WmSetBounds(
@@ skipping 235 matching lines @@
 
   for (const auto* root : roots_) {
     if (root->Contains(window))
       return true;
   }
   return false;
 }
 
 }  // namespace ws
 }  // namespace mus