Hide mouse cursor when screenshot is taking

ui/snapshot/screenshot_grabber.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 "ui/snapshot/screenshot_grabber.h"
 
 #include <stddef.h>
 
 #include <climits>
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "ui/gfx/image/image.h"
 #include "ui/snapshot/snapshot.h"
 
 #if defined(USE_AURA)
+#include "ui/aura/client/cursor_client.h"
 #include "ui/aura/window.h"
 #endif
 
 namespace ui {
 
 namespace {
 // The minimum interval between two screenshot commands.  It has to be
 // more than 1000 to prevent the conflict of filenames.
 const int kScreenshotMinimumIntervalInMS = 1000;
 
@@ skipping 64 matching lines @@
 
 void ScreenshotGrabberDelegate::PrepareFileAndRunOnBlockingPool(
     const base::FilePath& path,
     scoped_refptr<base::TaskRunner> blocking_task_runner,
     const FileCallback& callback_on_blocking_pool) {
   blocking_task_runner->PostTask(
       FROM_HERE,
       base::Bind(EnsureLocalDirectoryExists, path, callback_on_blocking_pool));
 }
 
+#if defined(USE_AURA)
+class ScreenshotGrabber::ScopedCursorHider {
+ public:
+  explicit ScopedCursorHider(aura::Window* window)
+      : window_(window), hid_cursor_(false) {
+    if (!window_->IsRootWindow())

[sky, 2016/07/22 16:14:44]

This should be a DCHECK.

[Qiang(Joe) Xu, 2016/07/22 20:15:26]

Done.

+      return;
+    aura::client::CursorClient* cursor_client =

[sky, 2016/07/22 16:14:44]

Having to have all these checks in both the constructor and destructor is ugly.
How about a static function that returns a std::unique_ptr<ScopedCursorHider>
only if appropriate? The constructor is private. That way you get rid of
hid_cursor.

[Qiang(Joe) Xu, 2016/07/22 20:15:26]

done. Thanks for suggestion.

+        aura::client::GetCursorClient(window_);
+    if (!cursor_client)
+      return;
+    cursor_client->HideCursor();
+    hid_cursor_ = true;
+  }
+  ~ScopedCursorHider() {
+    if (!window_->IsRootWindow())
+      return;
+    if (hid_cursor_) {
+      aura::client::CursorClient* cursor_client =
+          aura::client::GetCursorClient(window_);
+      if (!cursor_client)
+        return;
+      cursor_client->ShowCursor();
+    }
+  }
+
+ private:
+  aura::Window* window_;
+  bool hid_cursor_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedCursorHider);
+};
+#endif
+
 ScreenshotGrabber::ScreenshotGrabber(
     ScreenshotGrabberDelegate* client,
     scoped_refptr<base::TaskRunner> blocking_task_runner)
     : client_(client),
       blocking_task_runner_(blocking_task_runner),
       factory_(this) {
 }
 
 ScreenshotGrabber::~ScreenshotGrabber() {
 }
 
 void ScreenshotGrabber::TakeScreenshot(gfx::NativeWindow window,
                                        const gfx::Rect& rect,
                                        const base::FilePath& screenshot_path) {
   DCHECK(base::MessageLoopForUI::IsCurrent());
   last_screenshot_timestamp_ = base::TimeTicks::Now();
 
   bool is_partial = true;
   // Window identifier is used to log a message on failure to capture a full
   // screen (i.e. non partial) screenshot. The only time is_partial can be
   // false, we will also have an identification string for the window.
   std::string window_identifier;
 #if defined(USE_AURA)
   aura::Window* aura_window = static_cast<aura::Window*>(window);
   is_partial = rect.size() != aura_window->bounds().size();
   window_identifier = aura_window->GetBoundsInScreen().ToString();
+
+  cursor_hider_.reset(new ScopedCursorHider(aura_window->GetRootWindow()));
 #endif
   ui::GrabWindowSnapshotAsync(
       window, rect, blocking_task_runner_,
       base::Bind(&ScreenshotGrabber::GrabWindowSnapshotAsyncCallback,
                  factory_.GetWeakPtr(), window_identifier, screenshot_path,
                  is_partial));
 }
 
 bool ScreenshotGrabber::CanTakeScreenshot() {
   return last_screenshot_timestamp_.is_null() ||
          base::TimeTicks::Now() - last_screenshot_timestamp_ >
              base::TimeDelta::FromMilliseconds(kScreenshotMinimumIntervalInMS);
 }
 
 void ScreenshotGrabber::NotifyScreenshotCompleted(
     ScreenshotGrabberObserver::Result screenshot_result,
     const base::FilePath& screenshot_path) {
   DCHECK(base::MessageLoopForUI::IsCurrent());
+#if defined(USE_AURA)
+  cursor_hider_.reset();
+#endif
   FOR_EACH_OBSERVER(ScreenshotGrabberObserver, observers_,
                     OnScreenshotCompleted(screenshot_result, screenshot_path));
 }
 
 void ScreenshotGrabber::AddObserver(ScreenshotGrabberObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void ScreenshotGrabber::RemoveObserver(ScreenshotGrabberObserver* observer) {
   observers_.RemoveObserver(observer);
@@ skipping 28 matching lines @@
 
   ShowNotificationCallback notification_callback(base::Bind(
       &ScreenshotGrabber::NotifyScreenshotCompleted, factory_.GetWeakPtr()));
   client_->PrepareFileAndRunOnBlockingPool(
       screenshot_path, blocking_task_runner_,
       base::Bind(&SaveScreenshot, base::ThreadTaskRunnerHandle::Get(),
                  notification_callback, screenshot_path, png_data));
 }
 
 }  // namespace ui