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