chrome/browser/download/download_shelf_context_menu.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/download/download_shelf_context_menu.h"
   6
   7 #include "base/command_line.h"
   8 #include "chrome/browser/download/download_item_model.h"
   9 #include "chrome/grit/generated_resources.h"
  10 #include "content/public/common/content_switches.h"
  11 #include "extensions/common/extension.h"
  12 #include "ui/base/l10n/l10n_util.h"
  13
  14 #if defined(OS_WIN)
  15 #include "chrome/browser/ui/pdf/adobe_reader_info_win.h"
  16 #endif
  17
  18 using content::DownloadItem;
  19
  20 namespace {
  21
  22 // Returns true if downloads resumption is enabled.
  23 bool IsDownloadResumptionEnabled() {
  24   return base::CommandLine::ForCurrentProcess()->HasSwitch(
  25       switches::kEnableDownloadResumption);
  26 }
  27
  28 }  // namespace
  29
  30 DownloadShelfContextMenu::~DownloadShelfContextMenu() {
  31   DetachFromDownloadItem();
  32 }
  33
  34 DownloadShelfContextMenu::DownloadShelfContextMenu(DownloadItem* download_item)
  35     : download_item_(download_item),
  36       download_commands_(new DownloadCommands(download_item)) {
  37   DCHECK(download_item_);
  38   download_item_->AddObserver(this);
  39 }
  40
  41 ui::SimpleMenuModel* DownloadShelfContextMenu::GetMenuModel() {
  42   ui::SimpleMenuModel* model = NULL;
  43
  44   if (!download_item_)
  45     return NULL;
  46
  47   DownloadItemModel download_model(download_item_);
  48   // We shouldn't be opening a context menu for a dangerous download, unless it
  49   // is a malicious download.
  50   DCHECK(!download_model.IsDangerous() || download_model.MightBeMalicious());
  51
  52   if (download_model.IsMalicious())
  53     model = GetMaliciousMenuModel();
  54   else if (download_model.MightBeMalicious())
  55     model = GetMaybeMaliciousMenuModel();
  56   else if (download_item_->GetState() == DownloadItem::COMPLETE)
  57     model = GetFinishedMenuModel();
  58   else if (download_item_->GetState() == DownloadItem::INTERRUPTED)
  59     model = GetInterruptedMenuModel();
  60   else if (download_item_->IsPaused())
  61     model = GetInProgressPausedMenuModel();
  62   else
  63     model = GetInProgressMenuModel();
  64   return model;
  65 }
  66
  67 bool DownloadShelfContextMenu::IsCommandIdEnabled(int command_id) const {
  68   if (!download_commands_)
  69     return false;
  70
  71   return download_commands_->IsCommandEnabled(
  72       static_cast<DownloadCommands::Command>(command_id));
  73 }
  74
  75 bool DownloadShelfContextMenu::IsCommandIdChecked(int command_id) const {
  76   if (!download_commands_)
  77     return false;
  78
  79   return download_commands_->IsCommandChecked(
  80       static_cast<DownloadCommands::Command>(command_id));
  81 }
  82
  83 bool DownloadShelfContextMenu::IsCommandIdVisible(int command_id) const {
  84   if (!download_commands_)
  85     return false;
  86
  87   return download_commands_->IsCommandVisible(
  88       static_cast<DownloadCommands::Command>(command_id));
  89 }
  90
  91 void DownloadShelfContextMenu::ExecuteCommand(int command_id, int event_flags) {
  92   if (!download_commands_)
  93     return;
  94
  95   download_commands_->ExecuteCommand(
  96       static_cast<DownloadCommands::Command>(command_id));
  97 }
  98
  99 bool DownloadShelfContextMenu::GetAcceleratorForCommandId(
 100     int command_id,
 101     ui::Accelerator* accelerator) {
 102   return false;
 103 }
 104
 105 bool DownloadShelfContextMenu::IsItemForCommandIdDynamic(int command_id) const {
 106   return false;
 107 }
 108
 109 base::string16 DownloadShelfContextMenu::GetLabelForCommandId(
 110     int command_id) const {
 111   int id = -1;
 112
 113   switch (static_cast<DownloadCommands::Command>(command_id)) {
 114     case DownloadCommands::OPEN_WHEN_COMPLETE:
 115       if (download_item_ && !download_item_->IsDone())
 116         id = IDS_DOWNLOAD_MENU_OPEN_WHEN_COMPLETE;
 117       else
 118         id = IDS_DOWNLOAD_MENU_OPEN;
 119       break;
 120     case DownloadCommands::PAUSE:
 121       id = IDS_DOWNLOAD_MENU_PAUSE_ITEM;
 122       break;
 123     case DownloadCommands::RESUME:
 124       id = IDS_DOWNLOAD_MENU_RESUME_ITEM;
 125       break;
 126     case DownloadCommands::SHOW_IN_FOLDER:
 127       id = IDS_DOWNLOAD_MENU_SHOW;
 128       break;
 129     case DownloadCommands::DISCARD:
 130       id = IDS_DOWNLOAD_MENU_DISCARD;
 131       break;
 132     case DownloadCommands::KEEP:
 133       id = IDS_DOWNLOAD_MENU_KEEP;
 134       break;
 135     case DownloadCommands::ALWAYS_OPEN_TYPE: {
 136       if (download_commands_) {
 137         bool can_open_pdf_in_system_viewer =
 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();
 171   }
 172   CHECK(id != -1);
 173   return l10n_util::GetStringUTF16(id);
 174 }
 175
 176 void DownloadShelfContextMenu::DetachFromDownloadItem() {
 177   if (!download_item_)
 178     return;
 179
 180   download_commands_.reset();
 181   download_item_->RemoveObserver(this);
 182   download_item_ = NULL;
 183 }
 184
 185 void DownloadShelfContextMenu::OnDownloadDestroyed(DownloadItem* download) {
 186   DCHECK(download_item_ == download);
 187   DetachFromDownloadItem();
 188 }
 189
 190 ui::SimpleMenuModel* DownloadShelfContextMenu::GetInProgressMenuModel() {
 191   if (in_progress_download_menu_model_)
 192     return in_progress_download_menu_model_.get();
 193
 194   in_progress_download_menu_model_.reset(new ui::SimpleMenuModel(this));
 195
 196   in_progress_download_menu_model_->AddCheckItem(
 197       DownloadCommands::OPEN_WHEN_COMPLETE,
 198       GetLabelForCommandId(DownloadCommands::OPEN_WHEN_COMPLETE));
 199   in_progress_download_menu_model_->AddCheckItem(
 200       DownloadCommands::ALWAYS_OPEN_TYPE,
 201       GetLabelForCommandId(DownloadCommands::ALWAYS_OPEN_TYPE));
 202   in_progress_download_menu_model_->AddSeparator(ui::NORMAL_SEPARATOR);
 203   in_progress_download_menu_model_->AddItem(
 204       DownloadCommands::PAUSE, GetLabelForCommandId(DownloadCommands::PAUSE));
 205   in_progress_download_menu_model_->AddItem(
 206       DownloadCommands::SHOW_IN_FOLDER,
 207       GetLabelForCommandId(DownloadCommands::SHOW_IN_FOLDER));
 208   in_progress_download_menu_model_->AddSeparator(ui::NORMAL_SEPARATOR);
 209   in_progress_download_menu_model_->AddItem(
 210       DownloadCommands::CANCEL, GetLabelForCommandId(DownloadCommands::CANCEL));
 211
 212   return in_progress_download_menu_model_.get();
 213 }
 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
 240 ui::SimpleMenuModel* DownloadShelfContextMenu::GetFinishedMenuModel() {
 241   if (finished_download_menu_model_)
 242     return finished_download_menu_model_.get();
 243
 244   finished_download_menu_model_.reset(new ui::SimpleMenuModel(this));
 245
 246   finished_download_menu_model_->AddItem(
 247       DownloadCommands::OPEN_WHEN_COMPLETE,
 248       GetLabelForCommandId(DownloadCommands::OPEN_WHEN_COMPLETE));
 249   finished_download_menu_model_->AddCheckItem(
 250       DownloadCommands::ALWAYS_OPEN_TYPE,
 251       GetLabelForCommandId(DownloadCommands::ALWAYS_OPEN_TYPE));
 252   finished_download_menu_model_->AddItem(
 253       DownloadCommands::PLATFORM_OPEN,
 254       GetLabelForCommandId(DownloadCommands::PLATFORM_OPEN));
 255   finished_download_menu_model_->AddSeparator(ui::NORMAL_SEPARATOR);
 256   finished_download_menu_model_->AddItem(
 257       DownloadCommands::SHOW_IN_FOLDER,
 258       GetLabelForCommandId(DownloadCommands::SHOW_IN_FOLDER));
 259   finished_download_menu_model_->AddSeparator(ui::NORMAL_SEPARATOR);
 260   finished_download_menu_model_->AddItem(
 261       DownloadCommands::CANCEL, GetLabelForCommandId(DownloadCommands::CANCEL));
 262
 263   return finished_download_menu_model_.get();
 264 }
 265
 266 ui::SimpleMenuModel* DownloadShelfContextMenu::GetInterruptedMenuModel() {
 267 #if !defined(OS_WIN)
 268   // If resumption isn't enabled and we aren't on Windows, then none of the
 269   // options here are applicable.
 270   if (!IsDownloadResumptionEnabled())
 271     return GetInProgressMenuModel();
 272 #endif
 273
 274   if (interrupted_download_menu_model_)
 275     return interrupted_download_menu_model_.get();
 276
 277   interrupted_download_menu_model_.reset(new ui::SimpleMenuModel(this));
 278
 279   if (IsDownloadResumptionEnabled()) {
 280     interrupted_download_menu_model_->AddItem(
 281         DownloadCommands::RESUME,
 282         GetLabelForCommandId(DownloadCommands::RESUME));
 283   }
 284 #if defined(OS_WIN)
 285   // The Help Center article is currently Windows specific.
 286   // TODO(asanka): Enable this for other platforms when the article is expanded
 287   // for other platforms.
 288   interrupted_download_menu_model_->AddItem(
 289       DownloadCommands::LEARN_MORE_INTERRUPTED,
 290       GetLabelForCommandId(DownloadCommands::LEARN_MORE_INTERRUPTED));
 291 #endif
 292   if (IsDownloadResumptionEnabled()) {
 293     interrupted_download_menu_model_->AddSeparator(ui::NORMAL_SEPARATOR);
 294     interrupted_download_menu_model_->AddItem(
 295         DownloadCommands::CANCEL,
 296         GetLabelForCommandId(DownloadCommands::CANCEL));
 297   }
 298
 299   return interrupted_download_menu_model_.get();
 300 }
 301
 302 ui::SimpleMenuModel* DownloadShelfContextMenu::GetMaybeMaliciousMenuModel() {
 303   if (maybe_malicious_download_menu_model_)
 304     return maybe_malicious_download_menu_model_.get();
 305
 306   maybe_malicious_download_menu_model_.reset(new ui::SimpleMenuModel(this));
 307
 308   maybe_malicious_download_menu_model_->AddItem(
 309       DownloadCommands::KEEP, GetLabelForCommandId(DownloadCommands::KEEP));
 310   maybe_malicious_download_menu_model_->AddSeparator(ui::NORMAL_SEPARATOR);
 311   maybe_malicious_download_menu_model_->AddItem(
 312       DownloadCommands::LEARN_MORE_SCANNING,
 313       GetLabelForCommandId(DownloadCommands::LEARN_MORE_SCANNING));
 314   return maybe_malicious_download_menu_model_.get();
 315 }
 316
 317 ui::SimpleMenuModel* DownloadShelfContextMenu::GetMaliciousMenuModel() {
 318   if (malicious_download_menu_model_)
 319     return malicious_download_menu_model_.get();
 320
 321   malicious_download_menu_model_.reset(new ui::SimpleMenuModel(this));
 322   malicious_download_menu_model_->AddItem(
 323       DownloadCommands::LEARN_MORE_SCANNING,
 324       GetLabelForCommandId(DownloadCommands::LEARN_MORE_SCANNING));
 325
 326   return malicious_download_menu_model_.get();
 327 }