Add {Lock,Unlock,Show,Hide}Cursor() to the window manager mojom.

services/ui/ws/display.cc

 // Copyright 2015 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 "services/ui/ws/display.h"
 
 #include <set>
 #include <utility>
 #include <vector>
 
@@ skipping 18 matching lines @@
 #include "ui/base/cursor/cursor.h"
 #include "ui/display/screen.h"
 
 #if defined(USE_OZONE)
 #include "ui/ozone/public/ozone_platform.h"
 #endif
 
 namespace ui {
 namespace ws {
 
+class Display::CursorState {
+ public:
+  CursorState()
+      : cursor_data_(ui::CursorData(ui::CursorType::kNull)), visible_(true) {}
+  CursorState(const CursorState& rhs) = default;
+  ~CursorState() {}
+
+  const base::Optional<ui::CursorData>& global_override_cursor() const {
+    return global_override_cursor_;
+  }
+  void SetGlobalOverrideCursor(const base::Optional<ui::CursorData>& cursor) {
+    global_override_cursor_ = cursor;
+  }
+
+  const ui::CursorData& cursor_data() const { return cursor_data_; }
+  void SetCursorData(const ui::CursorData& data) { cursor_data_ = data; }
+
+  bool visible() const { return visible_; }
+  void set_visible(bool visible) { visible_ = visible; }
+
+ private:
+  // An optional cursor set by the window manager which overrides per-window
+  // requests.
+  base::Optional<ui::CursorData> global_override_cursor_;
+
+  // The last cursor set. Used to track whether we need to change the cursor.
+  ui::CursorData cursor_data_;
+
+  // Whether the cursor is visible.
+  bool visible_;
+};
+
 Display::Display(WindowServer* window_server)
     : window_server_(window_server),
-      last_cursor_(ui::CursorData(ui::CursorType::kNull)) {
+      current_state_(base::MakeUnique<CursorState>()),
+      state_on_unlock_(base::MakeUnique<CursorState>()) {
   window_server_->window_manager_window_tree_factory_set()->AddObserver(this);
   window_server_->user_id_tracker()->AddObserver(this);
 }
 
 Display::~Display() {
   window_server_->user_id_tracker()->RemoveObserver(this);
 
   window_server_->window_manager_window_tree_factory_set()->RemoveObserver(
       this);
 
@@ skipping 140 matching lines @@
        it != window_manager_display_root_map_.end(); ++it) {
     if (it->second == display_root) {
       window_manager_display_root_map_.erase(it);
       return;
     }
   }
   NOTREACHED();
 }
 
 void Display::UpdateNativeCursor(const ui::CursorData& cursor) {
-  if (!last_cursor_.IsSameAs(cursor)) {
-    platform_display_->SetCursor(cursor);
-    last_cursor_ = cursor;
+  if (!state_on_unlock_->cursor_data().IsSameAs(cursor))
+    state_on_unlock_->SetCursorData(cursor);
+
+  if (cursor_lock_count_ == 0 &&
+      !current_state_->cursor_data().IsSameAs(cursor)) {
+    current_state_->SetCursorData(cursor);
+    SetPlatformCursor();
   }
 }
 
+void Display::LockCursor() {
+  cursor_lock_count_++;
+}
+
+void Display::UnlockCursor() {
+  cursor_lock_count_--;

[sky, 2017/05/12 13:40:01]

Having each Display track this state is rather duplicative. WDYT of having a
class that keeps track of the lock count and other state and calls out to each
Display as appropriate? The call out to each display could be done via an
interface to minimize dependencies, but I don't feel strongly about that last
part.

[Elliot Glaysher, 2017/05/12 23:02:44]

Created CursorState class, which is owned by window_manager_state() and takes a
DisplayManager* in its ctor.

+  DCHECK_GE(cursor_lock_count_, 0);
+  if (cursor_lock_count_ > 0)
+    return;
+
+  *current_state_ = *state_on_unlock_;
+  SetPlatformCursor();
+}
+
+void Display::ShowCursor() {
+  state_on_unlock_->set_visible(true);
+  if (cursor_lock_count_ == 0 &&
+      current_state_->visible() != state_on_unlock_->visible()) {
+    current_state_->set_visible(true);
+    SetPlatformCursor();
+  }
+}
+
+void Display::HideCursor() {
+  state_on_unlock_->set_visible(false);
+  if (cursor_lock_count_ == 0 &&
+      current_state_->visible() != state_on_unlock_->visible()) {
+    platform_display_->SetCursor(ui::CursorData(ui::CursorType::kNone));
+    current_state_->set_visible(false);
+  }
+}
+
+void Display::SetGlobalOverrideCursor(
+    const base::Optional<ui::CursorData>& cursor) {
+  state_on_unlock_->SetGlobalOverrideCursor(cursor);
+  if (cursor_lock_count_ == 0) {
+    current_state_->SetGlobalOverrideCursor(cursor);
+    SetPlatformCursor();
+  }
+}
+
 void Display::SetSize(const gfx::Size& size) {
   platform_display_->SetViewportSize(size);
 }
 
 void Display::SetTitle(const std::string& title) {
   platform_display_->SetTitle(base::UTF8ToUTF16(title));
 }
 
 void Display::InitWindowManagerDisplayRoots() {
   if (binding_) {
@@ skipping 48 matching lines @@
       display_manager()->GetAndAdvanceNextRootId(),
       ServerWindow::Properties()));
   root_->set_event_targeting_policy(
       mojom::EventTargetingPolicy::DESCENDANTS_ONLY);
   root_->SetBounds(gfx::Rect(size), allocator_.GenerateId());
   root_->SetVisible(true);
   focus_controller_ = base::MakeUnique<FocusController>(this, root_.get());
   focus_controller_->AddObserver(this);
 }
 
+void Display::SetPlatformCursor() {
+  if (current_state_->visible()) {
+    if (current_state_->global_override_cursor().has_value()) {
+      platform_display_->SetCursor(
+          current_state_->global_override_cursor().value());
+    } else {
+      platform_display_->SetCursor(current_state_->cursor_data());
+    }
+  } else {
+    platform_display_->SetCursor(ui::CursorData(ui::CursorType::kNone));
+  }
+}
+
 ServerWindow* Display::GetRootWindow() {
   return root_.get();
 }
 
 EventSink* Display::GetEventSink() {
   return this;
 }
 
 void Display::OnAcceleratedWidgetAvailable() {
   display_manager()->OnDisplayAcceleratedWidgetAvailable(this);
@@ skipping 126 matching lines @@
 
   UserActivityMonitor* activity_monitor =
       window_server_->GetUserActivityMonitorForUser(
           window_server_->user_id_tracker()->active_id());
   activity_monitor->OnUserActivity();
   return EventDispatchDetails();
 }
 
 }  // namespace ws
 }  // namespace ui