Make ChromeOS screenshots use async readback path

chrome/browser/ui/ash/screenshot_taker.cc

 // 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"
@@ skipping 21 matching lines @@
 #include "grit/ash_strings.h"
 #include "grit/theme_resources.h"
 #include "grit/ui_strings.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.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"
 
 #if defined(USE_ASH)
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #endif
 
 #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"
@@ skipping 245 matching lines @@
                             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 GrabWindowSnapshot(aura::Window* window,
-                        const gfx::Rect& snapshot_bounds,
-                        std::vector<unsigned char>* png_data) {
-  return chrome::GrabWindowSnapshotForUser(window, png_data, snapshot_bounds);
-}
-
 bool ShouldUse24HourClock() {
 #if defined(OS_CHROMEOS)
   Profile* profile = ProfileManager::GetActiveUserProfile();
   if (profile) {
     return profile->GetPrefs()->GetBoolean(prefs::kUse24HourClock);
   }
 #endif
   return base::GetHourClockType() == base::k24HourClock;
 }
 
@@ skipping 101 matching lines @@
   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];
-    scoped_refptr<base::RefCountedBytes> png_data(new base::RefCountedBytes);
     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");
-    if (GrabWindowSnapshot(root_window, rect, &png_data->data())) {
-      PostSaveScreenshotTask(
-          base::Bind(&ScreenshotTaker::ShowNotification, factory_.GetWeakPtr()),
-          GetProfile(),
-          screenshot_path,
-          png_data);
-    } else {
-      LOG(ERROR) << "Failed to grab the window screenshot for " << i;
-      ShowNotification(
-          ScreenshotTakerObserver::SCREENSHOT_GRABWINDOW_FULL_FAILED,
-          screenshot_path);
-    }
+    GrabFullWindowSnapshotAsync(
+        root_window, rect, GetProfile(), screenshot_path, i);
   }
   content::RecordAction(base::UserMetricsAction("Screenshot_TakeFull"));
-  last_screenshot_timestamp_ = base::Time::Now();
 }
 
 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(content::BrowserThread::CurrentlyOn(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;
   }
 
-  scoped_refptr<base::RefCountedBytes> png_data(new base::RefCountedBytes);
-
   std::string screenshot_basename = !screenshot_basename_for_test_.empty() ?
       screenshot_basename_for_test_ : GetScreenshotBaseFilename();
   base::FilePath screenshot_path =
       screenshot_directory.AppendASCII(screenshot_basename + ".png");
-  if (GrabWindowSnapshot(window, rect, &png_data->data())) {
-    last_screenshot_timestamp_ = base::Time::Now();
-    PostSaveScreenshotTask(
-        base::Bind(&ScreenshotTaker::ShowNotification, factory_.GetWeakPtr()),
-        GetProfile(),
-        screenshot_path,
-        png_data);
-  } else {
-    LOG(ERROR) << "Failed to grab the window screenshot";
-    ShowNotification(
-        ScreenshotTakerObserver::SCREENSHOT_GRABWINDOW_PARTIAL_FAILED,
-        screenshot_path);
-  }
+  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);
 }
 
@@ skipping 65 matching lines @@
 }
 
 void ScreenshotTaker::RemoveObserver(ScreenshotTakerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 bool ScreenshotTaker::HasObserver(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) {
+    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;
 }