mus: Implement ScreenMus::GetCursorScreenPoint().

components/mus/ws/window_tree.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.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 651 matching lines @@
   DCHECK(window_manager_internal_);
 
   WindowManagerState* wms = display_manager()
                                 ->GetWindowManagerAndDisplay(*roots_.begin())
                                 .window_manager_state;
   CHECK(wms);
   DCHECK_EQ(this, wms->tree());
   return wms;
 }
 
+WindowManagerState* WindowTree::GetWindowManagerStateForUser() {
+  // TODO(sky): need a way for client to provide context to figure out display.

[sky, 2016/04/20 23:46:36]

This TODO isn't applicable here.

+  Display* display = display_manager()->displays().empty()
+                         ? nullptr
+                         : *(display_manager()->displays().begin());
+  // TODO(sky): move checks to accesspolicy.

[sky, 2016/04/20 23:46:36]

This TODO should be in NewTopLevelWindow, not here.

+  return display && user_id_ != InvalidUserId()
+      ? display->GetWindowManagerStateForUser(user_id_)
+      : nullptr;
+}
+
 bool WindowTree::ShouldRouteToWindowManager(const ServerWindow* window) const {
   // If the client created this window, then do not route it through the WM.
   if (window->id().connection_id == id_)
     return false;
 
   // If the client did not create the window, then it must be the root of the
   // client. If not, that means the client should not know about this window,
   // and so do not route the request to the WM.
   if (roots_.count(window) == 0)
     return false;
@@ skipping 286 matching lines @@
   client()->OnChangeCompleted(
       change_id, NewWindow(ClientWindowId(transport_window_id), properties));
 }
 
 void WindowTree::NewTopLevelWindow(
     uint32_t change_id,
     Id transport_window_id,
     mojo::Map<mojo::String, mojo::Array<uint8_t>> transport_properties) {
   DCHECK(!waiting_for_top_level_window_info_);
   const ClientWindowId client_window_id(transport_window_id);
-  // TODO(sky): need a way for client to provide context to figure out display.
-  Display* display = display_manager()->displays().empty()
-                         ? nullptr
-                         : *(display_manager()->displays().begin());
-  // TODO(sky): move checks to accesspolicy.
-  WindowManagerState* wms =
-      display && user_id_ != InvalidUserId()
-          ? display->GetWindowManagerStateForUser(user_id_)
-          : nullptr;
+  WindowManagerState* wms = GetWindowManagerStateForUser();
   if (!wms || wms->tree() == this || !IsValidIdForNewWindow(client_window_id)) {
     client()->OnChangeCompleted(change_id, false);
     return;
   }
 
   // The server creates the real window. Any further messages from the client
   // may try to alter the window. Pause incoming messages so that we know we
   // can't get a message for a window before the window is created. Once the
   // window is created we'll resume processing.
   binding_->SetIncomingMethodCallProcessingPaused(true);
@@ skipping 305 matching lines @@
     mojo::AssociatedInterfaceRequest<mojom::WindowManagerClient> internal) {
   if (!access_policy_->CanSetWindowManager() || !window_manager_internal_ ||
       window_manager_internal_client_binding_) {
     return;
   }
   window_manager_internal_client_binding_.reset(
       new mojo::AssociatedBinding<mojom::WindowManagerClient>(
           this, std::move(internal)));
 }
 
+void WindowTree::GetCursorLocationMemory(
+    const GetCursorLocationMemoryCallback& callback) {
+  WindowManagerState* wms = GetWindowManagerStateForUser();
+  callback.Run(wms->GetCursorLocationMemory());
+}
+
 void WindowTree::AddAccelerator(uint32_t id,
                                 mojom::EventMatcherPtr event_matcher,
                                 const AddAcceleratorCallback& callback) {
   WindowManagerState* wms = GetWindowManagerStateForWindowManager();
   const bool success =
       wms->event_dispatcher()->AddAccelerator(id, std::move(event_matcher));
   callback.Run(success);
 }
 
 void WindowTree::RemoveAccelerator(uint32_t id) {
@@ skipping 87 matching lines @@
 }
 
 bool WindowTree::IsWindowRootOfAnotherTreeForAccessPolicy(
     const ServerWindow* window) const {
   WindowTree* tree = window_server_->GetTreeWithRoot(window);
   return tree && tree != this;
 }
 
 }  // namespace ws
 }  // namespace mus