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/download/download_shelf_context_menu.h" | 5 #include "chrome/browser/download/download_shelf_context_menu.h" |
6 | 6 |
7 #include "base/command_line.h" | 7 #include "base/command_line.h" |
8 #include "chrome/browser/browser_process.h" | |
9 #include "chrome/browser/download/download_crx_util.h" | |
10 #include "chrome/browser/download/download_item_model.h" | 8 #include "chrome/browser/download/download_item_model.h" |
11 #include "chrome/browser/download/download_prefs.h" | |
12 #include "chrome/browser/download/download_target_determiner.h" | |
13 #include "chrome/browser/safe_browsing/download_protection_service.h" | |
14 #include "chrome/browser/safe_browsing/safe_browsing_service.h" | |
15 #include "chrome/common/url_constants.h" | |
16 #include "chrome/grit/generated_resources.h" | |
17 #include "content/public/browser/download_item.h" | |
18 #include "content/public/browser/download_manager.h" | |
19 #include "content/public/browser/page_navigator.h" | |
20 #include "content/public/common/content_switches.h" | 9 #include "content/public/common/content_switches.h" |
21 #include "extensions/common/extension.h" | 10 #include "extensions/common/extension.h" |
22 #include "ui/base/l10n/l10n_util.h" | 11 #include "ui/base/l10n/l10n_util.h" |
23 | 12 |
24 #if defined(OS_WIN) | |
25 #include "chrome/browser/ui/pdf/adobe_reader_info_win.h" | |
26 #endif | |
27 | |
28 using content::DownloadItem; | 13 using content::DownloadItem; |
29 | 14 |
30 namespace { | 15 namespace { |
31 | 16 |
32 // Returns true if downloads resumption is enabled. | 17 // Returns true if downloads resumption is enabled. |
33 bool IsDownloadResumptionEnabled() { | 18 bool IsDownloadResumptionEnabled() { |
34 return base::CommandLine::ForCurrentProcess()->HasSwitch( | 19 return base::CommandLine::ForCurrentProcess()->HasSwitch( |
35 switches::kEnableDownloadResumption); | 20 switches::kEnableDownloadResumption); |
36 } | 21 } |
37 | 22 |
38 } // namespace | 23 } // namespace |
39 | 24 |
40 DownloadShelfContextMenu::~DownloadShelfContextMenu() { | 25 DownloadShelfContextMenu::~DownloadShelfContextMenu() { |
41 DetachFromDownloadItem(); | 26 DetachFromDownloadItem(); |
42 } | 27 } |
43 | 28 |
44 DownloadShelfContextMenu::DownloadShelfContextMenu( | 29 DownloadShelfContextMenu::DownloadShelfContextMenu( |
45 DownloadItem* download_item, | 30 DownloadItem* download_item, |
46 content::PageNavigator* navigator) | 31 content::PageNavigator* navigator) |
47 : download_item_(download_item), | 32 : download_item_(download_item), |
| 33 download_command_(download_item), |
48 navigator_(navigator) { | 34 navigator_(navigator) { |
49 DCHECK(download_item_); | 35 DCHECK(download_item_); |
50 download_item_->AddObserver(this); | 36 download_item_->AddObserver(this); |
51 | |
52 #if defined(OS_WIN) | |
53 is_adobe_pdf_reader_up_to_date_ = false; | |
54 if (IsDownloadPdf() && IsAdobeReaderDefaultPDFViewer()) { | |
55 is_adobe_pdf_reader_up_to_date_ = | |
56 DownloadTargetDeterminer::IsAdobeReaderUpToDate(); | |
57 } | |
58 #endif // defined(OS_WIN) | |
59 } | 37 } |
60 | 38 |
61 ui::SimpleMenuModel* DownloadShelfContextMenu::GetMenuModel() { | 39 ui::SimpleMenuModel* DownloadShelfContextMenu::GetMenuModel() { |
62 ui::SimpleMenuModel* model = NULL; | 40 ui::SimpleMenuModel* model = NULL; |
63 | 41 |
64 if (!download_item_) | 42 if (!download_item_) |
65 return NULL; | 43 return NULL; |
66 | 44 |
67 DownloadItemModel download_model(download_item_); | 45 DownloadItemModel download_model(download_item_); |
68 // We shouldn't be opening a context menu for a dangerous download, unless it | 46 // We shouldn't be opening a context menu for a dangerous download, unless it |
69 // is a malicious download. | 47 // is a malicious download. |
70 DCHECK(!download_model.IsDangerous() || download_model.MightBeMalicious()); | 48 DCHECK(!download_model.IsDangerous() || download_model.MightBeMalicious()); |
71 | 49 |
72 if (download_model.IsMalicious()) | 50 if (download_model.IsMalicious()) |
73 model = GetMaliciousMenuModel(); | 51 model = GetMaliciousMenuModel(); |
74 else if (download_model.MightBeMalicious()) | 52 else if (download_model.MightBeMalicious()) |
75 model = GetMaybeMaliciousMenuModel(); | 53 model = GetMaybeMaliciousMenuModel(); |
76 else if (download_item_->GetState() == DownloadItem::COMPLETE) | 54 else if (download_item_->GetState() == DownloadItem::COMPLETE) |
77 model = GetFinishedMenuModel(); | 55 model = GetFinishedMenuModel(); |
78 else if (download_item_->GetState() == DownloadItem::INTERRUPTED) | 56 else if (download_item_->GetState() == DownloadItem::INTERRUPTED) |
79 model = GetInterruptedMenuModel(); | 57 model = GetInterruptedMenuModel(); |
80 else | 58 else |
81 model = GetInProgressMenuModel(); | 59 model = GetInProgressMenuModel(); |
82 return model; | 60 return model; |
83 } | 61 } |
84 | 62 |
85 bool DownloadShelfContextMenu::IsCommandIdEnabled(int command_id) const { | 63 bool DownloadShelfContextMenu::IsCommandIdEnabled(int command_id) const { |
86 if (!download_item_) | 64 return download_command_.IsCommandIdEnabled( |
87 return false; | 65 static_cast<DownloadCommand::Commands>(command_id)); |
88 | |
89 switch (static_cast<ContextMenuCommands>(command_id)) { | |
90 case SHOW_IN_FOLDER: | |
91 return download_item_->CanShowInFolder(); | |
92 case OPEN_WHEN_COMPLETE: | |
93 case PLATFORM_OPEN: | |
94 return download_item_->CanOpenDownload() && | |
95 !download_crx_util::IsExtensionDownload(*download_item_); | |
96 case ALWAYS_OPEN_TYPE: | |
97 // For temporary downloads, the target filename might be a temporary | |
98 // filename. Don't base an "Always open" decision based on it. Also | |
99 // exclude extensions. | |
100 return download_item_->CanOpenDownload() && | |
101 !download_crx_util::IsExtensionDownload(*download_item_); | |
102 case CANCEL: | |
103 return !download_item_->IsDone(); | |
104 case TOGGLE_PAUSE: | |
105 return !download_item_->IsDone(); | |
106 case DISCARD: | |
107 case KEEP: | |
108 case LEARN_MORE_SCANNING: | |
109 case LEARN_MORE_INTERRUPTED: | |
110 return true; | |
111 } | |
112 NOTREACHED(); | |
113 return false; | |
114 } | 66 } |
115 | 67 |
116 bool DownloadShelfContextMenu::IsCommandIdChecked(int command_id) const { | 68 bool DownloadShelfContextMenu::IsCommandIdChecked(int command_id) const { |
117 if (!download_item_) | 69 return download_command_.IsCommandIdChecked( |
118 return false; | 70 static_cast<DownloadCommand::Commands>(command_id)); |
119 | |
120 switch (command_id) { | |
121 case OPEN_WHEN_COMPLETE: | |
122 return download_item_->GetOpenWhenComplete() || | |
123 download_crx_util::IsExtensionDownload(*download_item_); | |
124 case ALWAYS_OPEN_TYPE: | |
125 #if defined(OS_WIN) || defined(OS_LINUX) || \ | |
126 (defined(OS_MACOSX) && !defined(OS_IOS)) | |
127 if (CanOpenPdfInSystemViewer()) { | |
128 DownloadPrefs* prefs = DownloadPrefs::FromBrowserContext( | |
129 download_item_->GetBrowserContext()); | |
130 return prefs->ShouldOpenPdfInSystemReader(); | |
131 } | |
132 #endif | |
133 return download_item_->ShouldOpenFileBasedOnExtension(); | |
134 case TOGGLE_PAUSE: | |
135 return download_item_->IsPaused(); | |
136 } | |
137 return false; | |
138 } | 71 } |
139 | 72 |
140 bool DownloadShelfContextMenu::IsCommandIdVisible(int command_id) const { | 73 bool DownloadShelfContextMenu::IsCommandIdVisible(int command_id) const { |
141 if (!download_item_) | 74 return download_command_.IsCommandIdVisible( |
142 return false; | 75 static_cast<DownloadCommand::Commands>(command_id)); |
143 | |
144 if (command_id == PLATFORM_OPEN) | |
145 return (DownloadItemModel(download_item_).ShouldPreferOpeningInBrowser()); | |
146 | |
147 return true; | |
148 } | 76 } |
149 | 77 |
150 void DownloadShelfContextMenu::ExecuteCommand(int command_id, int event_flags) { | 78 void DownloadShelfContextMenu::ExecuteCommand(int command_id, int event_flags) { |
151 if (!download_item_) | 79 download_command_.ExecuteCommand( |
152 return; | 80 static_cast<DownloadCommand::Commands>(command_id), navigator_); |
153 | |
154 switch (static_cast<ContextMenuCommands>(command_id)) { | |
155 case SHOW_IN_FOLDER: | |
156 download_item_->ShowDownloadInShell(); | |
157 break; | |
158 case OPEN_WHEN_COMPLETE: | |
159 download_item_->OpenDownload(); | |
160 break; | |
161 case ALWAYS_OPEN_TYPE: { | |
162 bool is_checked = IsCommandIdChecked(ALWAYS_OPEN_TYPE); | |
163 DownloadPrefs* prefs = DownloadPrefs::FromBrowserContext( | |
164 download_item_->GetBrowserContext()); | |
165 #if defined(OS_WIN) || defined(OS_LINUX) || \ | |
166 (defined(OS_MACOSX) && !defined(OS_IOS)) | |
167 if (CanOpenPdfInSystemViewer()) { | |
168 prefs->SetShouldOpenPdfInSystemReader(!is_checked); | |
169 DownloadItemModel(download_item_).SetShouldPreferOpeningInBrowser( | |
170 is_checked); | |
171 break; | |
172 } | |
173 #endif | |
174 base::FilePath path = download_item_->GetTargetFilePath(); | |
175 if (is_checked) | |
176 prefs->DisableAutoOpenBasedOnExtension(path); | |
177 else | |
178 prefs->EnableAutoOpenBasedOnExtension(path); | |
179 break; | |
180 } | |
181 case PLATFORM_OPEN: | |
182 DownloadItemModel(download_item_).OpenUsingPlatformHandler(); | |
183 break; | |
184 case CANCEL: | |
185 download_item_->Cancel(true /* Cancelled by user */); | |
186 break; | |
187 case TOGGLE_PAUSE: | |
188 if (download_item_->GetState() == DownloadItem::IN_PROGRESS && | |
189 !download_item_->IsPaused()) { | |
190 download_item_->Pause(); | |
191 } else { | |
192 download_item_->Resume(); | |
193 } | |
194 break; | |
195 case DISCARD: | |
196 download_item_->Remove(); | |
197 break; | |
198 case KEEP: | |
199 download_item_->ValidateDangerousDownload(); | |
200 break; | |
201 case LEARN_MORE_SCANNING: { | |
202 #if defined(FULL_SAFE_BROWSING) | |
203 using safe_browsing::DownloadProtectionService; | |
204 SafeBrowsingService* sb_service = | |
205 g_browser_process->safe_browsing_service(); | |
206 DownloadProtectionService* protection_service = | |
207 (sb_service ? sb_service->download_protection_service() : NULL); | |
208 if (protection_service) { | |
209 protection_service->ShowDetailsForDownload(*download_item_, navigator_); | |
210 } | |
211 #else | |
212 // Should only be getting invoked if we are using safe browsing. | |
213 NOTREACHED(); | |
214 #endif | |
215 break; | |
216 } | |
217 case LEARN_MORE_INTERRUPTED: | |
218 navigator_->OpenURL( | |
219 content::OpenURLParams(GURL(chrome::kDownloadInterruptedLearnMoreURL), | |
220 content::Referrer(), | |
221 NEW_FOREGROUND_TAB, | |
222 ui::PAGE_TRANSITION_LINK, | |
223 false)); | |
224 break; | |
225 } | |
226 } | 81 } |
227 | 82 |
228 bool DownloadShelfContextMenu::GetAcceleratorForCommandId( | 83 bool DownloadShelfContextMenu::GetAcceleratorForCommandId( |
229 int command_id, ui::Accelerator* accelerator) { | 84 int command_id, ui::Accelerator* accelerator) { |
230 return false; | 85 return false; |
231 } | 86 } |
232 | 87 |
233 bool DownloadShelfContextMenu::IsItemForCommandIdDynamic(int command_id) const { | 88 bool DownloadShelfContextMenu::IsItemForCommandIdDynamic(int command_id) const { |
234 return command_id == TOGGLE_PAUSE; | 89 return false; |
235 } | 90 } |
236 | 91 |
237 base::string16 DownloadShelfContextMenu::GetLabelForCommandId( | 92 base::string16 DownloadShelfContextMenu::GetLabelForCommandId( |
238 int command_id) const { | 93 int command_id) const { |
239 switch (static_cast<ContextMenuCommands>(command_id)) { | 94 return l10n_util::GetStringUTF16(GetStringIdForCommand( |
240 case SHOW_IN_FOLDER: | 95 static_cast<DownloadCommand::Commands>(command_id))); |
241 return l10n_util::GetStringUTF16(IDS_DOWNLOAD_MENU_SHOW); | 96 } |
242 case OPEN_WHEN_COMPLETE: | 97 |
243 if (download_item_ && !download_item_->IsDone()) | 98 int DownloadShelfContextMenu::GetStringIdForCommand( |
244 return l10n_util::GetStringUTF16(IDS_DOWNLOAD_MENU_OPEN_WHEN_COMPLETE); | 99 DownloadCommand::Commands command) const { |
245 return l10n_util::GetStringUTF16(IDS_DOWNLOAD_MENU_OPEN); | 100 return download_command_.GetCommandStringIdForMenu(command); |
246 case ALWAYS_OPEN_TYPE: | |
247 return l10n_util::GetStringUTF16(GetAlwaysOpenStringId()); | |
248 case PLATFORM_OPEN: | |
249 return l10n_util::GetStringUTF16(IDS_DOWNLOAD_MENU_PLATFORM_OPEN); | |
250 case CANCEL: | |
251 return l10n_util::GetStringUTF16(IDS_DOWNLOAD_MENU_CANCEL); | |
252 case TOGGLE_PAUSE: | |
253 if (download_item_ && | |
254 download_item_->GetState() == DownloadItem::IN_PROGRESS && | |
255 !download_item_->IsPaused()) | |
256 return l10n_util::GetStringUTF16(IDS_DOWNLOAD_MENU_PAUSE_ITEM); | |
257 return l10n_util::GetStringUTF16(IDS_DOWNLOAD_MENU_RESUME_ITEM); | |
258 case DISCARD: | |
259 return l10n_util::GetStringUTF16(IDS_DOWNLOAD_MENU_DISCARD); | |
260 case KEEP: | |
261 return l10n_util::GetStringUTF16(IDS_DOWNLOAD_MENU_KEEP); | |
262 case LEARN_MORE_SCANNING: | |
263 return l10n_util::GetStringUTF16(IDS_DOWNLOAD_MENU_LEARN_MORE_SCANNING); | |
264 case LEARN_MORE_INTERRUPTED: | |
265 return l10n_util::GetStringUTF16( | |
266 IDS_DOWNLOAD_MENU_LEARN_MORE_INTERRUPTED); | |
267 } | |
268 NOTREACHED(); | |
269 return base::string16(); | |
270 } | 101 } |
271 | 102 |
272 void DownloadShelfContextMenu::DetachFromDownloadItem() { | 103 void DownloadShelfContextMenu::DetachFromDownloadItem() { |
273 if (!download_item_) | 104 if (!download_item_) |
274 return; | 105 return; |
275 | 106 |
276 download_item_->RemoveObserver(this); | 107 download_item_->RemoveObserver(this); |
277 download_item_ = NULL; | 108 download_item_ = NULL; |
278 } | 109 } |
279 | 110 |
280 void DownloadShelfContextMenu::OnDownloadDestroyed(DownloadItem* download) { | 111 void DownloadShelfContextMenu::OnDownloadDestroyed(DownloadItem* download) { |
281 DCHECK(download_item_ == download); | 112 DCHECK(download_item_ == download); |
282 DetachFromDownloadItem(); | 113 DetachFromDownloadItem(); |
283 } | 114 } |
284 | 115 |
285 ui::SimpleMenuModel* DownloadShelfContextMenu::GetInProgressMenuModel() { | 116 ui::SimpleMenuModel* DownloadShelfContextMenu::GetInProgressMenuModel() { |
286 if (in_progress_download_menu_model_) | 117 if (in_progress_download_menu_model_) |
287 return in_progress_download_menu_model_.get(); | 118 return in_progress_download_menu_model_.get(); |
288 | 119 |
289 in_progress_download_menu_model_.reset(new ui::SimpleMenuModel(this)); | 120 in_progress_download_menu_model_.reset(new ui::SimpleMenuModel(this)); |
290 | 121 |
291 in_progress_download_menu_model_->AddCheckItemWithStringId( | 122 in_progress_download_menu_model_->AddCheckItemWithStringId( |
292 OPEN_WHEN_COMPLETE, IDS_DOWNLOAD_MENU_OPEN_WHEN_COMPLETE); | 123 DownloadCommand::OPEN_WHEN_COMPLETE, |
| 124 GetStringIdForCommand(DownloadCommand::OPEN_WHEN_COMPLETE)); |
293 in_progress_download_menu_model_->AddCheckItemWithStringId( | 125 in_progress_download_menu_model_->AddCheckItemWithStringId( |
294 ALWAYS_OPEN_TYPE, GetAlwaysOpenStringId()); | 126 DownloadCommand::ALWAYS_OPEN_TYPE, |
| 127 GetStringIdForCommand(DownloadCommand::ALWAYS_OPEN_TYPE)); |
295 in_progress_download_menu_model_->AddSeparator(ui::NORMAL_SEPARATOR); | 128 in_progress_download_menu_model_->AddSeparator(ui::NORMAL_SEPARATOR); |
296 in_progress_download_menu_model_->AddItemWithStringId( | 129 in_progress_download_menu_model_->AddItemWithStringId( |
297 TOGGLE_PAUSE, IDS_DOWNLOAD_MENU_PAUSE_ITEM); | 130 DownloadCommand::PAUSE, GetStringIdForCommand(DownloadCommand::PAUSE)); |
298 in_progress_download_menu_model_->AddItemWithStringId( | 131 in_progress_download_menu_model_->AddItemWithStringId( |
299 SHOW_IN_FOLDER, IDS_DOWNLOAD_MENU_SHOW); | 132 DownloadCommand::SHOW_IN_FOLDER, |
| 133 GetStringIdForCommand(DownloadCommand::SHOW_IN_FOLDER)); |
300 in_progress_download_menu_model_->AddSeparator(ui::NORMAL_SEPARATOR); | 134 in_progress_download_menu_model_->AddSeparator(ui::NORMAL_SEPARATOR); |
301 in_progress_download_menu_model_->AddItemWithStringId( | 135 in_progress_download_menu_model_->AddItemWithStringId( |
302 CANCEL, IDS_DOWNLOAD_MENU_CANCEL); | 136 DownloadCommand::CANCEL, GetStringIdForCommand(DownloadCommand::CANCEL)); |
303 | 137 |
304 return in_progress_download_menu_model_.get(); | 138 return in_progress_download_menu_model_.get(); |
305 } | 139 } |
306 | 140 |
307 ui::SimpleMenuModel* DownloadShelfContextMenu::GetFinishedMenuModel() { | 141 ui::SimpleMenuModel* DownloadShelfContextMenu::GetFinishedMenuModel() { |
308 if (finished_download_menu_model_) | 142 if (finished_download_menu_model_) |
309 return finished_download_menu_model_.get(); | 143 return finished_download_menu_model_.get(); |
310 | 144 |
311 finished_download_menu_model_.reset(new ui::SimpleMenuModel(this)); | 145 finished_download_menu_model_.reset(new ui::SimpleMenuModel(this)); |
312 | 146 |
313 finished_download_menu_model_->AddItemWithStringId( | 147 finished_download_menu_model_->AddItemWithStringId( |
314 OPEN_WHEN_COMPLETE, IDS_DOWNLOAD_MENU_OPEN); | 148 DownloadCommand::OPEN_WHEN_COMPLETE, |
| 149 GetStringIdForCommand(DownloadCommand::OPEN_WHEN_COMPLETE)); |
315 finished_download_menu_model_->AddCheckItemWithStringId( | 150 finished_download_menu_model_->AddCheckItemWithStringId( |
316 ALWAYS_OPEN_TYPE, GetAlwaysOpenStringId()); | 151 DownloadCommand::ALWAYS_OPEN_TYPE, |
| 152 GetStringIdForCommand(DownloadCommand::ALWAYS_OPEN_TYPE)); |
317 finished_download_menu_model_->AddItemWithStringId( | 153 finished_download_menu_model_->AddItemWithStringId( |
318 PLATFORM_OPEN, IDS_DOWNLOAD_MENU_PLATFORM_OPEN); | 154 DownloadCommand::PLATFORM_OPEN, |
| 155 GetStringIdForCommand(DownloadCommand::PLATFORM_OPEN)); |
319 finished_download_menu_model_->AddSeparator(ui::NORMAL_SEPARATOR); | 156 finished_download_menu_model_->AddSeparator(ui::NORMAL_SEPARATOR); |
320 finished_download_menu_model_->AddItemWithStringId( | 157 finished_download_menu_model_->AddItemWithStringId( |
321 SHOW_IN_FOLDER, IDS_DOWNLOAD_MENU_SHOW); | 158 DownloadCommand::SHOW_IN_FOLDER, |
| 159 GetStringIdForCommand(DownloadCommand::SHOW_IN_FOLDER)); |
322 finished_download_menu_model_->AddSeparator(ui::NORMAL_SEPARATOR); | 160 finished_download_menu_model_->AddSeparator(ui::NORMAL_SEPARATOR); |
323 finished_download_menu_model_->AddItemWithStringId( | 161 finished_download_menu_model_->AddItemWithStringId( |
324 CANCEL, IDS_DOWNLOAD_MENU_CANCEL); | 162 DownloadCommand::CANCEL, GetStringIdForCommand(DownloadCommand::CANCEL)); |
325 | 163 |
326 return finished_download_menu_model_.get(); | 164 return finished_download_menu_model_.get(); |
327 } | 165 } |
328 | 166 |
329 ui::SimpleMenuModel* DownloadShelfContextMenu::GetInterruptedMenuModel() { | 167 ui::SimpleMenuModel* DownloadShelfContextMenu::GetInterruptedMenuModel() { |
330 #if !defined(OS_WIN) | 168 #if !defined(OS_WIN) |
331 // If resumption isn't enabled and we aren't on Windows, then none of the | 169 // If resumption isn't enabled and we aren't on Windows, then none of the |
332 // options here are applicable. | 170 // options here are applicable. |
333 if (!IsDownloadResumptionEnabled()) | 171 if (!IsDownloadResumptionEnabled()) |
334 return GetInProgressMenuModel(); | 172 return GetInProgressMenuModel(); |
335 #endif | 173 #endif |
336 | 174 |
337 if (interrupted_download_menu_model_) | 175 if (interrupted_download_menu_model_) |
338 return interrupted_download_menu_model_.get(); | 176 return interrupted_download_menu_model_.get(); |
339 | 177 |
340 interrupted_download_menu_model_.reset(new ui::SimpleMenuModel(this)); | 178 interrupted_download_menu_model_.reset(new ui::SimpleMenuModel(this)); |
341 | 179 |
342 if (IsDownloadResumptionEnabled()) { | 180 if (IsDownloadResumptionEnabled()) { |
343 interrupted_download_menu_model_->AddItemWithStringId( | 181 interrupted_download_menu_model_->AddItemWithStringId( |
344 TOGGLE_PAUSE, IDS_DOWNLOAD_MENU_RESUME_ITEM); | 182 DownloadCommand::RESUME, |
| 183 GetStringIdForCommand(DownloadCommand::RESUME)); |
345 } | 184 } |
346 #if defined(OS_WIN) | 185 #if defined(OS_WIN) |
347 // The Help Center article is currently Windows specific. | 186 // The Help Center article is currently Windows specific. |
348 // TODO(asanka): Enable this for other platforms when the article is expanded | 187 // TODO(asanka): Enable this for other platforms when the article is expanded |
349 // for other platforms. | 188 // for other platforms. |
350 interrupted_download_menu_model_->AddItemWithStringId( | 189 interrupted_download_menu_model_->AddItemWithStringId( |
351 LEARN_MORE_INTERRUPTED, IDS_DOWNLOAD_MENU_LEARN_MORE_INTERRUPTED); | 190 DownloadCommand::LEARN_MORE_INTERRUPTED, |
| 191 GetStringIdForCommand(DownloadCommand::LEARN_MORE_INTERRUPTED)); |
352 #endif | 192 #endif |
353 if (IsDownloadResumptionEnabled()) { | 193 if (IsDownloadResumptionEnabled()) { |
354 interrupted_download_menu_model_->AddSeparator(ui::NORMAL_SEPARATOR); | 194 interrupted_download_menu_model_->AddSeparator(ui::NORMAL_SEPARATOR); |
355 interrupted_download_menu_model_->AddItemWithStringId( | 195 interrupted_download_menu_model_->AddItemWithStringId( |
356 CANCEL, IDS_DOWNLOAD_MENU_CANCEL); | 196 DownloadCommand::CANCEL, |
| 197 GetStringIdForCommand(DownloadCommand::CANCEL)); |
357 } | 198 } |
358 | 199 |
359 return interrupted_download_menu_model_.get(); | 200 return interrupted_download_menu_model_.get(); |
360 } | 201 } |
361 | 202 |
362 ui::SimpleMenuModel* DownloadShelfContextMenu::GetMaybeMaliciousMenuModel() { | 203 ui::SimpleMenuModel* DownloadShelfContextMenu::GetMaybeMaliciousMenuModel() { |
363 if (maybe_malicious_download_menu_model_) | 204 if (maybe_malicious_download_menu_model_) |
364 return maybe_malicious_download_menu_model_.get(); | 205 return maybe_malicious_download_menu_model_.get(); |
365 | 206 |
366 maybe_malicious_download_menu_model_.reset(new ui::SimpleMenuModel(this)); | 207 maybe_malicious_download_menu_model_.reset(new ui::SimpleMenuModel(this)); |
367 | 208 |
368 maybe_malicious_download_menu_model_->AddItemWithStringId( | 209 maybe_malicious_download_menu_model_->AddItemWithStringId( |
369 KEEP, IDS_DOWNLOAD_MENU_KEEP); | 210 DownloadCommand::KEEP, |
| 211 GetStringIdForCommand(DownloadCommand::KEEP)); |
370 maybe_malicious_download_menu_model_->AddSeparator(ui::NORMAL_SEPARATOR); | 212 maybe_malicious_download_menu_model_->AddSeparator(ui::NORMAL_SEPARATOR); |
371 maybe_malicious_download_menu_model_->AddItemWithStringId( | 213 maybe_malicious_download_menu_model_->AddItemWithStringId( |
372 LEARN_MORE_SCANNING, IDS_DOWNLOAD_MENU_LEARN_MORE_SCANNING); | 214 DownloadCommand::LEARN_MORE_SCANNING, |
| 215 GetStringIdForCommand(DownloadCommand::LEARN_MORE_SCANNING)); |
373 return maybe_malicious_download_menu_model_.get(); | 216 return maybe_malicious_download_menu_model_.get(); |
374 } | 217 } |
375 | 218 |
376 ui::SimpleMenuModel* DownloadShelfContextMenu::GetMaliciousMenuModel() { | 219 ui::SimpleMenuModel* DownloadShelfContextMenu::GetMaliciousMenuModel() { |
377 if (malicious_download_menu_model_) | 220 if (malicious_download_menu_model_) |
378 return malicious_download_menu_model_.get(); | 221 return malicious_download_menu_model_.get(); |
379 | 222 |
380 malicious_download_menu_model_.reset(new ui::SimpleMenuModel(this)); | 223 malicious_download_menu_model_.reset(new ui::SimpleMenuModel(this)); |
381 | 224 |
382 DownloadItemModel download_model(download_item_); | 225 DownloadItemModel download_model(download_item_); |
383 malicious_download_menu_model_->AddItemWithStringId( | 226 malicious_download_menu_model_->AddItemWithStringId( |
384 LEARN_MORE_SCANNING, IDS_DOWNLOAD_MENU_LEARN_MORE_SCANNING); | 227 DownloadCommand::LEARN_MORE_SCANNING, |
| 228 GetStringIdForCommand(DownloadCommand::LEARN_MORE_SCANNING)); |
385 | 229 |
386 return malicious_download_menu_model_.get(); | 230 return malicious_download_menu_model_.get(); |
387 } | 231 } |
388 | |
389 int DownloadShelfContextMenu::GetAlwaysOpenStringId() const { | |
390 #if defined(OS_WIN) | |
391 if (CanOpenPdfInSystemViewer()) | |
392 return IsAdobeReaderDefaultPDFViewer() | |
393 ? IDS_DOWNLOAD_MENU_ALWAYS_OPEN_PDF_IN_READER | |
394 : IDS_DOWNLOAD_MENU_PLATFORM_OPEN_ALWAYS; | |
395 #elif defined(OS_MACOSX) || defined(OS_LINUX) | |
396 if (CanOpenPdfInSystemViewer()) | |
397 return IDS_DOWNLOAD_MENU_PLATFORM_OPEN_ALWAYS; | |
398 #endif | |
399 return IDS_DOWNLOAD_MENU_ALWAYS_OPEN_TYPE; | |
400 } | |
401 | |
402 #if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) | |
403 bool DownloadShelfContextMenu::IsDownloadPdf() const { | |
404 base::FilePath path = download_item_->GetTargetFilePath(); | |
405 return path.MatchesExtension(FILE_PATH_LITERAL(".pdf")); | |
406 } | |
407 #endif | |
408 | |
409 bool DownloadShelfContextMenu::CanOpenPdfInSystemViewer() const { | |
410 #if defined(OS_WIN) | |
411 return IsDownloadPdf() && | |
412 (IsAdobeReaderDefaultPDFViewer() ? is_adobe_pdf_reader_up_to_date_ : | |
413 true); | |
414 #elif defined(OS_MACOSX) || defined(OS_LINUX) | |
415 return IsDownloadPdf(); | |
416 #endif | |
417 } | |
OLD | NEW |