Move non-browser specific ScreenshotTaker code to ui/snapshot.

components/screenshot_taker/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 "components/screenshot_taker/screenshot_taker.h"
+
+#include <climits>
+#include <string>
+
+#include "base/bind.h"
+#include "base/files/file_util.h"
+#include "base/logging.h"
+#include "base/threading/sequenced_worker_pool.h"
+#include "base/time/time.h"
+#include "content/public/browser/browser_thread.h"
+#include "ui/aura/window.h"
+#include "ui/gfx/image/image.h"
+#include "ui/snapshot/snapshot.h"
+
+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;
+
+typedef base::Callback<
+  void(ScreenshotTakerObserver::Result screenshot_result,
+       const base::FilePath& screenshot_path)> ShowNotificationCallback;
+
+void SaveScreenshot(const ShowNotificationCallback& callback,
+                    const base::FilePath& screenshot_path,
+                    scoped_refptr<base::RefCountedBytes> png_data,
+                    ScreenshotTakerClient::WritableFileResult result,
+                    const base::FilePath& local_path) {
+  DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());

[Jun Mukai, 2014/11/12 19:36:21]

Can we use SequencedWorkerPool as a constructor parameter?  Then it doesn't have
to depend on the browser thread and content/

And then -- I think we can put the files into ui/snapshot rather than a new
directory in components.

[flackr, 2014/11/18 16:46:30]

Done.

+  DCHECK(!screenshot_path.empty());
+
+  // Convert WritableFileResult into ScreenshotTakerObserver::Result.
+  ScreenshotTakerObserver::Result screenshot_result =
+      ScreenshotTakerObserver::SCREENSHOT_SUCCESS;
+  switch(result) {
+    case ScreenshotTakerClient::WRITABLE_FILE_SUCCESS:
+      // Successful so far, continue to attempt to take screenshot.
+      break;
+    case ScreenshotTakerClient::WRITABLE_FILE_CHECK_DIR_FAILED:
+      screenshot_result =
+          ScreenshotTakerObserver::SCREENSHOT_CHECK_DIR_FAILED;
+      break;
+    case ScreenshotTakerClient::WRITABLE_FILE_CREATE_DIR_FAILED:
+      screenshot_result =
+          ScreenshotTakerObserver::SCREENSHOT_CREATE_DIR_FAILED;
+      break;
+    case ScreenshotTakerClient::WRITABLE_FILE_CREATE_FAILED:
+      screenshot_result =
+          ScreenshotTakerObserver::SCREENSHOT_CREATE_FILE_FAILED;
+      break;
+  }
+
+  if (screenshot_result == ScreenshotTakerObserver::SCREENSHOT_SUCCESS &&
+      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();
+    screenshot_result = ScreenshotTakerObserver::SCREENSHOT_WRITE_FILE_FAILED;
+  }
+
+  // Report the result on the UI thread.
+  content::BrowserThread::PostTask(
+      content::BrowserThread::UI, FROM_HERE,
+      base::Bind(callback, screenshot_result, screenshot_path));
+}
+
+void EnsureLocalDirectoryExists(
+    const base::FilePath& path,
+    ScreenshotTakerClient::WritableFileCallback callback) {
+  DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
+  DCHECK(!path.empty());
+
+  if (!base::CreateDirectory(path.DirName())) {
+    LOG(ERROR) << "Failed to ensure the existence of "
+               << path.DirName().value();
+    content::BrowserThread::PostTask(
+        content::BrowserThread::UI, FROM_HERE,
+        base::Bind(callback,
+                   ScreenshotTakerClient::WRITABLE_FILE_CREATE_DIR_FAILED,
+                   path));
+    return;
+  }
+
+  callback.Run(ScreenshotTakerClient::WRITABLE_FILE_SUCCESS, path);
+}
+
+}  // namespace
+
+void ScreenshotTakerClient::PrepareWritableFileAndRunOnBlockingPool(
+    const base::FilePath& path,
+    WritableFileCallback callback_on_blocking_pool) {
+  content::BrowserThread::GetBlockingPool()->PostTask(
+      FROM_HERE, base::Bind(EnsureLocalDirectoryExists,
+                            path,
+                            callback_on_blocking_pool));
+}
+
+ScreenshotTaker::ScreenshotTaker(ScreenshotTakerClient* client)
+    : client_(client),
+      factory_(this) {
+}
+
+ScreenshotTaker::~ScreenshotTaker() {
+}
+
+void ScreenshotTaker::TakeScreenshot(
+    aura::Window* window,
+    const gfx::Rect& rect,
+    const base::FilePath& screenshot_path) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  last_screenshot_timestamp_ = base::Time::Now();
+
+  bool is_partial = rect == window->bounds();
+  ui::GrabWindowSnapshotAsync(
+      window,
+      rect,
+      content::BrowserThread::GetBlockingPool(),
+      base::Bind(&ScreenshotTaker::GrabWindowSnapshotAsyncCallback,
+                 factory_.GetWeakPtr(),
+                 window->GetBoundsInScreen().ToString(),
+                 screenshot_path,
+                 is_partial));
+}
+
+bool ScreenshotTaker::CanTakeScreenshot() {
+  return last_screenshot_timestamp_.is_null() ||
+      base::Time::Now() - last_screenshot_timestamp_ >
+      base::TimeDelta::FromMilliseconds(
+          kScreenshotMinimumIntervalInMS);
+}
+
+void ScreenshotTaker::NotifyScreenshotCompleted(
+    ScreenshotTakerObserver::Result screenshot_result,
+    const base::FilePath& screenshot_path) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  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(
+    const std::string& screen_bounds,
+    base::FilePath screenshot_path,
+    bool is_partial,
+    scoped_refptr<base::RefCountedBytes> png_data) {
+  if (!png_data.get()) {
+    if (is_partial) {
+      LOG(ERROR) << "Failed to grab the window screenshot";
+      NotifyScreenshotCompleted(
+          ScreenshotTakerObserver::SCREENSHOT_GRABWINDOW_PARTIAL_FAILED,
+          screenshot_path);
+    } else {
+      LOG(ERROR) << "Failed to grab the window screenshot for "
+                 << screen_bounds;
+      NotifyScreenshotCompleted(
+          ScreenshotTakerObserver::SCREENSHOT_GRABWINDOW_FULL_FAILED,
+          screenshot_path);
+    }
+    return;
+  }
+
+  client_->PrepareWritableFileAndRunOnBlockingPool(
+      screenshot_path, base::Bind(
+          &SaveScreenshot,
+          base::Bind(&ScreenshotTaker::NotifyScreenshotCompleted,
+                     factory_.GetWeakPtr()),
+          screenshot_path,
+          png_data));
+}