src/chrome/browser/ui/ash/screenshot_taker.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/ash/screenshot_taker.h"
   6
   7 #include <climits>
   8 #include <string>
   9
  10 #include "ash/shell.h"
  11 #include "ash/shell_delegate.h"
  12 #include "ash/system/system_notifier.h"
  13 #include "base/base64.h"
  14 #include "base/bind.h"
  15 #include "base/files/file_util.h"
  16 #include "base/i18n/time_formatting.h"
  17 #include "base/logging.h"
  18 #include "base/memory/ref_counted_memory.h"
  19 #include "base/prefs/pref_service.h"
  20 #include "base/strings/stringprintf.h"
  21 #include "base/strings/utf_string_conversions.h"
  22 #include "base/threading/sequenced_worker_pool.h"
  23 #include "base/time/time.h"
  24 #include "chrome/browser/browser_process.h"
  25 #include "chrome/browser/download/download_prefs.h"
  26 #include "chrome/browser/notifications/notification_ui_manager.h"
  27 #include "chrome/browser/profiles/profile.h"
  28 #include "chrome/browser/profiles/profile_manager.h"
  29 #include "chrome/common/pref_names.h"
  30 #include "content/public/browser/browser_thread.h"
  31 #include "content/public/browser/user_metrics.h"
  32 #include "grit/ash_strings.h"
  33 #include "grit/theme_resources.h"
  34 #include "ui/aura/window.h"
  35 #include "ui/aura/window_event_dispatcher.h"
  36 #include "ui/base/clipboard/clipboard.h"
  37 #include "ui/base/clipboard/scoped_clipboard_writer.h"
  38 #include "ui/base/l10n/l10n_util.h"
  39 #include "ui/base/resource/resource_bundle.h"
  40 #include "ui/gfx/image/image.h"
  41 #include "ui/snapshot/snapshot.h"
  42 #include "ui/strings/grit/ui_strings.h"
  43
  44 #if defined(OS_CHROMEOS)
  45 #include "chrome/browser/chromeos/drive/file_system_interface.h"
  46 #include "chrome/browser/chromeos/drive/file_system_util.h"
  47 #include "chrome/browser/chromeos/file_manager/open_util.h"
  48 #include "chrome/browser/notifications/desktop_notification_service.h"
  49 #include "chrome/browser/notifications/desktop_notification_service_factory.h"
  50 #include "chromeos/login/login_state.h"
  51 #endif
  52
  53 namespace {
  54 // The minimum interval between two screenshot commands.  It has to be
  55 // more than 1000 to prevent the conflict of filenames.
  56 const int kScreenshotMinimumIntervalInMS = 1000;
  57
  58 const char kNotificationId[] = "screenshot";
  59
  60 #if defined(OS_CHROMEOS)
  61 const char kNotificationOriginUrl[] = "chrome://screenshot";
  62 #endif
  63
  64 const char kImageClipboardFormatPrefix[] = "<img src='data:image/png;base64,";
  65 const char kImageClipboardFormatSuffix[] = "'>";
  66
  67 void CopyScreenshotToClipboard(scoped_refptr<base::RefCountedString> png_data) {
  68   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
  69
  70   std::string encoded;
  71   base::Base64Encode(png_data->data(), &encoded);
  72
  73   // Only cares about HTML because ChromeOS doesn't need other formats.
  74   // TODO(dcheng): Why don't we take advantage of the ability to write bitmaps
  75   // to the clipboard here?
  76   {
  77     ui::ScopedClipboardWriter scw(ui::CLIPBOARD_TYPE_COPY_PASTE);
  78     std::string html(kImageClipboardFormatPrefix);
  79     html += encoded;
  80     html += kImageClipboardFormatSuffix;
  81     scw.WriteHTML(base::UTF8ToUTF16(html), std::string());
  82   }
  83   content::RecordAction(base::UserMetricsAction("Screenshot_CopyClipboard"));
  84 }
  85
  86 void ReadFileAndCopyToClipboardLocal(const base::FilePath& screenshot_path) {
  87   DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
  88
  89   scoped_refptr<base::RefCountedString> png_data(new base::RefCountedString());
  90   if (!base::ReadFileToString(screenshot_path, &(png_data->data()))) {
  91     LOG(ERROR) << "Failed to read the screenshot file: "
  92                << screenshot_path.value();
  93     return;
  94   }
  95
  96   content::BrowserThread::PostTask(
  97       content::BrowserThread::UI, FROM_HERE,
  98       base::Bind(CopyScreenshotToClipboard, png_data));
  99 }
 100
 101 #if defined(OS_CHROMEOS)
 102 void ReadFileAndCopyToClipboardDrive(drive::FileError error,
 103                                      const base::FilePath& file_path,
 104                                      scoped_ptr<drive::ResourceEntry> entry) {
 105   if (error != drive::FILE_ERROR_OK) {
 106     LOG(ERROR) << "Failed to read the screenshot path on drive: "
 107                << drive::FileErrorToString(error);
 108     return;
 109   }
 110   content::BrowserThread::GetBlockingPool()->PostTask(
 111       FROM_HERE,
 112       base::Bind(&ReadFileAndCopyToClipboardLocal, file_path));
 113 }
 114 #endif
 115
 116 // Delegate for a notification. This class has two roles: to implement callback
 117 // methods for notification, and to provide an identity of the associated
 118 // notification.
 119 class ScreenshotTakerNotificationDelegate : public NotificationDelegate {
 120  public:
 121   ScreenshotTakerNotificationDelegate(bool success,
 122                                       Profile* profile,
 123                                       const base::FilePath& screenshot_path)
 124       : success_(success),
 125         profile_(profile),
 126         screenshot_path_(screenshot_path) {
 127   }
 128
 129   // Overridden from NotificationDelegate:
 130   virtual void Display() OVERRIDE {}
 131   virtual void Error() OVERRIDE {}
 132   virtual void Close(bool by_user) OVERRIDE {}
 133   virtual void Click() OVERRIDE {
 134     if (!success_)
 135       return;
 136 #if defined(OS_CHROMEOS)
 137     file_manager::util::ShowItemInFolder(profile_, screenshot_path_);
 138 #else
 139     // TODO(sschmitz): perhaps add similar action for Windows.
 140 #endif
 141   }
 142   virtual void ButtonClick(int button_index) OVERRIDE {
 143     DCHECK(success_ && button_index == 0);
 144
 145     // To avoid keeping the screenshot image on memory, it will re-read the
 146     // screenshot file and copy it to the clipboard.
 147 #if defined(OS_CHROMEOS)
 148   if (drive::util::IsUnderDriveMountPoint(screenshot_path_)) {
 149     drive::FileSystemInterface* file_system =
 150         drive::util::GetFileSystemByProfile(profile_);
 151     file_system->GetFile(
 152         drive::util::ExtractDrivePath(screenshot_path_),
 153         base::Bind(&ReadFileAndCopyToClipboardDrive));
 154     return;
 155   }
 156 #endif
 157     content::BrowserThread::GetBlockingPool()->PostTask(
 158         FROM_HERE, base::Bind(
 159             &ReadFileAndCopyToClipboardLocal, screenshot_path_));
 160   }
 161   virtual bool HasClickedListener() OVERRIDE { return success_; }
 162   virtual std::string id() const OVERRIDE {
 163     return std::string(kNotificationId);
 164   }
 165   virtual content::WebContents* GetWebContents() const OVERRIDE {
 166     return NULL;
 167   }
 168
 169  private:
 170   virtual ~ScreenshotTakerNotificationDelegate() {}
 171
 172   const bool success_;
 173   Profile* profile_;
 174   const base::FilePath screenshot_path_;
 175
 176   DISALLOW_COPY_AND_ASSIGN(ScreenshotTakerNotificationDelegate);
 177 };
 178
 179 typedef base::Callback<
 180   void(ScreenshotTakerObserver::Result screenshot_result,
 181        const base::FilePath& screenshot_path)> ShowNotificationCallback;
 182
 183 void SaveScreenshotInternal(const ShowNotificationCallback& callback,
 184                             const base::FilePath& screenshot_path,
 185                             const base::FilePath& local_path,
 186                             scoped_refptr<base::RefCountedBytes> png_data) {
 187   DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
 188   DCHECK(!local_path.empty());
 189   ScreenshotTakerObserver::Result result =
 190       ScreenshotTakerObserver::SCREENSHOT_SUCCESS;
 191   if (static_cast<size_t>(base::WriteFile(
 192           local_path,
 193           reinterpret_cast<char*>(&(png_data->data()[0])),
 194           png_data->size())) != png_data->size()) {
 195     LOG(ERROR) << "Failed to save to " << local_path.value();
 196     result = ScreenshotTakerObserver::SCREENSHOT_WRITE_FILE_FAILED;
 197   }
 198   content::BrowserThread::PostTask(
 199       content::BrowserThread::UI, FROM_HERE,
 200       base::Bind(callback, result, screenshot_path));
 201 }
 202
 203 void SaveScreenshot(const ShowNotificationCallback& callback,
 204                     const base::FilePath& screenshot_path,
 205                     scoped_refptr<base::RefCountedBytes> png_data) {
 206   DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
 207   DCHECK(!screenshot_path.empty());
 208
 209   if (!base::CreateDirectory(screenshot_path.DirName())) {
 210     LOG(ERROR) << "Failed to ensure the existence of "
 211                << screenshot_path.DirName().value();
 212     content::BrowserThread::PostTask(
 213         content::BrowserThread::UI, FROM_HERE,
 214         base::Bind(callback,
 215                    ScreenshotTakerObserver::SCREENSHOT_CREATE_DIR_FAILED,
 216                    screenshot_path));
 217     return;
 218   }
 219   SaveScreenshotInternal(callback, screenshot_path, screenshot_path, png_data);
 220 }
 221
 222 // TODO(kinaba): crbug.com/140425, remove this ungly #ifdef dispatch.
 223 #if defined(OS_CHROMEOS)
 224 void SaveScreenshotToDrive(const ShowNotificationCallback& callback,
 225                            const base::FilePath& screenshot_path,
 226                            scoped_refptr<base::RefCountedBytes> png_data,
 227                            drive::FileError error,
 228                            const base::FilePath& local_path) {
 229   // |screenshot_path| is used in the notification callback.
 230   // |local_path| is a temporary file in a hidden cache directory used for
 231   // internal work generated by drive::util::PrepareWritableFileAndRun.
 232   if (error != drive::FILE_ERROR_OK) {
 233     LOG(ERROR) << "Failed to write screenshot image to Google Drive: " << error;
 234     content::BrowserThread::PostTask(
 235         content::BrowserThread::UI, FROM_HERE,
 236         base::Bind(callback,
 237                    ScreenshotTakerObserver::SCREENSHOT_CREATE_FILE_FAILED,
 238                    screenshot_path));
 239     return;
 240   }
 241   SaveScreenshotInternal(callback, screenshot_path, local_path, png_data);
 242 }
 243
 244 void EnsureDirectoryExistsCallback(
 245     const ShowNotificationCallback& callback,
 246     Profile* profile,
 247     const base::FilePath& screenshot_path,
 248     scoped_refptr<base::RefCountedBytes> png_data,
 249     drive::FileError error) {
 250   // It is okay to fail with FILE_ERROR_EXISTS since anyway the directory
 251   // of the target file exists.
 252   if (error == drive::FILE_ERROR_OK ||
 253       error == drive::FILE_ERROR_EXISTS) {
 254     drive::util::PrepareWritableFileAndRun(
 255         profile,
 256         screenshot_path,
 257         base::Bind(&SaveScreenshotToDrive,
 258                    callback,
 259                    screenshot_path,
 260                    png_data));
 261   } else {
 262     LOG(ERROR) << "Failed to ensure the existence of the specified directory "
 263                << "in Google Drive: " << error;
 264     callback.Run(ScreenshotTakerObserver::SCREENSHOT_CHECK_DIR_FAILED,
 265                  screenshot_path);
 266   }
 267 }
 268
 269 void PostSaveScreenshotTask(const ShowNotificationCallback& callback,
 270                             Profile* profile,
 271                             const base::FilePath& screenshot_path,
 272                             scoped_refptr<base::RefCountedBytes> png_data) {
 273   if (drive::util::IsUnderDriveMountPoint(screenshot_path)) {
 274     drive::util::EnsureDirectoryExists(
 275         profile,
 276         screenshot_path.DirName(),
 277         base::Bind(&EnsureDirectoryExistsCallback,
 278                    callback,
 279                    profile,
 280                    screenshot_path,
 281                    png_data));
 282   } else {
 283     content::BrowserThread::GetBlockingPool()->PostTask(
 284         FROM_HERE, base::Bind(&SaveScreenshot,
 285                               callback,
 286                               screenshot_path,
 287                               png_data));
 288   }
 289 }
 290 #else
 291 void PostSaveScreenshotTask(const ShowNotificationCallback& callback,
 292                             Profile* profile,
 293                             const base::FilePath& screenshot_path,
 294                             scoped_refptr<base::RefCountedBytes> png_data) {
 295   content::BrowserThread::GetBlockingPool()->PostTask(
 296       FROM_HERE, base::Bind(&SaveScreenshot,
 297                             callback,
 298                             screenshot_path,
 299                             png_data));
 300 }
 301 #endif
 302
 303 bool ShouldUse24HourClock() {
 304 #if defined(OS_CHROMEOS)
 305   Profile* profile = ProfileManager::GetActiveUserProfile();
 306   if (profile) {
 307     return profile->GetPrefs()->GetBoolean(prefs::kUse24HourClock);
 308   }
 309 #endif
 310   return base::GetHourClockType() == base::k24HourClock;
 311 }
 312
 313 std::string GetScreenshotBaseFilename() {
 314   base::Time::Exploded now;
 315   base::Time::Now().LocalExplode(&now);
 316
 317   // We don't use base/i18n/time_formatting.h here because it doesn't
 318   // support our format.  Don't use ICU either to avoid i18n file names
 319   // for non-English locales.
 320   // TODO(mukai): integrate this logic somewhere time_formatting.h
 321   std::string file_name = base::StringPrintf(
 322       "Screenshot %d-%02d-%02d at ", now.year, now.month, now.day_of_month);
 323
 324   if (ShouldUse24HourClock()) {
 325     file_name.append(base::StringPrintf(
 326         "%02d.%02d.%02d", now.hour, now.minute, now.second));
 327   } else {
 328     int hour = now.hour;
 329     if (hour > 12) {
 330       hour -= 12;
 331     } else if (hour == 0) {
 332       hour = 12;
 333     }
 334     file_name.append(base::StringPrintf(
 335         "%d.%02d.%02d ", hour, now.minute, now.second));
 336     file_name.append((now.hour >= 12) ? "PM" : "AM");
 337   }
 338
 339   return file_name;
 340 }
 341
 342 bool GetScreenshotDirectory(base::FilePath* directory) {
 343   bool is_logged_in = true;
 344
 345 #if defined(OS_CHROMEOS)
 346   is_logged_in = chromeos::LoginState::Get()->IsUserLoggedIn();
 347 #endif
 348
 349   if (is_logged_in) {
 350     DownloadPrefs* download_prefs = DownloadPrefs::FromBrowserContext(
 351         ProfileManager::GetActiveUserProfile());
 352     *directory = download_prefs->DownloadPath();
 353   } else  {
 354     if (!base::GetTempDir(directory)) {
 355       LOG(ERROR) << "Failed to find temporary directory.";
 356       return false;
 357     }
 358   }
 359   return true;
 360 }
 361
 362 #if defined(OS_CHROMEOS)
 363 const int GetScreenshotNotificationTitle(
 364     ScreenshotTakerObserver::Result screenshot_result) {
 365   switch (screenshot_result) {
 366     case ScreenshotTakerObserver::SCREENSHOTS_DISABLED:
 367       return IDS_ASH_SCREENSHOT_NOTIFICATION_TITLE_DISABLED;
 368     case ScreenshotTakerObserver::SCREENSHOT_SUCCESS:
 369       return IDS_ASH_SCREENSHOT_NOTIFICATION_TITLE_SUCCESS;
 370     default:
 371       return IDS_ASH_SCREENSHOT_NOTIFICATION_TITLE_FAIL;
 372   }
 373 }
 374
 375 const int GetScreenshotNotificationText(
 376     ScreenshotTakerObserver::Result screenshot_result) {
 377   switch (screenshot_result) {
 378     case ScreenshotTakerObserver::SCREENSHOTS_DISABLED:
 379       return IDS_ASH_SCREENSHOT_NOTIFICATION_TEXT_DISABLED;
 380     case ScreenshotTakerObserver::SCREENSHOT_SUCCESS:
 381       return IDS_ASH_SCREENSHOT_NOTIFICATION_TEXT_SUCCESS;
 382     default:
 383       return IDS_ASH_SCREENSHOT_NOTIFICATION_TEXT_FAIL;
 384   }
 385 }
 386 #endif
 387
 388 }  // namespace
 389
 390 ScreenshotTaker::ScreenshotTaker()
 391     : profile_for_test_(NULL),
 392       factory_(this) {
 393 }
 394
 395 ScreenshotTaker::~ScreenshotTaker() {
 396 }
 397
 398 void ScreenshotTaker::HandleTakeScreenshotForAllRootWindows() {
 399   if (g_browser_process->local_state()->
 400           GetBoolean(prefs::kDisableScreenshots)) {
 401     ShowNotification(ScreenshotTakerObserver::SCREENSHOTS_DISABLED,
 402                      base::FilePath());
 403     return;
 404   }
 405   base::FilePath screenshot_directory;
 406   if (!screenshot_directory_for_test_.empty()) {
 407     screenshot_directory = screenshot_directory_for_test_;
 408   } else if (!GetScreenshotDirectory(&screenshot_directory)) {
 409     ShowNotification(ScreenshotTakerObserver::SCREENSHOT_GET_DIR_FAILED,
 410                      base::FilePath());
 411     return;
 412   }
 413   std::string screenshot_basename = !screenshot_basename_for_test_.empty() ?
 414       screenshot_basename_for_test_ : GetScreenshotBaseFilename();
 415
 416   aura::Window::Windows root_windows = ash::Shell::GetAllRootWindows();
 417   // Reorder root_windows to take the primary root window's snapshot at first.
 418   aura::Window* primary_root = ash::Shell::GetPrimaryRootWindow();
 419   if (*(root_windows.begin()) != primary_root) {
 420     root_windows.erase(std::find(
 421         root_windows.begin(), root_windows.end(), primary_root));
 422     root_windows.insert(root_windows.begin(), primary_root);
 423   }
 424   for (size_t i = 0; i < root_windows.size(); ++i) {
 425     aura::Window* root_window = root_windows[i];
 426     std::string basename = screenshot_basename;
 427     gfx::Rect rect = root_window->bounds();
 428     if (root_windows.size() > 1)
 429       basename += base::StringPrintf(" - Display %d", static_cast<int>(i + 1));
 430     base::FilePath screenshot_path =
 431         screenshot_directory.AppendASCII(basename + ".png");
 432     GrabFullWindowSnapshotAsync(
 433         root_window, rect, GetProfile(), screenshot_path, i);
 434   }
 435   content::RecordAction(base::UserMetricsAction("Screenshot_TakeFull"));
 436 }
 437
 438 void ScreenshotTaker::HandleTakePartialScreenshot(
 439     aura::Window* window, const gfx::Rect& rect) {
 440   if (g_browser_process->local_state()->
 441           GetBoolean(prefs::kDisableScreenshots)) {
 442     ShowNotification(ScreenshotTakerObserver::SCREENSHOTS_DISABLED,
 443                      base::FilePath());
 444     return;
 445   }
 446   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 447
 448   base::FilePath screenshot_directory;
 449   if (!screenshot_directory_for_test_.empty()) {
 450     screenshot_directory = screenshot_directory_for_test_;
 451   } else if (!GetScreenshotDirectory(&screenshot_directory)) {
 452     ShowNotification(ScreenshotTakerObserver::SCREENSHOT_GET_DIR_FAILED,
 453                      base::FilePath());
 454     return;
 455   }
 456
 457   std::string screenshot_basename = !screenshot_basename_for_test_.empty() ?
 458       screenshot_basename_for_test_ : GetScreenshotBaseFilename();
 459   base::FilePath screenshot_path =
 460       screenshot_directory.AppendASCII(screenshot_basename + ".png");
 461   GrabPartialWindowSnapshotAsync(window, rect, GetProfile(), screenshot_path);
 462   content::RecordAction(base::UserMetricsAction("Screenshot_TakePartial"));
 463 }
 464
 465 bool ScreenshotTaker::CanTakeScreenshot() {
 466   return last_screenshot_timestamp_.is_null() ||
 467       base::Time::Now() - last_screenshot_timestamp_ >
 468       base::TimeDelta::FromMilliseconds(
 469           kScreenshotMinimumIntervalInMS);
 470 }
 471
 472 #if defined(OS_CHROMEOS)
 473 Notification* ScreenshotTaker::CreateNotification(
 474     ScreenshotTakerObserver::Result screenshot_result,
 475     const base::FilePath& screenshot_path) {
 476   const std::string notification_id(kNotificationId);
 477   // We cancel a previous screenshot notification, if any, to ensure we get
 478   // a fresh notification pop-up.
 479   g_browser_process->notification_ui_manager()->CancelById(notification_id);
 480   const base::string16 replace_id(base::UTF8ToUTF16(notification_id));
 481   bool success =
 482       (screenshot_result == ScreenshotTakerObserver::SCREENSHOT_SUCCESS);
 483   message_center::RichNotificationData optional_field;
 484   if (success) {
 485     const base::string16 label = l10n_util::GetStringUTF16(
 486         IDS_MESSAGE_CENTER_NOTIFICATION_BUTTON_COPY_SCREENSHOT_TO_CLIPBOARD);
 487     optional_field.buttons.push_back(message_center::ButtonInfo(label));
 488   }
 489   return new Notification(
 490       message_center::NOTIFICATION_TYPE_SIMPLE,
 491       GURL(kNotificationOriginUrl),
 492       l10n_util::GetStringUTF16(
 493           GetScreenshotNotificationTitle(screenshot_result)),
 494       l10n_util::GetStringUTF16(
 495           GetScreenshotNotificationText(screenshot_result)),
 496       ui::ResourceBundle::GetSharedInstance().GetImageNamed(
 497           IDR_SCREENSHOT_NOTIFICATION_ICON),
 498       blink::WebTextDirectionDefault,
 499       message_center::NotifierId(
 500           message_center::NotifierId::SYSTEM_COMPONENT,
 501           ash::system_notifier::kNotifierScreenshot),
 502       l10n_util::GetStringUTF16(IDS_MESSAGE_CENTER_NOTIFIER_SCREENSHOT_NAME),
 503       replace_id,
 504       optional_field,
 505       new ScreenshotTakerNotificationDelegate(
 506           success, GetProfile(), screenshot_path));
 507 }
 508 #endif
 509
 510 void ScreenshotTaker::ShowNotification(
 511     ScreenshotTakerObserver::Result screenshot_result,
 512     const base::FilePath& screenshot_path) {
 513   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 514 #if defined(OS_CHROMEOS)
 515   // Do not show a notification that a screenshot was taken while no user is
 516   // logged in, since it is confusing for the user to get a message about it
 517   // after he logs in (crbug.com/235217).
 518   if (!chromeos::LoginState::Get()->IsUserLoggedIn())
 519     return;
 520
 521   // TODO(sschmitz): make this work for Windows.
 522   DesktopNotificationService* const service =
 523       DesktopNotificationServiceFactory::GetForProfile(GetProfile());
 524   if (service->IsNotifierEnabled(message_center::NotifierId(
 525           message_center::NotifierId::SYSTEM_COMPONENT,
 526           ash::system_notifier::kNotifierScreenshot))) {
 527     scoped_ptr<Notification> notification(
 528         CreateNotification(screenshot_result, screenshot_path));
 529     g_browser_process->notification_ui_manager()->Add(*notification,
 530                                                       GetProfile());
 531   }
 532 #endif
 533   FOR_EACH_OBSERVER(ScreenshotTakerObserver, observers_,
 534                     OnScreenshotCompleted(screenshot_result, screenshot_path));
 535 }
 536
 537 void ScreenshotTaker::AddObserver(ScreenshotTakerObserver* observer) {
 538   observers_.AddObserver(observer);
 539 }
 540
 541 void ScreenshotTaker::RemoveObserver(ScreenshotTakerObserver* observer) {
 542   observers_.RemoveObserver(observer);
 543 }
 544
 545 bool ScreenshotTaker::HasObserver(ScreenshotTakerObserver* observer) const {
 546   return observers_.HasObserver(observer);
 547 }
 548
 549 void ScreenshotTaker::GrabWindowSnapshotAsyncCallback(
 550     base::FilePath screenshot_path,
 551     bool is_partial,
 552     int window_idx,
 553     scoped_refptr<base::RefCountedBytes> png_data) {
 554   if (!png_data.get()) {
 555     if (is_partial) {
 556       LOG(ERROR) << "Failed to grab the window screenshot";
 557       ShowNotification(
 558           ScreenshotTakerObserver::SCREENSHOT_GRABWINDOW_PARTIAL_FAILED,
 559           screenshot_path);
 560     } else {
 561       LOG(ERROR) << "Failed to grab the window screenshot for " << window_idx;
 562       ShowNotification(
 563           ScreenshotTakerObserver::SCREENSHOT_GRABWINDOW_FULL_FAILED,
 564           screenshot_path);
 565     }
 566     return;
 567   }
 568
 569   PostSaveScreenshotTask(
 570       base::Bind(&ScreenshotTaker::ShowNotification, factory_.GetWeakPtr()),
 571       GetProfile(),
 572       screenshot_path,
 573       png_data);
 574 }
 575
 576 void ScreenshotTaker::GrabPartialWindowSnapshotAsync(
 577     aura::Window* window,
 578     const gfx::Rect& snapshot_bounds,
 579     Profile* profile,
 580     base::FilePath screenshot_path) {
 581   last_screenshot_timestamp_ = base::Time::Now();
 582
 583   bool is_partial = true;
 584   int window_idx = -1;  // unused
 585   ui::GrabWindowSnapshotAsync(
 586       window,
 587       snapshot_bounds,
 588       content::BrowserThread::GetBlockingPool(),
 589       base::Bind(&ScreenshotTaker::GrabWindowSnapshotAsyncCallback,
 590                  factory_.GetWeakPtr(),
 591                  screenshot_path,
 592                  is_partial,
 593                  window_idx));
 594 }
 595
 596 void ScreenshotTaker::GrabFullWindowSnapshotAsync(
 597     aura::Window* window,
 598     const gfx::Rect& snapshot_bounds,
 599     Profile* profile,
 600     base::FilePath screenshot_path,
 601     int window_idx) {
 602   last_screenshot_timestamp_ = base::Time::Now();
 603
 604   bool is_partial = false;
 605   ui::GrabWindowSnapshotAsync(
 606       window,
 607       snapshot_bounds,
 608       content::BrowserThread::GetBlockingPool(),
 609       base::Bind(&ScreenshotTaker::GrabWindowSnapshotAsyncCallback,
 610                  factory_.GetWeakPtr(),
 611                  screenshot_path,
 612                  is_partial,
 613                  window_idx));
 614 }
 615
 616 Profile* ScreenshotTaker::GetProfile() {
 617   if (profile_for_test_)
 618     return profile_for_test_;
 619   return ProfileManager::GetActiveUserProfile();
 620 }
 621
 622 void ScreenshotTaker::SetScreenshotDirectoryForTest(
 623     const base::FilePath& directory) {
 624   screenshot_directory_for_test_ = directory;
 625 }
 626
 627 void ScreenshotTaker::SetScreenshotBasenameForTest(
 628     const std::string& basename) {
 629   screenshot_basename_for_test_ = basename;
 630 }
 631
 632 void ScreenshotTaker::SetScreenshotProfileForTest(Profile* profile) {
 633   profile_for_test_ = profile;
 634 }