OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/ui/ash/screenshot_taker.h" | 5 #include "chrome/browser/ui/ash/screenshot_taker.h" |
6 | 6 |
7 #include <climits> | 7 #include <climits> |
8 #include <string> | 8 #include <string> |
9 | 9 |
10 #include "ash/shell.h" | 10 #include "ash/shell.h" |
11 #include "ash/shell_delegate.h" | |
12 #include "ash/shell_window_ids.h" | |
13 #include "base/bind.h" | 11 #include "base/bind.h" |
14 #include "base/file_util.h" | 12 #include "base/file_util.h" |
15 #include "base/files/file_path.h" | |
16 #include "base/logging.h" | 13 #include "base/logging.h" |
17 #include "base/memory/ref_counted_memory.h" | 14 #include "base/memory/ref_counted_memory.h" |
18 #include "base/stringprintf.h" | 15 #include "base/stringprintf.h" |
19 #include "base/threading/sequenced_worker_pool.h" | 16 #include "base/threading/sequenced_worker_pool.h" |
20 #include "base/time.h" | 17 #include "base/time.h" |
| 18 #include "base/utf_string_conversions.h" |
| 19 #include "chrome/browser/browser_process.h" |
| 20 #include "chrome/browser/chromeos/extensions/file_manager_util.h" |
21 #include "chrome/browser/download/download_prefs.h" | 21 #include "chrome/browser/download/download_prefs.h" |
| 22 #include "chrome/browser/notifications/notification.h" |
| 23 #include "chrome/browser/notifications/notification_ui_manager.h" |
22 #include "chrome/browser/profiles/profile.h" | 24 #include "chrome/browser/profiles/profile.h" |
23 #include "chrome/browser/profiles/profile_manager.h" | |
24 #include "chrome/browser/ui/webui/screenshot_source.h" | 25 #include "chrome/browser/ui/webui/screenshot_source.h" |
25 #include "chrome/browser/ui/window_snapshot/window_snapshot.h" | 26 #include "chrome/browser/ui/window_snapshot/window_snapshot.h" |
26 #include "content/public/browser/browser_thread.h" | 27 #include "content/public/browser/browser_thread.h" |
| 28 #include "grit/ash_strings.h" |
| 29 #include "grit/theme_resources.h" |
27 #include "ui/aura/root_window.h" | 30 #include "ui/aura/root_window.h" |
28 #include "ui/aura/window.h" | 31 #include "ui/aura/window.h" |
| 32 #include "ui/base/l10n/l10n_util.h" |
| 33 #include "ui/base/resource/resource_bundle.h" |
| 34 #include "ui/gfx/image/image.h" |
29 | 35 |
30 #if defined(OS_CHROMEOS) | 36 #if defined(OS_CHROMEOS) |
31 #include "chrome/browser/chromeos/drive/drive_file_system_util.h" | 37 #include "chrome/browser/chromeos/drive/drive_file_system_util.h" |
32 #include "chrome/browser/chromeos/login/user_manager.h" | 38 #include "chrome/browser/chromeos/login/user_manager.h" |
33 #endif | 39 #endif |
34 | 40 |
35 namespace { | 41 namespace { |
36 // How opaque should the layer that we flash onscreen to provide visual | |
37 // feedback after the screenshot is taken be? | |
38 const float kVisualFeedbackLayerOpacity = 0.25f; | |
39 | |
40 // How long should the visual feedback layer be displayed? | |
41 const int64 kVisualFeedbackLayerDisplayTimeMs = 100; | |
42 | |
43 // The minimum interval between two screenshot commands. It has to be | 42 // The minimum interval between two screenshot commands. It has to be |
44 // more than 1000 to prevent the conflict of filenames. | 43 // more than 1000 to prevent the conflict of filenames. |
45 const int kScreenshotMinimumIntervalInMS = 1000; | 44 const int kScreenshotMinimumIntervalInMS = 1000; |
46 | 45 |
| 46 const char kNotificationOriginUrl[] = "chrome://screenshot"; |
47 | 47 |
48 void SaveScreenshotInternal(const base::FilePath& screenshot_path, | 48 // Delegate for a notification. This class has two roles: to implement callback |
| 49 // methods for notification, and to provide an identity of the associated |
| 50 // notification. |
| 51 class ScreenshotTakerNotificationDelegate : public NotificationDelegate { |
| 52 public: |
| 53 ScreenshotTakerNotificationDelegate(const std::string& id_text, |
| 54 bool success, |
| 55 const base::FilePath& screenshot_path) |
| 56 : id_text_(id_text), |
| 57 success_(success), |
| 58 screenshot_path_(screenshot_path) { |
| 59 } |
| 60 |
| 61 // Overridden from NotificationDelegate: |
| 62 virtual void Display() OVERRIDE {} |
| 63 virtual void Error() OVERRIDE {} |
| 64 virtual void Close(bool by_user) OVERRIDE {} |
| 65 virtual void Click() OVERRIDE { |
| 66 if (success_) |
| 67 file_manager_util::ShowFileInFolder(screenshot_path_); |
| 68 } |
| 69 virtual std::string id() const OVERRIDE { return id_text_; } |
| 70 virtual content::RenderViewHost* GetRenderViewHost() const OVERRIDE { |
| 71 return NULL; |
| 72 } |
| 73 |
| 74 private: |
| 75 virtual ~ScreenshotTakerNotificationDelegate() {} |
| 76 |
| 77 const std::string id_text_; |
| 78 const bool success_; |
| 79 const base::FilePath screenshot_path_; |
| 80 |
| 81 DISALLOW_COPY_AND_ASSIGN(ScreenshotTakerNotificationDelegate); |
| 82 }; |
| 83 |
| 84 void ShowNotificationCaller(base::WeakPtr<ScreenshotTaker> screenshot_taker, |
| 85 ScreenshotTakerObserver::Result screenshot_result, |
| 86 const base::FilePath& screenshot_path) { |
| 87 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); |
| 88 if (screenshot_taker.get()) |
| 89 screenshot_taker->ShowNotification(screenshot_result, screenshot_path); |
| 90 } |
| 91 |
| 92 void PostShowNotification(base::WeakPtr<ScreenshotTaker> screenshot_taker, |
| 93 ScreenshotTakerObserver::Result screenshot_result, |
| 94 const base::FilePath& screenshot_path) { |
| 95 DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread()); |
| 96 content::BrowserThread::PostTask( |
| 97 content::BrowserThread::UI, FROM_HERE, |
| 98 base::Bind(&ShowNotificationCaller, |
| 99 screenshot_taker, |
| 100 screenshot_result, |
| 101 screenshot_path)); |
| 102 } |
| 103 |
| 104 void SaveScreenshotInternal(base::WeakPtr<ScreenshotTaker> screenshot_taker, |
| 105 const base::FilePath& screenshot_path, |
49 scoped_refptr<base::RefCountedBytes> png_data) { | 106 scoped_refptr<base::RefCountedBytes> png_data) { |
50 DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread()); | 107 DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread()); |
51 DCHECK(!screenshot_path.empty()); | 108 DCHECK(!screenshot_path.empty()); |
| 109 ScreenshotTakerObserver::Result result = |
| 110 ScreenshotTakerObserver::SCREENSHOT_SUCCESS; |
52 if (static_cast<size_t>(file_util::WriteFile( | 111 if (static_cast<size_t>(file_util::WriteFile( |
53 screenshot_path, | 112 screenshot_path, |
54 reinterpret_cast<char*>(&(png_data->data()[0])), | 113 reinterpret_cast<char*>(&(png_data->data()[0])), |
55 png_data->size())) != png_data->size()) { | 114 png_data->size())) != png_data->size()) { |
56 LOG(ERROR) << "Failed to save to " << screenshot_path.value(); | 115 LOG(ERROR) << "Failed to save to " << screenshot_path.value(); |
| 116 result = ScreenshotTakerObserver::SCREENSHOT_WRITE_FILE_FAILED; |
57 } | 117 } |
| 118 PostShowNotification(screenshot_taker, result, screenshot_path); |
58 } | 119 } |
59 | 120 |
60 void SaveScreenshot(const base::FilePath& screenshot_path, | 121 void SaveScreenshot(base::WeakPtr<ScreenshotTaker> screenshot_taker, |
| 122 const base::FilePath& screenshot_path, |
61 scoped_refptr<base::RefCountedBytes> png_data) { | 123 scoped_refptr<base::RefCountedBytes> png_data) { |
62 DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread()); | 124 DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread()); |
63 DCHECK(!screenshot_path.empty()); | 125 DCHECK(!screenshot_path.empty()); |
64 | 126 |
65 if (!file_util::CreateDirectory(screenshot_path.DirName())) { | 127 if (!file_util::CreateDirectory(screenshot_path.DirName())) { |
66 LOG(ERROR) << "Failed to ensure the existence of " | 128 LOG(ERROR) << "Failed to ensure the existence of " |
67 << screenshot_path.DirName().value(); | 129 << screenshot_path.DirName().value(); |
| 130 PostShowNotification( |
| 131 screenshot_taker, |
| 132 ScreenshotTakerObserver::SCREENSHOT_CREATE_DIR_FAILED, |
| 133 screenshot_path); |
68 return; | 134 return; |
69 } | 135 } |
70 SaveScreenshotInternal(screenshot_path, png_data); | 136 SaveScreenshotInternal(screenshot_taker, screenshot_path, png_data); |
71 } | 137 } |
72 | 138 |
73 // TODO(kinaba): crbug.com/140425, remove this ungly #ifdef dispatch. | 139 // TODO(kinaba): crbug.com/140425, remove this ungly #ifdef dispatch. |
74 #if defined(OS_CHROMEOS) | 140 #if defined(OS_CHROMEOS) |
75 void SaveScreenshotToDrive(scoped_refptr<base::RefCountedBytes> png_data, | 141 void SaveScreenshotToDrive(base::WeakPtr<ScreenshotTaker> screenshot_taker, |
| 142 scoped_refptr<base::RefCountedBytes> png_data, |
76 drive::DriveFileError error, | 143 drive::DriveFileError error, |
77 const base::FilePath& local_path) { | 144 const base::FilePath& local_path) { |
78 if (error != drive::DRIVE_FILE_OK) { | 145 if (error != drive::DRIVE_FILE_OK) { |
79 LOG(ERROR) << "Failed to write screenshot image to Google Drive: " << error; | 146 LOG(ERROR) << "Failed to write screenshot image to Google Drive: " << error; |
| 147 PostShowNotification( |
| 148 screenshot_taker, |
| 149 ScreenshotTakerObserver::SCREENSHOT_CREATE_FILE_FAILED, |
| 150 local_path); |
80 return; | 151 return; |
81 } | 152 } |
82 SaveScreenshotInternal(local_path, png_data); | 153 SaveScreenshotInternal(screenshot_taker, local_path, png_data); |
83 } | 154 } |
84 | 155 |
85 void EnsureDirectoryExistsCallback( | 156 void EnsureDirectoryExistsCallback( |
| 157 base::WeakPtr<ScreenshotTaker> screenshot_taker, |
86 Profile* profile, | 158 Profile* profile, |
87 const base::FilePath& screenshot_path, | 159 const base::FilePath& screenshot_path, |
88 scoped_refptr<base::RefCountedBytes> png_data, | 160 scoped_refptr<base::RefCountedBytes> png_data, |
89 drive::DriveFileError error) { | 161 drive::DriveFileError error) { |
90 // It is okay to fail with DRIVE_FILE_ERROR_EXISTS since anyway the directory | 162 // It is okay to fail with DRIVE_FILE_ERROR_EXISTS since anyway the directory |
91 // of the target file exists. | 163 // of the target file exists. |
92 if (error == drive::DRIVE_FILE_OK || | 164 if (error == drive::DRIVE_FILE_OK || |
93 error == drive::DRIVE_FILE_ERROR_EXISTS) { | 165 error == drive::DRIVE_FILE_ERROR_EXISTS) { |
| 166 // Note: The last two arguments of SaveScreenshotToDrive are appended by |
| 167 // PrepareWritableFileAndRun. |
94 drive::util::PrepareWritableFileAndRun( | 168 drive::util::PrepareWritableFileAndRun( |
95 profile, | 169 profile, |
96 screenshot_path, | 170 screenshot_path, |
97 base::Bind(&SaveScreenshotToDrive, png_data)); | 171 base::Bind(&SaveScreenshotToDrive, screenshot_taker, png_data)); |
98 } else { | 172 } else { |
99 LOG(ERROR) << "Failed to ensure the existence of the specified directory " | 173 LOG(ERROR) << "Failed to ensure the existence of the specified directory " |
100 << "in Google Drive: " << error; | 174 << "in Google Drive: " << error; |
| 175 ShowNotificationCaller( |
| 176 screenshot_taker, |
| 177 ScreenshotTakerObserver::SCREENSHOT_CHECK_DIR_FAILED, |
| 178 screenshot_path); |
101 } | 179 } |
102 } | 180 } |
103 | 181 |
104 void PostSaveScreenshotTask(const base::FilePath& screenshot_path, | 182 void PostSaveScreenshotTask(base::WeakPtr<ScreenshotTaker> screenshot_taker, |
| 183 Profile* profile, |
| 184 const base::FilePath& screenshot_path, |
105 scoped_refptr<base::RefCountedBytes> png_data) { | 185 scoped_refptr<base::RefCountedBytes> png_data) { |
106 if (drive::util::IsUnderDriveMountPoint(screenshot_path)) { | 186 if (drive::util::IsUnderDriveMountPoint(screenshot_path)) { |
107 Profile* profile = ProfileManager::GetDefaultProfileOrOffTheRecord(); | 187 // Note: The last argument of EnsureDirectoryExistsCallback is |
108 if (profile) { | 188 // appended by EnsureDirectoryExists. |
109 drive::util::EnsureDirectoryExists( | 189 drive::util::EnsureDirectoryExists( |
110 profile, | 190 profile, |
111 screenshot_path.DirName(), | 191 screenshot_path.DirName(), |
112 base::Bind(&EnsureDirectoryExistsCallback, | 192 base::Bind(&EnsureDirectoryExistsCallback, |
113 profile, | 193 screenshot_taker, |
114 screenshot_path, | 194 profile, |
115 png_data)); | 195 screenshot_path, |
116 } | 196 png_data)); |
117 } else { | 197 } else { |
118 content::BrowserThread::GetBlockingPool()->PostTask( | 198 content::BrowserThread::GetBlockingPool()->PostTask( |
119 FROM_HERE, base::Bind(&SaveScreenshot, screenshot_path, png_data)); | 199 FROM_HERE, base::Bind(&SaveScreenshot, |
| 200 screenshot_taker, |
| 201 screenshot_path, |
| 202 png_data)); |
120 } | 203 } |
121 } | 204 } |
122 #else | 205 #else |
123 void PostSaveScreenshotTask(const base::FilePath& screenshot_path, | 206 void PostSaveScreenshotTask(base::WeakPtr<ScreenshotTaker> screenshot_taker, |
| 207 Profile* profile, |
| 208 const base::FilePath& screenshot_path, |
124 scoped_refptr<base::RefCountedBytes> png_data) { | 209 scoped_refptr<base::RefCountedBytes> png_data) { |
125 content::BrowserThread::GetBlockingPool()->PostTask( | 210 content::BrowserThread::GetBlockingPool()->PostTask( |
126 FROM_HERE, base::Bind(&SaveScreenshot, screenshot_path, png_data)); | 211 FROM_HERE, base::Bind(&SaveScreenshot, |
| 212 screenshot_taker, |
| 213 screenshot_path, |
| 214 png_data)); |
127 } | 215 } |
128 #endif | 216 #endif |
129 | 217 |
130 bool GrabWindowSnapshot(aura::Window* window, | 218 bool GrabWindowSnapshot(aura::Window* window, |
131 const gfx::Rect& snapshot_bounds, | 219 const gfx::Rect& snapshot_bounds, |
132 std::vector<unsigned char>* png_data) { | 220 std::vector<unsigned char>* png_data) { |
133 #if defined(OS_LINUX) | 221 #if defined(OS_LINUX) |
134 // chrome::GrabWindowSnapshotForUser checks this too, but | 222 // chrome::GrabWindowSnapshotForUser checks this too, but |
135 // RootWindow::GrabSnapshot does not. | 223 // RootWindow::GrabSnapshot does not. |
136 if (ScreenshotSource::AreScreenshotsDisabled()) | 224 if (ScreenshotSource::AreScreenshotsDisabled()) |
137 return false; | 225 return false; |
138 | 226 |
139 // We use XGetImage() for Linux/ChromeOS for performance reasons. | 227 // We use XGetImage() for Linux/ChromeOS for performance reasons. |
140 // See crbug.com/119492 | 228 // See crbug.com/119492 |
141 // TODO(mukai): remove this when the performance issue has been fixed. | 229 // TODO(mukai): remove this when the performance issue has been fixed. |
142 if (window->GetRootWindow()->GrabSnapshot(snapshot_bounds, png_data)) | 230 if (window->GetRootWindow()->GrabSnapshot(snapshot_bounds, png_data)) |
143 return true; | 231 return true; |
144 #endif // OS_LINUX | 232 #endif // OS_LINUX |
145 | 233 |
146 return chrome::GrabWindowSnapshotForUser(window, png_data, snapshot_bounds); | 234 return chrome::GrabWindowSnapshotForUser(window, png_data, snapshot_bounds); |
147 } | 235 } |
148 | 236 |
149 } // namespace | 237 } // namespace |
150 | 238 |
151 ScreenshotTaker::ScreenshotTaker() { | 239 ScreenshotTaker::ScreenshotTaker(Profile* profile) |
| 240 : profile_(profile), |
| 241 ALLOW_THIS_IN_INITIALIZER_LIST(factory_(this)) { |
| 242 DCHECK(profile_); |
152 } | 243 } |
153 | 244 |
154 ScreenshotTaker::~ScreenshotTaker() { | 245 ScreenshotTaker::~ScreenshotTaker() { |
155 } | 246 } |
156 | 247 |
157 void ScreenshotTaker::HandleTakeScreenshotForAllRootWindows() { | 248 void ScreenshotTaker::HandleTakeScreenshotForAllRootWindows() { |
158 base::FilePath screenshot_directory; | 249 base::FilePath screenshot_directory; |
159 if (!ScreenshotSource::GetScreenshotDirectory(&screenshot_directory)) | 250 if (!screenshot_directory_for_test_.empty()) { |
| 251 screenshot_directory = screenshot_directory_for_test_; |
| 252 } else if (!ScreenshotSource::GetScreenshotDirectory(&screenshot_directory)) { |
| 253 ShowNotification(ScreenshotTakerObserver::SCREENSHOT_GET_DIR_FAILED, |
| 254 base::FilePath()); |
160 return; | 255 return; |
| 256 } |
| 257 std::string screenshot_basename = !screenshot_basename_for_test_.empty() ? |
| 258 screenshot_basename_for_test_ : |
| 259 ScreenshotSource::GetScreenshotBaseFilename(); |
161 | 260 |
162 std::string screenshot_basename = | |
163 ScreenshotSource::GetScreenshotBaseFilename(); | |
164 ash::Shell::RootWindowList root_windows = ash::Shell::GetAllRootWindows(); | 261 ash::Shell::RootWindowList root_windows = ash::Shell::GetAllRootWindows(); |
165 // Reorder root_windows to take the primary root window's snapshot at first. | 262 // Reorder root_windows to take the primary root window's snapshot at first. |
166 aura::RootWindow* primary_root = ash::Shell::GetPrimaryRootWindow(); | 263 aura::RootWindow* primary_root = ash::Shell::GetPrimaryRootWindow(); |
167 if (*(root_windows.begin()) != primary_root) { | 264 if (*(root_windows.begin()) != primary_root) { |
168 root_windows.erase(std::find( | 265 root_windows.erase(std::find( |
169 root_windows.begin(), root_windows.end(), primary_root)); | 266 root_windows.begin(), root_windows.end(), primary_root)); |
170 root_windows.insert(root_windows.begin(), primary_root); | 267 root_windows.insert(root_windows.begin(), primary_root); |
171 } | 268 } |
172 for (size_t i = 0; i < root_windows.size(); ++i) { | 269 for (size_t i = 0; i < root_windows.size(); ++i) { |
173 aura::RootWindow* root_window = root_windows[i]; | 270 aura::RootWindow* root_window = root_windows[i]; |
174 scoped_refptr<base::RefCountedBytes> png_data(new base::RefCountedBytes); | 271 scoped_refptr<base::RefCountedBytes> png_data(new base::RefCountedBytes); |
175 std::string basename = screenshot_basename; | 272 std::string basename = screenshot_basename; |
176 gfx::Rect rect = root_window->bounds(); | 273 gfx::Rect rect = root_window->bounds(); |
177 if (root_windows.size() > 1) | 274 if (root_windows.size() > 1) |
178 basename += base::StringPrintf(" - Display %d", static_cast<int>(i + 1)); | 275 basename += base::StringPrintf(" - Display %d", static_cast<int>(i + 1)); |
| 276 base::FilePath screenshot_path = |
| 277 screenshot_directory.AppendASCII(basename + ".png"); |
179 if (GrabWindowSnapshot(root_window, rect, &png_data->data())) { | 278 if (GrabWindowSnapshot(root_window, rect, &png_data->data())) { |
180 DisplayVisualFeedback(rect); | 279 PostSaveScreenshotTask(factory_.GetWeakPtr(), profile_, |
181 PostSaveScreenshotTask( | 280 screenshot_path, png_data); |
182 screenshot_directory.AppendASCII(basename + ".png"), png_data); | |
183 } else { | 281 } else { |
184 LOG(ERROR) << "Failed to grab the window screenshot for " << i; | 282 LOG(ERROR) << "Failed to grab the window screenshot for " << i; |
| 283 ShowNotification( |
| 284 ScreenshotTakerObserver::SCREENSHOT_GRABWINDOW_FULL_FAILED, |
| 285 screenshot_path); |
185 } | 286 } |
186 } | 287 } |
187 last_screenshot_timestamp_ = base::Time::Now(); | 288 last_screenshot_timestamp_ = base::Time::Now(); |
188 } | 289 } |
189 | 290 |
190 void ScreenshotTaker::HandleTakePartialScreenshot( | 291 void ScreenshotTaker::HandleTakePartialScreenshot( |
191 aura::Window* window, const gfx::Rect& rect) { | 292 aura::Window* window, const gfx::Rect& rect) { |
192 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); | 293 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); |
193 | 294 |
194 base::FilePath screenshot_directory; | 295 base::FilePath screenshot_directory; |
195 if (!ScreenshotSource::GetScreenshotDirectory(&screenshot_directory)) | 296 if (!screenshot_directory_for_test_.empty()) { |
| 297 screenshot_directory = screenshot_directory_for_test_; |
| 298 } else if (!ScreenshotSource::GetScreenshotDirectory(&screenshot_directory)) { |
| 299 ShowNotification(ScreenshotTakerObserver::SCREENSHOT_GET_DIR_FAILED, |
| 300 base::FilePath()); |
196 return; | 301 return; |
| 302 } |
197 | 303 |
198 scoped_refptr<base::RefCountedBytes> png_data(new base::RefCountedBytes); | 304 scoped_refptr<base::RefCountedBytes> png_data(new base::RefCountedBytes); |
199 | 305 |
| 306 std::string screenshot_basename = !screenshot_basename_for_test_.empty() ? |
| 307 screenshot_basename_for_test_ : |
| 308 ScreenshotSource::GetScreenshotBaseFilename(); |
| 309 base::FilePath screenshot_path = |
| 310 screenshot_directory.AppendASCII(screenshot_basename + ".png"); |
200 if (GrabWindowSnapshot(window, rect, &png_data->data())) { | 311 if (GrabWindowSnapshot(window, rect, &png_data->data())) { |
201 last_screenshot_timestamp_ = base::Time::Now(); | 312 last_screenshot_timestamp_ = base::Time::Now(); |
202 DisplayVisualFeedback(rect); | 313 PostSaveScreenshotTask(factory_.GetWeakPtr(), profile_, |
203 PostSaveScreenshotTask( | 314 screenshot_path, png_data); |
204 screenshot_directory.AppendASCII( | |
205 ScreenshotSource::GetScreenshotBaseFilename() + ".png"), | |
206 png_data); | |
207 } else { | 315 } else { |
208 LOG(ERROR) << "Failed to grab the window screenshot"; | 316 LOG(ERROR) << "Failed to grab the window screenshot"; |
| 317 ShowNotification( |
| 318 ScreenshotTakerObserver::SCREENSHOT_GRABWINDOW_PARTIAL_FAILED, |
| 319 screenshot_path); |
209 } | 320 } |
210 } | 321 } |
211 | 322 |
212 bool ScreenshotTaker::CanTakeScreenshot() { | 323 bool ScreenshotTaker::CanTakeScreenshot() { |
213 return last_screenshot_timestamp_.is_null() || | 324 return last_screenshot_timestamp_.is_null() || |
214 base::Time::Now() - last_screenshot_timestamp_ > | 325 base::Time::Now() - last_screenshot_timestamp_ > |
215 base::TimeDelta::FromMilliseconds( | 326 base::TimeDelta::FromMilliseconds( |
216 kScreenshotMinimumIntervalInMS); | 327 kScreenshotMinimumIntervalInMS); |
217 } | 328 } |
218 | 329 |
219 void ScreenshotTaker::CloseVisualFeedbackLayer() { | 330 void ScreenshotTaker::ShowNotification( |
220 visual_feedback_layer_.reset(); | 331 ScreenshotTakerObserver::Result screenshot_result, |
| 332 const base::FilePath& screenshot_path) { |
| 333 DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI)); |
| 334 static int id = 0; |
| 335 std::string id_text = base::StringPrintf("screenshot_%3.3d", ++id); |
| 336 string16 replace_id = UTF8ToUTF16(id_text); |
| 337 bool success = |
| 338 (screenshot_result == ScreenshotTakerObserver::SCREENSHOT_SUCCESS); |
| 339 Notification notification( |
| 340 GURL(kNotificationOriginUrl), |
| 341 ui::ResourceBundle::GetSharedInstance().GetImageNamed( |
| 342 IDR_SCREENSHOT_NOTIFICATION_ICON), |
| 343 l10n_util::GetStringUTF16( |
| 344 success ? |
| 345 IDS_ASH_SCREENSHOT_NOTIFICATION_TITLE_SUCCESS : |
| 346 IDS_ASH_SCREENSHOT_NOTIFICATION_TITLE_FAIL), |
| 347 l10n_util::GetStringUTF16( |
| 348 success ? |
| 349 IDS_ASH_SCREENSHOT_NOTIFICATION_TEXT_SUCCESS : |
| 350 IDS_ASH_SCREENSHOT_NOTIFICATION_TEXT_FAIL), |
| 351 WebKit::WebTextDirectionDefault, |
| 352 string16(), |
| 353 replace_id, |
| 354 new ScreenshotTakerNotificationDelegate(id_text, |
| 355 success, |
| 356 screenshot_path)); |
| 357 g_browser_process->notification_ui_manager()->Add(notification, profile_); |
| 358 |
| 359 FOR_EACH_OBSERVER(ScreenshotTakerObserver, observers_, |
| 360 OnScreenshotCompleted(screenshot_result, screenshot_path)); |
221 } | 361 } |
222 | 362 |
223 void ScreenshotTaker::DisplayVisualFeedback(const gfx::Rect& rect) { | 363 void ScreenshotTaker::AddObserver(ScreenshotTakerObserver* observer) { |
224 visual_feedback_layer_.reset(new ui::Layer(ui::LAYER_SOLID_COLOR)); | 364 observers_.AddObserver(observer); |
225 visual_feedback_layer_->SetColor(SK_ColorWHITE); | 365 } |
226 visual_feedback_layer_->SetOpacity(kVisualFeedbackLayerOpacity); | |
227 visual_feedback_layer_->SetBounds(rect); | |
228 | 366 |
229 ui::Layer* parent = ash::Shell::GetContainer( | 367 void ScreenshotTaker::RemoveObserver(ScreenshotTakerObserver* observer) { |
230 ash::Shell::GetActiveRootWindow(), | 368 observers_.RemoveObserver(observer); |
231 ash::internal::kShellWindowId_OverlayContainer)->layer(); | 369 } |
232 parent->Add(visual_feedback_layer_.get()); | |
233 visual_feedback_layer_->SetVisible(true); | |
234 | 370 |
235 MessageLoopForUI::current()->PostDelayedTask( | 371 bool ScreenshotTaker::HasObserver(ScreenshotTakerObserver* observer) const { |
236 FROM_HERE, | 372 return observers_.HasObserver(observer); |
237 base::Bind(&ScreenshotTaker::CloseVisualFeedbackLayer, | |
238 base::Unretained(this)), | |
239 base::TimeDelta::FromMilliseconds(kVisualFeedbackLayerDisplayTimeMs)); | |
240 } | 373 } |
| 374 |
| 375 void ScreenshotTaker::SetScreenshotDirectoryForTest( |
| 376 const base::FilePath& directory) { |
| 377 screenshot_directory_for_test_ = directory; |
| 378 } |
| 379 |
| 380 void ScreenshotTaker::SetScreenshotBasenameForTest( |
| 381 const std::string& basename){ |
| 382 screenshot_basename_for_test_ = basename; |
| 383 } |
OLD | NEW |