Screenshot effect non-obvious

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"
 #include "ash/shell_delegate.h"
 #include "ash/shell_window_ids.h"
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/stringprintf.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/time.h"
+#include "base/utf_string_conversions.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/chromeos/extensions/file_manager_util.h"
 #include "chrome/browser/download/download_prefs.h"
+#include "chrome/browser/notifications/notification.h"
+#include "chrome/browser/notifications/notification_ui_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/webui/screenshot_source.h"
 #include "chrome/browser/ui/window_snapshot/window_snapshot.h"
 #include "content/public/browser/browser_thread.h"
+#include "grit/ash_strings.h"
+#include "grit/theme_resources.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
+#include "ui/base/l10n/l10n_util.h"
+#include "ui/base/resource/resource_bundle.h"
+#include "ui/gfx/image/image.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/drive/drive_file_system_util.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #endif
 
 namespace {
-// How opaque should the layer that we flash onscreen to provide visual
-// feedback after the screenshot is taken be?
-const float kVisualFeedbackLayerOpacity = 0.25f;
-
-// How long should the visual feedback layer be displayed?
-const int64 kVisualFeedbackLayerDisplayTimeMs = 100;
-
 // The minimum interval between two screenshot commands.  It has to be
 // more than 1000 to prevent the conflict of filenames.
 const int kScreenshotMinimumIntervalInMS = 1000;
 
+// Origin URL for notifications.
+const GURL kNotificationOriginUrl("chrome://screenshot/");
+
+// Mostly unchanging data used in notifications.
+struct NotificationData {
+  static void init() {
+    static bool is_init = false;
+    if (is_init)
+      return;
+    is_init = true;
+    notification_icon = ui::ResourceBundle::GetSharedInstance().GetImageNamed(

[James Cook, 2013/03/27 16:49:17]

Why not just look up these images and resources every time a notification is
shown?  This is a rarely-used feature - the performance penalty is unlikely to
matter.

[sschmitz, 2013/03/27 17:44:29]

Great. Makes it much simpler.
Done.

+        IDR_SCREENSHOT_NOTIFICATION_ICON);
+    notification_title_success = l10n_util::GetStringUTF16(
+        IDS_ASH_SCREENSHOT_NOTIFICATION_TITLE_SUCCESS);
+    notification_title_fail = l10n_util::GetStringUTF16(
+        IDS_ASH_SCREENSHOT_NOTIFICATION_TITLE_FAIL);
+    notification_text_success = l10n_util::GetStringUTF16(
+        IDS_ASH_SCREENSHOT_NOTIFICATION_TEXT_SUCCESS);
+    notification_text_fail = l10n_util::GetStringUTF16(
+        IDS_ASH_SCREENSHOT_NOTIFICATION_TEXT_FAIL);
+  }
+  static int notification_id;
+  static gfx::Image notification_icon;
+  static string16 notification_title_success;
+  static string16 notification_title_fail;
+  static string16 notification_text_success;
+  static string16 notification_text_fail;
+};
+int NotificationData::notification_id = 0;
+gfx::Image NotificationData::notification_icon;
+string16 NotificationData::notification_title_success;
+string16 NotificationData::notification_title_fail;
+string16 NotificationData::notification_text_success;
+string16 NotificationData::notification_text_fail;
+
+class ScreenshotTakerNotificationDelegate : public NotificationDelegate {
+ public:
+  ScreenshotTakerNotificationDelegate(const std::string& id_text,
+                                      bool success,
+                                      const base::FilePath& screenshot_path)
+      : id_text_(id_text),
+        success_(success),
+        screenshot_path_(screenshot_path) {
+  }
+
+  virtual void Display() OVERRIDE {}
+
+  virtual void Error() OVERRIDE {}
+
+  virtual void Close(bool by_user) OVERRIDE {}
+
+  virtual void Click() OVERRIDE {
+    if (success_)
+      file_manager_util::ShowFileInFolder(screenshot_path_);
+  }
+
+  virtual std::string id() const OVERRIDE { return id_text_; }
+
+  virtual content::RenderViewHost* GetRenderViewHost() const OVERRIDE {
+    return NULL;
+  }
+
+ private:
+  virtual ~ScreenshotTakerNotificationDelegate() {}
+
+  std::string id_text_;
+  bool success_;
+  base::FilePath screenshot_path_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScreenshotTakerNotificationDelegate);
+};
+
+void ShowNotification(bool success, const base::FilePath& screenshot_path) {

[James Cook, 2013/03/27 16:49:17]

If you pass notification_id in here and look up the strings every time I think
you don't need the struct at all.

[sschmitz, 2013/03/27 17:44:29]

Decided to use static int id inside ShowNotification. That limits the scope and
requires fewer changes to existing code. Otherwise, we would have to pass the id
through many calls. Decided not to use the file-path as id because conversion to
std::string is OS dependent. This is simpler.

+#if defined(OS_CHROMEOS)
+  // Notifications only on Chrome OS.
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  NotificationData::init();
+  std::string id_text =
+      base::StringPrintf("screenshot_%3.3d",
+                         ++NotificationData::notification_id);
+  string16 notification_replace_id = UTF8ToUTF16(id_text);
+  Notification notification(
+      kNotificationOriginUrl,
+      NotificationData::notification_icon,
+      success ? NotificationData::notification_title_success :
+                NotificationData::notification_title_fail,
+      success ? NotificationData::notification_text_success :
+                NotificationData::notification_text_fail,
+      WebKit::WebTextDirectionDefault,
+      string16(), // display_source
+      notification_replace_id,
+      new ScreenshotTakerNotificationDelegate(id_text,
+                                              success,
+                                              screenshot_path));
+  Profile* profile = ProfileManager::GetDefaultProfileOrOffTheRecord();
+  DCHECK(profile);
+  DCHECK(g_browser_process);
+  g_browser_process->notification_ui_manager()->Add(notification, profile);
+#endif
+}
+
+void PostNotification(bool success, const base::FilePath& screenshot_path) {
+  content::BrowserThread::PostTask(
+      content::BrowserThread::UI, FROM_HERE,
+      base::Bind(&ShowNotification, success, screenshot_path));
+}
 
 void SaveScreenshotInternal(const base::FilePath& screenshot_path,
                             scoped_refptr<base::RefCountedBytes> png_data) {
   DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
   DCHECK(!screenshot_path.empty());
+  bool success = true;
   if (static_cast<size_t>(file_util::WriteFile(
           screenshot_path,
           reinterpret_cast<char*>(&(png_data->data()[0])),
           png_data->size())) != png_data->size()) {
     LOG(ERROR) << "Failed to save to " << screenshot_path.value();
+    success = false;
   }
+  PostNotification(success, screenshot_path);
 }
 
 void SaveScreenshot(const base::FilePath& screenshot_path,
                     scoped_refptr<base::RefCountedBytes> png_data) {
   DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
   DCHECK(!screenshot_path.empty());
 
   if (!file_util::CreateDirectory(screenshot_path.DirName())) {
     LOG(ERROR) << "Failed to ensure the existence of "
                << screenshot_path.DirName().value();
+    PostNotification(false, screenshot_path);
     return;
   }
   SaveScreenshotInternal(screenshot_path, png_data);
 }
 
 // TODO(kinaba): crbug.com/140425, remove this ungly #ifdef dispatch.
 #if defined(OS_CHROMEOS)
 void SaveScreenshotToDrive(scoped_refptr<base::RefCountedBytes> png_data,
                            drive::DriveFileError error,
                            const base::FilePath& local_path) {
   if (error != drive::DRIVE_FILE_OK) {
     LOG(ERROR) << "Failed to write screenshot image to Google Drive: " << error;
+    PostNotification(false, local_path);
     return;
   }
   SaveScreenshotInternal(local_path, png_data);
 }
 
 void EnsureDirectoryExistsCallback(
     Profile* profile,
     const base::FilePath& screenshot_path,
     scoped_refptr<base::RefCountedBytes> png_data,
     drive::DriveFileError error) {
   // It is okay to fail with DRIVE_FILE_ERROR_EXISTS since anyway the directory
   // of the target file exists.
   if (error == drive::DRIVE_FILE_OK ||
       error == drive::DRIVE_FILE_ERROR_EXISTS) {
+    // Note: The last two arguments of SaveScreenshotToDrive are appended by
+    // PrepareWritableFileAndRun.
     drive::util::PrepareWritableFileAndRun(
         profile,
         screenshot_path,
         base::Bind(&SaveScreenshotToDrive, png_data));
   } else {
     LOG(ERROR) << "Failed to ensure the existence of the specified directory "
                << "in Google Drive: " << error;
+    PostNotification(false, screenshot_path);
   }
 }
 
 void PostSaveScreenshotTask(const base::FilePath& screenshot_path,
                             scoped_refptr<base::RefCountedBytes> png_data) {
   if (drive::util::IsUnderDriveMountPoint(screenshot_path)) {
     Profile* profile = ProfileManager::GetDefaultProfileOrOffTheRecord();
     if (profile) {
+      // Note: The last argument of EnsureDirectoryExistsCallback is
+      // appended by EnsureDirectoryExists.
       drive::util::EnsureDirectoryExists(
           profile,
           screenshot_path.DirName(),
           base::Bind(&EnsureDirectoryExistsCallback,
                      profile,
                      screenshot_path,
                      png_data));
     }
   } else {
     content::BrowserThread::GetBlockingPool()->PostTask(
@@ skipping 50 matching lines @@
         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::RootWindow* 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())) {
-      DisplayVisualFeedback(rect);
-      PostSaveScreenshotTask(
-          screenshot_directory.AppendASCII(basename + ".png"), png_data);
+      PostSaveScreenshotTask(screenshot_path, png_data);
     } else {
       LOG(ERROR) << "Failed to grab the window screenshot for " << i;
+      ShowNotification(false, screenshot_path);
     }
   }
   last_screenshot_timestamp_ = base::Time::Now();
 }
 
 void ScreenshotTaker::HandleTakePartialScreenshot(
     aura::Window* window, const gfx::Rect& rect) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   base::FilePath screenshot_directory;
   if (!ScreenshotSource::GetScreenshotDirectory(&screenshot_directory))
     return;
 
   scoped_refptr<base::RefCountedBytes> png_data(new base::RefCountedBytes);
 
