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

ash/utility/screenshot_controller.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 "ash/utility/screenshot_controller.h"
 
 #include <cmath>
 
 #include "ash/display/mouse_cursor_event_filter.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/screenshot_delegate.h"
 #include "ash/shell.h"
+#include "ash/shell_port.h"
 #include "ash/wm/window_util.h"
 #include "base/memory/ptr_util.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/window_targeter.h"
 #include "ui/compositor/paint_recorder.h"
 #include "ui/display/screen.h"
 #include "ui/events/event.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/event_handler.h"
@@ skipping 168 matching lines @@
   gfx::Rect region_;
 
   gfx::Point cursor_location_in_root_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenshotLayer);
 };
 
 class ScreenshotController::ScopedCursorSetter {
  public:
   ScopedCursorSetter(::wm::CursorManager* cursor_manager,
-                     gfx::NativeCursor cursor)
-      : cursor_manager_(nullptr) {
-    if (cursor_manager->IsCursorLocked())
+                     ui::CursorType cursor) {
+    if (cursor_manager)
+      InitializeWithCursorManager(cursor_manager, cursor);
+    else
+      InitializeWithShellPort(cursor);
+  }
+
+  ~ScopedCursorSetter() {
+    if (cursor_manager_) {
+      cursor_manager_->UnlockCursor();
+    } else if (already_locked_) {
+      // No action; we didn't lock the cursor because it was already locked.
+    } else {
+      ShellPort::Get()->UnlockCursor();
+    }
+  }
+
+ private:
+  void InitializeWithCursorManager(::wm::CursorManager* cursor_manager,
+                                   ui::CursorType cursor) {
+    if (cursor_manager->IsCursorLocked()) {
+      already_locked_ = true;
       return;
+    }
     gfx::NativeCursor original_cursor = cursor_manager->GetCursor();
     cursor_manager_ = cursor_manager;
     if (cursor == ui::CursorType::kNone) {
       cursor_manager_->HideCursor();
     } else {
       cursor_manager_->SetCursor(cursor);
       cursor_manager_->ShowCursor();
     }
     cursor_manager_->LockCursor();
     // Set/ShowCursor does not make any effects at this point but it sets
     // back to the original cursor when unlocked.
     cursor_manager_->SetCursor(original_cursor);
     cursor_manager_->ShowCursor();
   }
 
-  ~ScopedCursorSetter() {
-    if (cursor_manager_)
-      cursor_manager_->UnlockCursor();
+  void InitializeWithShellPort(ui::CursorType cursor) {
+    // No cursor manager. We are in mus mode.
+    ShellPort* port = ShellPort::Get();
+    if (cursor == ui::CursorType::kNone) {
+      port->HideCursor();
+    } else {
+      port->SetGlobalOverrideCursor(ui::CursorData(cursor));
+      port->ShowCursor();
+    }
+    port->LockCursor();
+
+    // Set/ShowCursor does not make any effects at this point but it sets
+    // back to the original cursor when unlocked.
+    port->SetGlobalOverrideCursor(base::nullopt);
+    port->ShowCursor();
   }
 
- private:
-  ::wm::CursorManager* cursor_manager_;
+  // If the cursor is already locked, don't try to lock it again.
+  bool already_locked_ = false;
+
+  // If we were given a valid CursorManager, and the cursor wasn't locked, keep
+  // track of the CursorManager we sent a LockCursor() call to so we can unlock
+  // it in the destructor.
+  ::wm::CursorManager* cursor_manager_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedCursorSetter);
 };
 
 ScreenshotController::ScreenshotController()
     : mode_(NONE),
       root_window_(nullptr),
       selected_(nullptr),
       screenshot_delegate_(nullptr) {
   // Keep this here and don't move it to StartPartialScreenshotSession(), as it
@@ skipping 308 matching lines @@
 
 void ScreenshotController::OnDisplayMetricsChanged(
     const display::Display& display,
     uint32_t changed_metrics) {}
 
 void ScreenshotController::OnWindowDestroying(aura::Window* window) {
   SetSelectedWindow(nullptr);
 }
 
 }  // namespace ash