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