mus: Implement ScreenMus::GetCursorScreenPoint().

components/mus/ws/window_manager_state.cc

 // Copyright 2016 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_manager_state.h"
 
 #include "base/memory/weak_ptr.h"
 #include "components/mus/ws/accelerator.h"
 #include "components/mus/ws/display_manager.h"
 #include "components/mus/ws/platform_display.h"
@@ skipping 147 matching lines @@
   if (tree_awaiting_input_ack_ != tree)
     return;
   // The WindowTree is dying. So it's not going to ack the event.
   // If the dying tree matches the root |tree_| marked as handled so we don't
   // notify it of accelerators.
   OnEventAck(tree_awaiting_input_ack_, tree == tree_
                                            ? mojom::EventResult::HANDLED
                                            : mojom::EventResult::UNHANDLED);
 }
 
+mojo::ScopedSharedBufferHandle WindowManagerState::GetCursorLocationMemory() {

[sky, 2016/04/27 20:10:28]

If you put this code here, it means we're only get the coordinates of one
display. I think the right place for this is UserDisplayManager, which you can
get by way of:

window_server()->display_manager()->GetUserDisplayManager(user_id_);

+  if (!cursor_location_memory_) {
+    // Create our shared memory segment to share the cursor state with our
+    // window clients.
+    MojoResult result = mojo::CreateSharedBuffer(nullptr,
+                                                 sizeof(base::subtle::Atomic32),
+                                                 &cursor_location_handle_);
+    if (result != MOJO_RESULT_OK)
+      return mojo::ScopedSharedBufferHandle();
+    DCHECK(cursor_location_handle_.is_valid());
+
+    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)
+      return mojo::ScopedSharedBufferHandle();
+    DCHECK(cursor_location_memory_);
+
+    base::subtle::NoBarrier_Store(cursor_location_memory_,
+                                  current_cursor_location_);
+  }
+
+  mojo::ScopedSharedBufferHandle duped;
+  MojoDuplicateBufferHandleOptions options = {
+    sizeof(MojoDuplicateBufferHandleOptions),
+    MOJO_DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_READ_ONLY
+  };
+  MojoResult result = mojo::DuplicateBuffer(cursor_location_handle_.get(),
+                                            &options, &duped);
+  if (result != MOJO_RESULT_OK)
+    return mojo::ScopedSharedBufferHandle();
+  DCHECK(duped.is_valid());
+
+  return duped;
+}
+
 WindowManagerState::WindowManagerState(Display* display,
                                        PlatformDisplay* platform_display,
                                        cc::SurfaceId surface_id,
                                        bool is_user_id_valid,
                                        const UserId& user_id)
     : display_(display),
       platform_display_(platform_display),
       is_user_id_valid_(is_user_id_valid),
       user_id_(user_id),
-      event_dispatcher_(this) {
+      event_dispatcher_(this),
+      current_cursor_location_(0),
+      cursor_location_memory_(nullptr) {
   frame_decoration_values_ = mojom::FrameDecorationValues::New();
   frame_decoration_values_->normal_client_area_insets = mojo::Insets::New();
   frame_decoration_values_->maximized_client_area_insets = mojo::Insets::New();
   frame_decoration_values_->max_title_bar_button_width = 0u;
 
   root_.reset(window_server()->CreateServerWindow(
       window_server()->display_manager()->GetAndAdvanceNextRootId(),
       ServerWindow::Properties()));
   // Our root is always a child of the Display's root. Do this
   // before the WindowTree has been created so that the client doesn't get
@@ skipping 174 matching lines @@
 
 void WindowManagerState::ReleaseNativeCapture() {
   platform_display_->ReleaseCapture();
 }
 
 void WindowManagerState::OnServerWindowCaptureLost(ServerWindow* window) {
   DCHECK(window);
   window_server()->ProcessLostCapture(window);
 }
 
+void WindowManagerState::OnMouseCursorLocationChanged(
+    const gfx::Point& point) {
+  current_cursor_location_ =
+      static_cast<base::subtle::Atomic32>(
+          (point.x() & 0xFFFF) << 16 | (point.y() & 0xFFFF));
+  if (cursor_location_memory_) {
+    base::subtle::NoBarrier_Store(cursor_location_memory_,
+                                  current_cursor_location_);
+  }
+}
+
 void WindowManagerState::DispatchInputEventToWindow(ServerWindow* target,
                                                     bool in_nonclient_area,
                                                     const ui::Event& event,
                                                     Accelerator* accelerator) {
   DCHECK(IsActive());
   // TODO(sky): this needs to see if another wms has capture and if so forward
   // to it.
   if (event_ack_timer_.IsRunning()) {
     std::unique_ptr<ProcessedEventTarget> processed_event_target(
         new ProcessedEventTarget(target, in_nonclient_area, accelerator));
     QueueEvent(event, std::move(processed_event_target));
     return;
   }
 
   base::WeakPtr<Accelerator> weak_accelerator;
   if (accelerator)
     weak_accelerator = accelerator->GetWeakPtr();
   DispatchInputEventToWindowImpl(target, in_nonclient_area, event,
                                  weak_accelerator);
 }
 
 void WindowManagerState::OnEventTargetNotFound(const ui::Event& event) {
   window_server()->SendToEventObservers(event, user_id_,
                                         nullptr /* ignore_tree */);
 }
 
 }  // namespace ws
 }  // namespace mus