Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(4186)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: chrome/browser/ui/ash/screenshot_taker.cc

Issue 706013004: Move non-browser specific ScreenshotTaker code to ui/snapshot. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Restrict to use_aura==1 and fix gn build Created 6 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« chrome/browser/ui/ash/chrome_screenshot_taker.cc ('K') | « chrome/browser/ui/ash/screenshot_taker.h ('k') | chrome/browser/ui/ash/screenshot_taker_unittest.cc » ('j') | components/screenshot_taker/screenshot_taker.h » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: chrome/browser/ui/ash/screenshot_taker.cc
diff --git a/chrome/browser/ui/ash/screenshot_taker.cc b/chrome/browser/ui/ash/screenshot_taker.cc
deleted file mode 100644
index 108ca8b580a5a3ff652d9edbcc719e30bf4c8963..0000000000000000000000000000000000000000
--- a/chrome/browser/ui/ash/screenshot_taker.cc
+++ /dev/null
@@ -1,628 +0,0 @@
-// Copyright (c) 2012 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 "chrome/browser/ui/ash/screenshot_taker.h"
-
-#include <climits>
-#include <string>
-
-#include "ash/shell.h"
-#include "ash/shell_delegate.h"
-#include "ash/system/system_notifier.h"
-#include "base/base64.h"
-#include "base/bind.h"
-#include "base/files/file_util.h"
-#include "base/i18n/time_formatting.h"
-#include "base/logging.h"
-#include "base/memory/ref_counted_memory.h"
-#include "base/prefs/pref_service.h"
-#include "base/strings/stringprintf.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/threading/sequenced_worker_pool.h"
-#include "base/time/time.h"
-#include "chrome/browser/browser_process.h"
-#include "chrome/browser/download/download_prefs.h"
-#include "chrome/browser/notifications/notification_ui_manager.h"
-#include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/profiles/profile_manager.h"
-#include "chrome/common/pref_names.h"
-#include "content/public/browser/browser_thread.h"
-#include "content/public/browser/user_metrics.h"
-#include "grit/ash_strings.h"
-#include "grit/theme_resources.h"
-#include "ui/aura/window.h"
-#include "ui/aura/window_event_dispatcher.h"
-#include "ui/base/clipboard/clipboard.h"
-#include "ui/base/clipboard/scoped_clipboard_writer.h"
-#include "ui/base/l10n/l10n_util.h"
-#include "ui/base/resource/resource_bundle.h"
-#include "ui/gfx/image/image.h"
-#include "ui/snapshot/snapshot.h"
-#include "ui/strings/grit/ui_strings.h"
-
-#if defined(OS_CHROMEOS)
-#include "chrome/browser/chromeos/drive/file_system_interface.h"
-#include "chrome/browser/chromeos/drive/file_system_util.h"
-#include "chrome/browser/chromeos/file_manager/open_util.h"
-#include "chrome/browser/notifications/desktop_notification_service.h"
-#include "chrome/browser/notifications/desktop_notification_service_factory.h"
-#include "chromeos/login/login_state.h"
-#endif
-
-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;
-
-const char kNotificationId[] = "screenshot";
-
-#if defined(OS_CHROMEOS)
-const char kNotificationOriginUrl[] = "chrome://screenshot";
-#endif
-
-const char kImageClipboardFormatPrefix[] = "<img src='data:image/png;base64,";
-const char kImageClipboardFormatSuffix[] = "'>";
-
-void CopyScreenshotToClipboard(scoped_refptr<base::RefCountedString> png_data) {
- DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-
- std::string encoded;
- base::Base64Encode(png_data->data(), &encoded);
-
- // Only cares about HTML because ChromeOS doesn't need other formats.
- // TODO(dcheng): Why don't we take advantage of the ability to write bitmaps
- // to the clipboard here?
- {
- ui::ScopedClipboardWriter scw(ui::CLIPBOARD_TYPE_COPY_PASTE);
- std::string html(kImageClipboardFormatPrefix);
- html += encoded;
- html += kImageClipboardFormatSuffix;
- scw.WriteHTML(base::UTF8ToUTF16(html), std::string());
- }
- content::RecordAction(base::UserMetricsAction("Screenshot_CopyClipboard"));
-}
-
-void ReadFileAndCopyToClipboardLocal(const base::FilePath& screenshot_path) {
- DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
-
- scoped_refptr<base::RefCountedString> png_data(new base::RefCountedString());
- if (!base::ReadFileToString(screenshot_path, &(png_data->data()))) {
- LOG(ERROR) << "Failed to read the screenshot file: "
- << screenshot_path.value();
- return;
- }
-
- content::BrowserThread::PostTask(
- content::BrowserThread::UI, FROM_HERE,
- base::Bind(CopyScreenshotToClipboard, png_data));
-}
-
-#if defined(OS_CHROMEOS)
-void ReadFileAndCopyToClipboardDrive(drive::FileError error,
- const base::FilePath& file_path,
- scoped_ptr<drive::ResourceEntry> entry) {
- if (error != drive::FILE_ERROR_OK) {
- LOG(ERROR) << "Failed to read the screenshot path on drive: "
- << drive::FileErrorToString(error);
- return;
- }
- content::BrowserThread::GetBlockingPool()->PostTask(
- FROM_HERE,
- base::Bind(&ReadFileAndCopyToClipboardLocal, file_path));
-}
-#endif
-
-// Delegate for a notification. This class has two roles: to implement callback
-// methods for notification, and to provide an identity of the associated
-// notification.
-class ScreenshotTakerNotificationDelegate : public NotificationDelegate {
- public:
- ScreenshotTakerNotificationDelegate(bool success,
- Profile* profile,
- const base::FilePath& screenshot_path)
- : success_(success),
- profile_(profile),
- screenshot_path_(screenshot_path) {
- }
-
- // Overridden from NotificationDelegate:
- void Click() override {
- if (!success_)
- return;
-#if defined(OS_CHROMEOS)
- file_manager::util::ShowItemInFolder(profile_, screenshot_path_);
-#else
- // TODO(sschmitz): perhaps add similar action for Windows.
-#endif
- }
- void ButtonClick(int button_index) override {
- DCHECK(success_ && button_index == 0);
-
- // To avoid keeping the screenshot image on memory, it will re-read the
- // screenshot file and copy it to the clipboard.
-#if defined(OS_CHROMEOS)
- if (drive::util::IsUnderDriveMountPoint(screenshot_path_)) {
- drive::FileSystemInterface* file_system =
- drive::util::GetFileSystemByProfile(profile_);
- file_system->GetFile(
- drive::util::ExtractDrivePath(screenshot_path_),
- base::Bind(&ReadFileAndCopyToClipboardDrive));
- return;
- }
-#endif
- content::BrowserThread::GetBlockingPool()->PostTask(
- FROM_HERE, base::Bind(
- &ReadFileAndCopyToClipboardLocal, screenshot_path_));
- }
- bool HasClickedListener() override { return success_; }
- std::string id() const override { return std::string(kNotificationId); }
-
- private:
- ~ScreenshotTakerNotificationDelegate() override {}
-
- const bool success_;
- Profile* profile_;
- const base::FilePath screenshot_path_;
-
- DISALLOW_COPY_AND_ASSIGN(ScreenshotTakerNotificationDelegate);
-};
-
-typedef base::Callback<
- void(ScreenshotTakerObserver::Result screenshot_result,
- const base::FilePath& screenshot_path)> ShowNotificationCallback;
-
-void SaveScreenshotInternal(const ShowNotificationCallback& callback,
- const base::FilePath& screenshot_path,
- const base::FilePath& local_path,
- scoped_refptr<base::RefCountedBytes> png_data) {
- DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
- DCHECK(!local_path.empty());
- ScreenshotTakerObserver::Result result =
- ScreenshotTakerObserver::SCREENSHOT_SUCCESS;
- if (static_cast<size_t>(base::WriteFile(
- local_path,
- reinterpret_cast<char*>(&(png_data->data()[0])),
- png_data->size())) != png_data->size()) {
- LOG(ERROR) << "Failed to save to " << local_path.value();
- result = ScreenshotTakerObserver::SCREENSHOT_WRITE_FILE_FAILED;
- }
- content::BrowserThread::PostTask(
- content::BrowserThread::UI, FROM_HERE,
- base::Bind(callback, result, screenshot_path));
-}
-
-void SaveScreenshot(const ShowNotificationCallback& callback,
- const base::FilePath& screenshot_path,
- scoped_refptr<base::RefCountedBytes> png_data) {
- DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
- DCHECK(!screenshot_path.empty());
-
- if (!base::CreateDirectory(screenshot_path.DirName())) {
- LOG(ERROR) << "Failed to ensure the existence of "
- << screenshot_path.DirName().value();
- content::BrowserThread::PostTask(
- content::BrowserThread::UI, FROM_HERE,
- base::Bind(callback,
- ScreenshotTakerObserver::SCREENSHOT_CREATE_DIR_FAILED,
- screenshot_path));
- return;
- }
- SaveScreenshotInternal(callback, screenshot_path, screenshot_path, png_data);
-}
-
-// TODO(kinaba): crbug.com/140425, remove this ungly #ifdef dispatch.
-#if defined(OS_CHROMEOS)
-void SaveScreenshotToDrive(const ShowNotificationCallback& callback,
- const base::FilePath& screenshot_path,
- scoped_refptr<base::RefCountedBytes> png_data,
- drive::FileError error,
- const base::FilePath& local_path) {
- // |screenshot_path| is used in the notification callback.
- // |local_path| is a temporary file in a hidden cache directory used for
- // internal work generated by drive::util::PrepareWritableFileAndRun.
- if (error != drive::FILE_ERROR_OK) {
- LOG(ERROR) << "Failed to write screenshot image to Google Drive: " << error;
- content::BrowserThread::PostTask(
- content::BrowserThread::UI, FROM_HERE,
- base::Bind(callback,
- ScreenshotTakerObserver::SCREENSHOT_CREATE_FILE_FAILED,
- screenshot_path));
- return;
- }
- SaveScreenshotInternal(callback, screenshot_path, local_path, png_data);
-}
-
-void EnsureDirectoryExistsCallback(
- const ShowNotificationCallback& callback,
- Profile* profile,
- const base::FilePath& screenshot_path,
- scoped_refptr<base::RefCountedBytes> png_data,
- drive::FileError error) {
- // It is okay to fail with FILE_ERROR_EXISTS since anyway the directory
- // of the target file exists.
- if (error == drive::FILE_ERROR_OK ||
- error == drive::FILE_ERROR_EXISTS) {
- drive::util::PrepareWritableFileAndRun(
- profile,
- screenshot_path,
- base::Bind(&SaveScreenshotToDrive,
- callback,
- screenshot_path,
- png_data));
- } else {
- LOG(ERROR) << "Failed to ensure the existence of the specified directory "
- << "in Google Drive: " << error;
- callback.Run(ScreenshotTakerObserver::SCREENSHOT_CHECK_DIR_FAILED,
- screenshot_path);
- }
-}
-
-void PostSaveScreenshotTask(const ShowNotificationCallback& callback,
- Profile* profile,
- const base::FilePath& screenshot_path,
- scoped_refptr<base::RefCountedBytes> png_data) {
- if (drive::util::IsUnderDriveMountPoint(screenshot_path)) {
- drive::util::EnsureDirectoryExists(
- profile,
- screenshot_path.DirName(),
- base::Bind(&EnsureDirectoryExistsCallback,
- callback,
- profile,
- screenshot_path,
- png_data));
- } else {
- content::BrowserThread::GetBlockingPool()->PostTask(
- FROM_HERE, base::Bind(&SaveScreenshot,
- callback,
- screenshot_path,
- png_data));
- }
-}
-#else
-void PostSaveScreenshotTask(const ShowNotificationCallback& callback,
- Profile* profile,
- const base::FilePath& screenshot_path,
- scoped_refptr<base::RefCountedBytes> png_data) {
- content::BrowserThread::GetBlockingPool()->PostTask(
- FROM_HERE, base::Bind(&SaveScreenshot,
- callback,
- screenshot_path,
- png_data));
-}
-#endif
-
-bool ShouldUse24HourClock() {
-#if defined(OS_CHROMEOS)
- Profile* profile = ProfileManager::GetActiveUserProfile();
- if (profile) {
- return profile->GetPrefs()->GetBoolean(prefs::kUse24HourClock);
- }
-#endif
- return base::GetHourClockType() == base::k24HourClock;
-}
-
-std::string GetScreenshotBaseFilename() {
- base::Time::Exploded now;
- base::Time::Now().LocalExplode(&now);
-
- // We don't use base/i18n/time_formatting.h here because it doesn't
- // support our format. Don't use ICU either to avoid i18n file names
- // for non-English locales.
- // TODO(mukai): integrate this logic somewhere time_formatting.h
- std::string file_name = base::StringPrintf(
- "Screenshot %d-%02d-%02d at ", now.year, now.month, now.day_of_month);
-
- if (ShouldUse24HourClock()) {
- file_name.append(base::StringPrintf(
- "%02d.%02d.%02d", now.hour, now.minute, now.second));
- } else {
- int hour = now.hour;
- if (hour > 12) {
- hour -= 12;
- } else if (hour == 0) {
- hour = 12;
- }
- file_name.append(base::StringPrintf(
- "%d.%02d.%02d ", hour, now.minute, now.second));
- file_name.append((now.hour >= 12) ? "PM" : "AM");
- }
-
- return file_name;
-}
-
-bool GetScreenshotDirectory(base::FilePath* directory) {
- bool is_logged_in = true;
-
-#if defined(OS_CHROMEOS)
- is_logged_in = chromeos::LoginState::Get()->IsUserLoggedIn();
-#endif
-
- if (is_logged_in) {
- DownloadPrefs* download_prefs = DownloadPrefs::FromBrowserContext(
- ProfileManager::GetActiveUserProfile());
- *directory = download_prefs->DownloadPath();
- } else {
- if (!base::GetTempDir(directory)) {
- LOG(ERROR) << "Failed to find temporary directory.";
- return false;
- }
- }
- return true;
-}
-
-#if defined(OS_CHROMEOS)
-int GetScreenshotNotificationTitle(
- ScreenshotTakerObserver::Result screenshot_result) {
- switch (screenshot_result) {
- case ScreenshotTakerObserver::SCREENSHOTS_DISABLED:
- return IDS_ASH_SCREENSHOT_NOTIFICATION_TITLE_DISABLED;
- case ScreenshotTakerObserver::SCREENSHOT_SUCCESS:
- return IDS_ASH_SCREENSHOT_NOTIFICATION_TITLE_SUCCESS;
- default:
- return IDS_ASH_SCREENSHOT_NOTIFICATION_TITLE_FAIL;
- }
-}
-
-int GetScreenshotNotificationText(
- ScreenshotTakerObserver::Result screenshot_result) {
- switch (screenshot_result) {
- case ScreenshotTakerObserver::SCREENSHOTS_DISABLED:
- return IDS_ASH_SCREENSHOT_NOTIFICATION_TEXT_DISABLED;
- case ScreenshotTakerObserver::SCREENSHOT_SUCCESS:
- return IDS_ASH_SCREENSHOT_NOTIFICATION_TEXT_SUCCESS;
- default:
- return IDS_ASH_SCREENSHOT_NOTIFICATION_TEXT_FAIL;
- }
-}
-#endif
-
-} // namespace
-
-ScreenshotTaker::ScreenshotTaker()
- : profile_for_test_(NULL),
- factory_(this) {
-}
-
-ScreenshotTaker::~ScreenshotTaker() {
-}
-
-void ScreenshotTaker::HandleTakeScreenshotForAllRootWindows() {
- if (g_browser_process->local_state()->
- GetBoolean(prefs::kDisableScreenshots)) {
- ShowNotification(ScreenshotTakerObserver::SCREENSHOTS_DISABLED,
- base::FilePath());
- return;
- }
- base::FilePath screenshot_directory;
- if (!screenshot_directory_for_test_.empty()) {
- screenshot_directory = screenshot_directory_for_test_;
- } else if (!GetScreenshotDirectory(&screenshot_directory)) {
- ShowNotification(ScreenshotTakerObserver::SCREENSHOT_GET_DIR_FAILED,
- base::FilePath());
- return;
- }
- std::string screenshot_basename = !screenshot_basename_for_test_.empty() ?
- screenshot_basename_for_test_ : GetScreenshotBaseFilename();
-
- aura::Window::Windows root_windows = ash::Shell::GetAllRootWindows();
- // Reorder root_windows to take the primary root window's snapshot at first.
- aura::Window* primary_root = ash::Shell::GetPrimaryRootWindow();
- if (*(root_windows.begin()) != primary_root) {
- root_windows.erase(std::find(
- root_windows.begin(), root_windows.end(), primary_root));
- root_windows.insert(root_windows.begin(), primary_root);
- }
- for (size_t i = 0; i < root_windows.size(); ++i) {
- aura::Window* root_window = root_windows[i];
- std::string basename = screenshot_basename;
- gfx::Rect rect = root_window->bounds();
- if (root_windows.size() > 1)
- basename += base::StringPrintf(" - Display %d", static_cast<int>(i + 1));
- base::FilePath screenshot_path =
- screenshot_directory.AppendASCII(basename + ".png");
- GrabFullWindowSnapshotAsync(
- root_window, rect, GetProfile(), screenshot_path, i);
- }
- content::RecordAction(base::UserMetricsAction("Screenshot_TakeFull"));
-}
-
-void ScreenshotTaker::HandleTakePartialScreenshot(
- aura::Window* window, const gfx::Rect& rect) {
- if (g_browser_process->local_state()->
- GetBoolean(prefs::kDisableScreenshots)) {
- ShowNotification(ScreenshotTakerObserver::SCREENSHOTS_DISABLED,
- base::FilePath());
- return;
- }
- DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-
- base::FilePath screenshot_directory;
- if (!screenshot_directory_for_test_.empty()) {
- screenshot_directory = screenshot_directory_for_test_;
- } else if (!GetScreenshotDirectory(&screenshot_directory)) {
- ShowNotification(ScreenshotTakerObserver::SCREENSHOT_GET_DIR_FAILED,
- base::FilePath());
- return;
- }
-
- std::string screenshot_basename = !screenshot_basename_for_test_.empty() ?
- screenshot_basename_for_test_ : GetScreenshotBaseFilename();
- base::FilePath screenshot_path =
- screenshot_directory.AppendASCII(screenshot_basename + ".png");
- GrabPartialWindowSnapshotAsync(window, rect, GetProfile(), screenshot_path);
- content::RecordAction(base::UserMetricsAction("Screenshot_TakePartial"));
-}
-
-bool ScreenshotTaker::CanTakeScreenshot() {
- return last_screenshot_timestamp_.is_null() ||
- base::Time::Now() - last_screenshot_timestamp_ >
- base::TimeDelta::FromMilliseconds(
- kScreenshotMinimumIntervalInMS);
-}
-
-#if defined(OS_CHROMEOS)
-Notification* ScreenshotTaker::CreateNotification(
- ScreenshotTakerObserver::Result screenshot_result,
- const base::FilePath& screenshot_path) {
- const std::string notification_id(kNotificationId);
- // We cancel a previous screenshot notification, if any, to ensure we get
- // a fresh notification pop-up.
- g_browser_process->notification_ui_manager()->CancelById(
- notification_id, NotificationUIManager::GetProfileID(GetProfile()));
- const base::string16 replace_id(base::UTF8ToUTF16(notification_id));
- bool success =
- (screenshot_result == ScreenshotTakerObserver::SCREENSHOT_SUCCESS);
- message_center::RichNotificationData optional_field;
- if (success) {
- const base::string16 label = l10n_util::GetStringUTF16(
- IDS_MESSAGE_CENTER_NOTIFICATION_BUTTON_COPY_SCREENSHOT_TO_CLIPBOARD);
- optional_field.buttons.push_back(message_center::ButtonInfo(label));
- }
- return new Notification(
- message_center::NOTIFICATION_TYPE_SIMPLE,
- GURL(kNotificationOriginUrl),
- l10n_util::GetStringUTF16(
- GetScreenshotNotificationTitle(screenshot_result)),
- l10n_util::GetStringUTF16(
- GetScreenshotNotificationText(screenshot_result)),
- ui::ResourceBundle::GetSharedInstance().GetImageNamed(
- IDR_SCREENSHOT_NOTIFICATION_ICON),
- blink::WebTextDirectionDefault,
- message_center::NotifierId(
- message_center::NotifierId::SYSTEM_COMPONENT,
- ash::system_notifier::kNotifierScreenshot),
- l10n_util::GetStringUTF16(IDS_MESSAGE_CENTER_NOTIFIER_SCREENSHOT_NAME),
- replace_id,
- optional_field,
- new ScreenshotTakerNotificationDelegate(
- success, GetProfile(), screenshot_path));
-}
-#endif
-
-void ScreenshotTaker::ShowNotification(
- ScreenshotTakerObserver::Result screenshot_result,
- const base::FilePath& screenshot_path) {
- DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-#if defined(OS_CHROMEOS)
- // Do not show a notification that a screenshot was taken while no user is
- // logged in, since it is confusing for the user to get a message about it
- // after he logs in (crbug.com/235217).
- if (!chromeos::LoginState::Get()->IsUserLoggedIn())
- return;
-
- // TODO(sschmitz): make this work for Windows.
- DesktopNotificationService* const service =
- DesktopNotificationServiceFactory::GetForProfile(GetProfile());
- if (service->IsNotifierEnabled(message_center::NotifierId(
- message_center::NotifierId::SYSTEM_COMPONENT,
- ash::system_notifier::kNotifierScreenshot))) {
- scoped_ptr<Notification> notification(
- CreateNotification(screenshot_result, screenshot_path));
- g_browser_process->notification_ui_manager()->Add(*notification,
- GetProfile());
- }
-#endif
- FOR_EACH_OBSERVER(ScreenshotTakerObserver, observers_,
- OnScreenshotCompleted(screenshot_result, screenshot_path));
-}
-
-void ScreenshotTaker::AddObserver(ScreenshotTakerObserver* observer) {
- observers_.AddObserver(observer);
-}
-
-void ScreenshotTaker::RemoveObserver(ScreenshotTakerObserver* observer) {
- observers_.RemoveObserver(observer);
-}
-
-bool ScreenshotTaker::HasObserver(
- const ScreenshotTakerObserver* observer) const {
- return observers_.HasObserver(observer);
-}
-
-void ScreenshotTaker::GrabWindowSnapshotAsyncCallback(
- base::FilePath screenshot_path,
- bool is_partial,
- int window_idx,
- scoped_refptr<base::RefCountedBytes> png_data) {
- if (!png_data.get()) {
- if (is_partial) {
- LOG(ERROR) << "Failed to grab the window screenshot";
- ShowNotification(
- ScreenshotTakerObserver::SCREENSHOT_GRABWINDOW_PARTIAL_FAILED,
- screenshot_path);
- } else {
- LOG(ERROR) << "Failed to grab the window screenshot for " << window_idx;
- ShowNotification(
- ScreenshotTakerObserver::SCREENSHOT_GRABWINDOW_FULL_FAILED,
- screenshot_path);
- }
- return;
- }
-
- PostSaveScreenshotTask(
- base::Bind(&ScreenshotTaker::ShowNotification, factory_.GetWeakPtr()),
- GetProfile(),
- screenshot_path,
- png_data);
-}
-
-void ScreenshotTaker::GrabPartialWindowSnapshotAsync(
- aura::Window* window,
- const gfx::Rect& snapshot_bounds,
- Profile* profile,
- base::FilePath screenshot_path) {
- last_screenshot_timestamp_ = base::Time::Now();
-
- bool is_partial = true;
- int window_idx = -1; // unused
- ui::GrabWindowSnapshotAsync(
- window,
- snapshot_bounds,
- content::BrowserThread::GetBlockingPool(),
- base::Bind(&ScreenshotTaker::GrabWindowSnapshotAsyncCallback,
- factory_.GetWeakPtr(),
- screenshot_path,
- is_partial,
- window_idx));
-}
-
-void ScreenshotTaker::GrabFullWindowSnapshotAsync(
- aura::Window* window,
- const gfx::Rect& snapshot_bounds,
- Profile* profile,
- base::FilePath screenshot_path,
- int window_idx) {
- last_screenshot_timestamp_ = base::Time::Now();
-
- bool is_partial = false;
- ui::GrabWindowSnapshotAsync(
- window,
- snapshot_bounds,
- content::BrowserThread::GetBlockingPool(),
- base::Bind(&ScreenshotTaker::GrabWindowSnapshotAsyncCallback,
- factory_.GetWeakPtr(),
- screenshot_path,
- is_partial,
- window_idx));
-}
-
-Profile* ScreenshotTaker::GetProfile() {
- if (profile_for_test_)
- return profile_for_test_;
- return ProfileManager::GetActiveUserProfile();
-}
-
-void ScreenshotTaker::SetScreenshotDirectoryForTest(
- const base::FilePath& directory) {
- screenshot_directory_for_test_ = directory;
-}
-
-void ScreenshotTaker::SetScreenshotBasenameForTest(
- const std::string& basename) {
- screenshot_basename_for_test_ = basename;
-}
-
-void ScreenshotTaker::SetScreenshotProfileForTest(Profile* profile) {
- profile_for_test_ = profile;
-}
« chrome/browser/ui/ash/chrome_screenshot_taker.cc ('K') | « chrome/browser/ui/ash/screenshot_taker.h ('k') | chrome/browser/ui/ash/screenshot_taker_unittest.cc » ('j') | components/screenshot_taker/screenshot_taker.h » ('J')

Powered by Google App Engine
This is Rietveld 408576698