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 572 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,
+                                        bool originated_change) {
+  if ((originated_change &&
+       connection_manager_->current_operation_type() ==
+           OperationType::RELEASE_CAPTURE) ||
+      !IsWindowKnown(old_capture_window)) {
+    return;
+  }
+  client()->OnLostCapture(WindowIdToTransportId(old_capture_window->id()));
+}
+
 ClientWindowId WindowTreeImpl::ClientWindowIdForWindow(
     const ServerWindow* window) const {
   auto iter = window_id_to_client_id_map_.find(window->id());
   DCHECK(iter != window_id_to_client_id_map_.end());
   return iter->second;
 }
 
 bool WindowTreeImpl::IsValidIdForNewWindow(const ClientWindowId& id) const {
   if (is_embed_root_ && WindowIdFromTransportId(id.id).connection_id != id_) {
     // Embed roots see windows created from other connections. If they don't
@@ skipping 368 matching lines @@
 }
 
 void WindowTreeImpl::GetWindowTree(
     Id window_id,
     const Callback<void(Array<mojom::WindowDataPtr>)>& callback) {
   std::vector<const ServerWindow*> windows(
       GetWindowTree(ClientWindowId(window_id)));
   callback.Run(WindowsToWindowDatas(windows));
 }
 
+void WindowTreeImpl::SetCapture(uint32_t change_id, Id window_id) {
+  ServerWindow* window = GetWindow(WindowIdFromTransportId(window_id));

[sky, 2016/01/29 20:47:00]

Sorry, I've changed things around. You want:

window = GetWindowByClientId(ClientWindowId(window_id));

[jonross, 2016/02/01 18:52:22]

Done.

+  WindowTreeHostImpl* host = GetHost(window);
+  ServerWindow* current_capture_window =
+      host ? host->GetCaptureWindow() : nullptr;
+  bool success = window && access_policy_->CanSetCapture(window) && host &&
+                 (!current_capture_window ||
+                  access_policy_->CanSetCapture(current_capture_window)) &&

[sky, 2016/01/29 20:47:00]

Can the condition in () ever hit? Why do we need it?

[jonross, 2016/02/01 18:52:22]

Yes this can be hit.

When a window tree has been created, and all capture is currently implicit
within EventDispatcher. This leads to the |current_capture_window| being null.

On subsequent runs the second portion should always be true, unless an access
policy can change at runtime.

+                 event_ack_id_;
+  if (success) {
+    Operation op(this, connection_manager_, OperationType::SET_CAPTURE);
+    host->SetCapture(window, !HasRoot(window));
+  }
+  client_->OnChangeCompleted(change_id, success);
+}
+
+void WindowTreeImpl::ReleaseCapture(uint32_t change_id, Id window_id) {
+  ServerWindow* window = GetWindow(WindowIdFromTransportId(window_id));

[sky, 2016/01/29 20:47:00]

Same comment about ids.

[jonross, 2016/02/01 18:52:22]

Done.

+  WindowTreeHostImpl* host = GetHost(window);
+  ServerWindow* capture_window = host ? host->GetCaptureWindow() : nullptr;
+  bool success = window && host &&
+                 access_policy_->CanSetCapture(capture_window) &&
+                 window == capture_window;
+  if (success) {
+    Operation op(this, connection_manager_, OperationType::RELEASE_CAPTURE);
+    host->SetCapture(nullptr, false);
+  }
+  client_->OnChangeCompleted(change_id, success);
+}
+
 void WindowTreeImpl::SetWindowBounds(uint32_t change_id,
                                      Id window_id,
                                      mojo::RectPtr bounds) {
   ServerWindow* window = GetWindowByClientId(ClientWindowId(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.
     WindowTreeImpl* wm_window_tree = GetHost(window)->GetWindowTree();
@@ skipping 86 matching lines @@
       host->SetImeVisibility(window, visible);
   }
 }
 
 void WindowTreeImpl::OnWindowInputEventAck(uint32_t event_id) {
   if (event_ack_id_ == 0 || event_id != event_ack_id_) {
     // TODO(sad): Something bad happened. Kill the client?
     NOTIMPLEMENTED() << "Wrong event acked.";
   }
   event_ack_id_ = 0;
-
   WindowTreeHostImpl* event_source_host = event_source_host_;
   event_source_host_ = nullptr;
   if (event_source_host)
     event_source_host->OnEventAck(this);
 
   if (!event_queue_.empty()) {
     DCHECK(!event_ack_id_);
     ServerWindow* target = nullptr;
     mojom::EventPtr event;
     do {
@@ skipping 151 matching lines @@
 
   for (const auto* root : roots_) {
     if (root->Contains(window))
       return true;
   }
   return false;
 }
 
 }  // namespace ws
 }  // namespace mus