mus: Implement ScreenMus::GetCursorScreenPoint().

components/mus/public/cpp/lib/window_tree_client_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/public/cpp/lib/window_tree_client_impl.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 113 matching lines @@
     : connection_id_(0),
       next_window_id_(1),
       next_change_id_(1),
       delegate_(delegate),
       window_manager_delegate_(window_manager_delegate),
       capture_window_(nullptr),
       focused_window_(nullptr),
       binding_(this),
       tree_(nullptr),
       delete_on_no_roots_(true),
-      in_destructor_(false) {
+      in_destructor_(false),
+      cursor_location_memory_(nullptr),
+      weak_factory_(this) {
   // Allow for a null request in tests.
   if (request.is_pending())
     binding_.Bind(std::move(request));
   if (window_manager_delegate)
     window_manager_delegate->SetWindowManagerClient(this);
 }
 
 WindowTreeClientImpl::~WindowTreeClientImpl() {
   in_destructor_ = true;
 
@@ skipping 25 matching lines @@
   delete_on_no_roots_ = false;
 
   // The connection id doesn't really matter, we use 101 purely for debugging.
   connection_id_ = 101;
 
   mojom::WindowTreeFactoryPtr factory;
   connector->ConnectToInterface("mojo:mus", &factory);
   factory->CreateWindowTree(GetProxy(&tree_ptr_),
                             binding_.CreateInterfacePtrAndBind());
   tree_ = tree_ptr_.get();
+
+  tree_ptr_->GetCursorLocationMemory(
+      base::Bind(&WindowTreeClientImpl::OnReceivedCursorLocationMemory,
+                 weak_factory_.GetWeakPtr()));
 }
 
 void WindowTreeClientImpl::WaitForEmbed() {
   DCHECK(roots_.empty());
   // OnEmbed() is the first function called.
   binding_.WaitForIncomingMethodCall();
   // TODO(sky): deal with pipe being closed before we get OnEmbed().
 }
 
 void WindowTreeClientImpl::DestroyWindow(Window* window) {
@@ skipping 332 matching lines @@
   WindowPrivate(root).LocalSetParentDrawn(drawn);
 
   delegate_->OnEmbed(root);
 
   if (focused_window_) {
     FOR_EACH_OBSERVER(WindowTreeConnectionObserver, observers_,
                       OnWindowTreeFocusChanged(focused_window_, nullptr));
   }
 }
 
+void WindowTreeClientImpl::OnReceivedCursorLocationMemory(
+    mojo::ScopedSharedBufferHandle handle) {
+  cursor_location_handle_ = std::move(handle);
+  MojoResult result = mojo::MapBuffer(
+      cursor_location_handle_.get(), 0,
+      sizeof(base::subtle::Atomic32),
+      reinterpret_cast<void**>(&cursor_location_memory_),
+      MOJO_MAP_BUFFER_FLAG_NONE);
+  if (result != MOJO_RESULT_OK) {
+    NOTREACHED();
+    return;
+  }
+  DCHECK(cursor_location_memory_);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // WindowTreeClientImpl, WindowTreeConnection implementation:
 
 void WindowTreeClientImpl::SetDeleteOnNoRoots(bool value) {
   delete_on_no_roots_ = value;
 }
 
 const std::set<Window*>& WindowTreeClientImpl::GetRoots() {
   return roots_;
 }
 
 Window* WindowTreeClientImpl::GetFocusedWindow() {
   return focused_window_;
 }
 
 void WindowTreeClientImpl::ClearFocus() {
   if (!focused_window_)
     return;
 
   SetFocus(nullptr);
 }
 
+gfx::Point WindowTreeClientImpl::GetCursorScreenPoint() {
+  // We raced initialization. Return (0, 0).
+  if (!cursor_location_memory_)
+    return gfx::Point();
+
+  base::subtle::Atomic32 location =
+      base::subtle::NoBarrier_Load(cursor_location_memory_);
+  return gfx::Point(location >> 16,

[sky, 2016/04/27 23:55:57]

Is the sign bit preserved here? I would expect you need the static_cast as you
have on the next line, but I readily admit I'm not sure.

[Elliot Glaysher, 2016/04/28 00:14:01]

I manually tested this and the sign bit is preserved. Added cast anyway for
clarity.

+                    static_cast<int16_t>(location & 0xFFFF));
+}
+
 Window* WindowTreeClientImpl::NewWindow(
     const Window::SharedProperties* properties) {
   return NewWindowImpl(NewWindowType::CHILD, properties);
 }
 
 Window* WindowTreeClientImpl::NewTopLevelWindow(
     const Window::SharedProperties* properties) {
   Window* window = NewWindowImpl(NewWindowType::TOP_LEVEL, properties);
   // Assume newly created top level windows are drawn by default, otherwise
   // requests to focus will fail. We will get the real value in
@@ skipping 477 matching lines @@
 
 void WindowTreeClientImpl::SetUnderlaySurfaceOffsetAndExtendedHitArea(
     Window* window,
     const gfx::Vector2d& offset,
     const gfx::Insets& hit_area) {
   window_manager_internal_client_->SetUnderlaySurfaceOffsetAndExtendedHitArea(
       server_id(window), offset.x(), offset.y(), mojo::Insets::From(hit_area));
 }
 
 }  // namespace mus