| // 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/memory/ptr_util.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; |
| |
| using ShowNotificationCallback = |
| base::Callback<void(ScreenshotGrabberObserver::Result screenshot_result, |
| const base::FilePath& screenshot_path)>; |
| |
| void SaveScreenshot(scoped_refptr<base::TaskRunner> ui_task_runner, |
| const ShowNotificationCallback& callback, |
| const base::FilePath& screenshot_path, |
| scoped_refptr<base::RefCountedMemory> png_data, |
| ScreenshotGrabberDelegate::FileResult result, |
| const base::FilePath& local_path) { |
| DCHECK(!base::MessageLoopForUI::IsCurrent()); |
| DCHECK(!screenshot_path.empty()); |
| |
| // Convert FileResult into ScreenshotGrabberObserver::Result. |
| ScreenshotGrabberObserver::Result screenshot_result = |
| ScreenshotGrabberObserver::SCREENSHOT_SUCCESS; |
| switch (result) { |
| case ScreenshotGrabberDelegate::FILE_SUCCESS: |
| // Successfully got a local file to write to, write png data. |
| DCHECK_GT(static_cast<int>(png_data->size()), 0); |
| if (static_cast<size_t>(base::WriteFile( |
| local_path, reinterpret_cast<const char*>(png_data->front()), |
| static_cast<int>(png_data->size()))) != png_data->size()) { |
| LOG(ERROR) << "Failed to save to " << local_path.value(); |
| screenshot_result = |
| ScreenshotGrabberObserver::SCREENSHOT_WRITE_FILE_FAILED; |
| } |
| break; |
| case ScreenshotGrabberDelegate::FILE_CHECK_DIR_FAILED: |
| screenshot_result = |
| ScreenshotGrabberObserver::SCREENSHOT_CHECK_DIR_FAILED; |
| break; |
| case ScreenshotGrabberDelegate::FILE_CREATE_DIR_FAILED: |
| screenshot_result = |
| ScreenshotGrabberObserver::SCREENSHOT_CREATE_DIR_FAILED; |
| break; |
| case ScreenshotGrabberDelegate::FILE_CREATE_FAILED: |
| screenshot_result = |
| ScreenshotGrabberObserver::SCREENSHOT_CREATE_FILE_FAILED; |
| break; |
| } |
| |
| // Report the result on the UI thread. |
| ui_task_runner->PostTask( |
| FROM_HERE, base::Bind(callback, screenshot_result, screenshot_path)); |
| } |
| |
| void EnsureLocalDirectoryExists( |
| const base::FilePath& path, |
| ScreenshotGrabberDelegate::FileCallback callback) { |
| DCHECK(!base::MessageLoopForUI::IsCurrent()); |
| DCHECK(!path.empty()); |
| |
| if (!base::CreateDirectory(path.DirName())) { |
| LOG(ERROR) << "Failed to ensure the existence of " |
| << path.DirName().value(); |
| callback.Run(ScreenshotGrabberDelegate::FILE_CREATE_DIR_FAILED, path); |
| return; |
| } |
| |
| callback.Run(ScreenshotGrabberDelegate::FILE_SUCCESS, path); |
| } |
| |
| } // namespace |
| |
| 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: |
| // The nullptr might be returned when GetCursorClient is nullptr. |
| static std::unique_ptr<ScopedCursorHider> Create(aura::Window* window) { |
| DCHECK(window->IsRootWindow()); |
| aura::client::CursorClient* cursor_client = |
| aura::client::GetCursorClient(window); |
| if (!cursor_client) |
| return nullptr; |
| cursor_client->HideCursor(); |
| return std::unique_ptr<ScopedCursorHider>( |
| base::WrapUnique(new ScopedCursorHider(window))); |
| } |
| |
| ~ScopedCursorHider() { |
| aura::client::CursorClient* cursor_client = |
| aura::client::GetCursorClient(window_); |
| cursor_client->ShowCursor(); |
| } |
| |
| private: |
| explicit ScopedCursorHider(aura::Window* window) : window_(window) {} |
| aura::Window* window_; |
| |
| 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_ = ScopedCursorHider::Create(aura_window->GetRootWindow()); |
| #endif |
| ui::GrabWindowSnapshotAsyncPNG( |
| 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 (ScreenshotGrabberObserver& observer : observers_) |
| observer.OnScreenshotCompleted(screenshot_result, screenshot_path); |
| } |
| |
| void ScreenshotGrabber::AddObserver(ScreenshotGrabberObserver* observer) { |
| observers_.AddObserver(observer); |
| } |
| |
| void ScreenshotGrabber::RemoveObserver(ScreenshotGrabberObserver* observer) { |
| observers_.RemoveObserver(observer); |
| } |
| |
| bool ScreenshotGrabber::HasObserver( |
| const ScreenshotGrabberObserver* observer) const { |
| return observers_.HasObserver(observer); |
| } |
| |
| void ScreenshotGrabber::GrabWindowSnapshotAsyncCallback( |
| const std::string& window_identifier, |
| base::FilePath screenshot_path, |
| bool is_partial, |
| scoped_refptr<base::RefCountedMemory> png_data) { |
| DCHECK(base::MessageLoopForUI::IsCurrent()); |
| if (!png_data.get()) { |
| if (is_partial) { |
| LOG(ERROR) << "Failed to grab the window screenshot"; |
| NotifyScreenshotCompleted( |
| ScreenshotGrabberObserver::SCREENSHOT_GRABWINDOW_PARTIAL_FAILED, |
| screenshot_path); |
| } else { |
| LOG(ERROR) << "Failed to grab the window screenshot for " |
| << window_identifier; |
| NotifyScreenshotCompleted( |
| ScreenshotGrabberObserver::SCREENSHOT_GRABWINDOW_FULL_FAILED, |
| screenshot_path); |
| } |
| return; |
| } |
| |
| 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 |