+  base::FilePath screenshot_path =
+      screenshot_directory.AppendASCII(
+          ScreenshotSource::GetScreenshotBaseFilename() + ".png");
   if (GrabWindowSnapshot(window, rect, &png_data->data())) {
     last_screenshot_timestamp_ = base::Time::Now();
-    DisplayVisualFeedback(rect);
-    PostSaveScreenshotTask(
-        screenshot_directory.AppendASCII(
-                   ScreenshotSource::GetScreenshotBaseFilename() + ".png"),
-                   png_data);
+    PostSaveScreenshotTask(screenshot_path, png_data);
   } else {
     LOG(ERROR) << "Failed to grab the window screenshot";
+    ShowNotification(false, screenshot_path);
   }
 }
 
 bool ScreenshotTaker::CanTakeScreenshot() {
   return last_screenshot_timestamp_.is_null() ||
       base::Time::Now() - last_screenshot_timestamp_ >
       base::TimeDelta::FromMilliseconds(
           kScreenshotMinimumIntervalInMS);
 }
-
-void ScreenshotTaker::CloseVisualFeedbackLayer() {
-  visual_feedback_layer_.reset();
-}
-
-void ScreenshotTaker::DisplayVisualFeedback(const gfx::Rect& rect) {
-  visual_feedback_layer_.reset(new ui::Layer(ui::LAYER_SOLID_COLOR));
-  visual_feedback_layer_->SetColor(SK_ColorWHITE);
-  visual_feedback_layer_->SetOpacity(kVisualFeedbackLayerOpacity);
-  visual_feedback_layer_->SetBounds(rect);
-
-  ui::Layer* parent = ash::Shell::GetContainer(
-      ash::Shell::GetActiveRootWindow(),
-      ash::internal::kShellWindowId_OverlayContainer)->layer();
-  parent->Add(visual_feedback_layer_.get());
-  visual_feedback_layer_->SetVisible(true);
-
-  MessageLoopForUI::current()->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&ScreenshotTaker::CloseVisualFeedbackLayer,
-                 base::Unretained(this)),
-      base::TimeDelta::FromMilliseconds(kVisualFeedbackLayerDisplayTimeMs));
-}