[Resumption 11/12] Support resuming interrupted downloads from the downloads shelf.

chrome/browser/download/download_shelf_context_menu.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/download/download_shelf_context_menu.h"
 
+#include "base/command_line.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/download/download_crx_util.h"
 #include "chrome/browser/download/download_item_model.h"
 #include "chrome/browser/download/download_prefs.h"
 #include "chrome/browser/safe_browsing/download_protection_service.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/download_item.h"
 #include "content/public/browser/download_manager.h"
 #include "content/public/browser/page_navigator.h"
+#include "content/public/common/content_switches.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using content::DownloadItem;
 using extensions::Extension;
 
+namespace {
+
+// Returns true if downloads resumption is enabled.
+bool IsDownloadResumptionEnabled() {
+  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+  return command_line.HasSwitch(switches::kEnableDownloadResumption);
+}
+
+} // namespace
+
 DownloadShelfContextMenu::~DownloadShelfContextMenu() {
   DetachFromDownloadItem();
 }
 
 DownloadShelfContextMenu::DownloadShelfContextMenu(
     DownloadItem* download_item,
     content::PageNavigator* navigator)
     : download_item_(download_item),
       navigator_(navigator) {
   DCHECK(download_item_);
@@ skipping 32 matching lines @@
     case OPEN_WHEN_COMPLETE:
       return download_item_->CanOpenDownload() &&
           !download_crx_util::IsExtensionDownload(*download_item_);
     case ALWAYS_OPEN_TYPE:
       // For temporary downloads, the target filename might be a temporary
       // filename. Don't base an "Always open" decision based on it. Also
       // exclude extensions.
       return download_item_->CanOpenDownload() &&
           !download_crx_util::IsExtensionDownload(*download_item_);
     case CANCEL:
-      return download_item_->IsPartialDownload();
+      return download_item_->IsPartialDownload() || download_item_->CanResume();

[Randy Smith (Not in Mondays), 2013/06/04 17:08:59]

Why not IsInterrupted() instead of CanResume()?  Seems more accurate to my
uneducated eye.  

[asanka, 2013/06/04 18:52:39]

In theory, IsPartialDownload() should imply that the download can be cancelled.
Thus the additional check should be unnecessary. That'll be fixed in an upcoming
CL. I can consider landing that beforehand since that would make the code
clearer.

Without that CL, CanResume() takes into consideration whether the download can
be resumed at all. Thus the option to cancel is only offered if its expected to
do something. IsInterrupted() would unconditionally offer to cancel interrupted
downloads. I've added a check to see if resumption is enabled so that in the
absence of the flag, the previous behavior is preserved.

[Randy Smith (Not in Mondays), 2013/06/05 20:05:34]

SGTM; I'm neutral about the order the CLs are landed in.
So long-term I'm uncomfortable with this, just because I think it's confusing
for some interrupted downloads to be cancelable and some not.  I guess I'll just
say that long-term you should think about potential confusion on the user end,
and make sure that the UI gives clues about why a download can/cannot be
resumed/cancelled.

[asanka, 2013/06/05 20:09:27]

Yup. Long term all interrupted downloads will be resumable (they would at least
attempt to restart). The constraint imposed by requiring the corresponding
WebContents to stick around will go away soon. The confusion should be
temporary.

     case TOGGLE_PAUSE:
       return download_item_->GetState() == DownloadItem::IN_PROGRESS;
+    case RESUME_INTERRUPTED:
+      return download_item_->CanResume();

[Randy Smith (Not in Mondays), 2013/06/04 17:08:59]

This is true for IN_PROGRESS downloads as well.  Won't that mean that both the
TOGGLE_PAUSE and RESUME_INTERRUPTED menus show up in the shelf for IN_PROGRESS
downloads?

[asanka, 2013/06/04 18:52:39]

IsCommandIdEnabled() is only called on items that have already been added to a
menu. I've added an additional condition to make sure.

[Randy Smith (Not in Mondays), 2013/06/05 20:05:34]

Ah, sorry, missed that.  

     case DISCARD:
     case KEEP:
     case LEARN_MORE_SCANNING:
     case LEARN_MORE_INTERRUPTED:
       return true;
   }
   return false;
 }
 
 bool DownloadShelfContextMenu::IsCommandIdChecked(int command_id) const {
@@ skipping 40 matching lines @@
       // It is possible for the download to complete before the user clicks the
       // menu item, recheck if the download is in progress state before toggling
       // pause.
       if (download_item_->IsPartialDownload()) {
         if (download_item_->IsPaused())
           download_item_->Resume();
         else
           download_item_->Pause();
       }
       break;
+    case RESUME_INTERRUPTED:
+      // Check again, in case the download was cancelled before the user clicks
+      // the menu item. Also, it's possible the download automatically resumed
+      // in the meantime.
+      if (download_item_->CanResume())
+        download_item_->Resume();

[Randy Smith (Not in Mondays), 2013/06/04 17:08:59]

Any reason not to just unilaterally resume?  It looks like the resume code is a
no-op in the cases you care about.

[asanka, 2013/06/04 18:52:39]

Done.

+      break;
     case DISCARD:
       download_item_->Remove();
       break;
     case KEEP:
       download_item_->ValidateDangerousDownload();
       break;
     case LEARN_MORE_SCANNING: {
 #if defined(FULL_SAFE_BROWSING)
       using safe_browsing::DownloadProtectionService;
       SafeBrowsingService* sb_service =
@@ skipping 39 matching lines @@
         return l10n_util::GetStringUTF16(IDS_DOWNLOAD_MENU_OPEN_WHEN_COMPLETE);
       return l10n_util::GetStringUTF16(IDS_DOWNLOAD_MENU_OPEN);
     case ALWAYS_OPEN_TYPE:
       return l10n_util::GetStringUTF16(IDS_DOWNLOAD_MENU_ALWAYS_OPEN_TYPE);
     case CANCEL:
       return l10n_util::GetStringUTF16(IDS_DOWNLOAD_MENU_CANCEL);
     case TOGGLE_PAUSE:
       if (download_item_ && download_item_->IsPaused())
         return l10n_util::GetStringUTF16(IDS_DOWNLOAD_MENU_RESUME_ITEM);
       return l10n_util::GetStringUTF16(IDS_DOWNLOAD_MENU_PAUSE_ITEM);
+    case RESUME_INTERRUPTED:
+      return l10n_util::GetStringUTF16(IDS_DOWNLOAD_MENU_RESUME_ITEM);
     case DISCARD:
       return l10n_util::GetStringUTF16(IDS_DOWNLOAD_MENU_DISCARD);
     case KEEP:
       return l10n_util::GetStringUTF16(IDS_DOWNLOAD_MENU_KEEP);
     case LEARN_MORE_SCANNING:
       return l10n_util::GetStringUTF16(IDS_DOWNLOAD_MENU_LEARN_MORE_SCANNING);
     case LEARN_MORE_INTERRUPTED:
       return l10n_util::GetStringUTF16(
           IDS_DOWNLOAD_MENU_LEARN_MORE_INTERRUPTED);
   }
@@ skipping 50 matching lines @@
   finished_download_menu_model_->AddItemWithStringId(
       SHOW_IN_FOLDER, IDS_DOWNLOAD_MENU_SHOW);
   finished_download_menu_model_->AddSeparator(ui::NORMAL_SEPARATOR);
   finished_download_menu_model_->AddItemWithStringId(
       CANCEL, IDS_DOWNLOAD_MENU_CANCEL);
 
   return finished_download_menu_model_.get();
 }
 
 ui::SimpleMenuModel* DownloadShelfContextMenu::GetInterruptedMenuModel() {
-#if defined(OS_WIN)
-  // The Help Center article is currently Windows specific.
-  // TODO(asanka): Enable this for other platforms when the article is expanded
-  // for other platforms.
+#if !defined(OS_WIN)
+  // If resumption isn't enabled and we aren't on Windows, then none of the
+  // options here are applicable.
+  if (!IsDownloadResumptionEnabled())
+    return GetInProgressMenuModel();
+#endif
+
   if (interrupted_download_menu_model_)
     return interrupted_download_menu_model_.get();
 
   interrupted_download_menu_model_.reset(new ui::SimpleMenuModel(this));
 
+  if (IsDownloadResumptionEnabled()) {
+    interrupted_download_menu_model_->AddItemWithStringId(
+        RESUME_INTERRUPTED, IDS_DOWNLOAD_MENU_RESUME_ITEM);
+  }
+#if defined(OS_WIN)
+  // The Help Center article is currently Windows specific.
+  // TODO(asanka): Enable this for other platforms when the article is expanded
+  // for other platforms.
   interrupted_download_menu_model_->AddItemWithStringId(
       LEARN_MORE_INTERRUPTED, IDS_DOWNLOAD_MENU_LEARN_MORE_INTERRUPTED);
+#endif
+  if (IsDownloadResumptionEnabled()) {
+    interrupted_download_menu_model_->AddSeparator(ui::NORMAL_SEPARATOR);
+    interrupted_download_menu_model_->AddItemWithStringId(
+        CANCEL, IDS_DOWNLOAD_MENU_CANCEL);
+  }
 
   return interrupted_download_menu_model_.get();
-#else
-  return GetInProgressMenuModel();
-#endif
 }
 
 ui::SimpleMenuModel* DownloadShelfContextMenu::GetMaliciousMenuModel() {
   if (malicious_download_menu_model_)
     return malicious_download_menu_model_.get();
 
   malicious_download_menu_model_.reset(new ui::SimpleMenuModel(this));
 
   malicious_download_menu_model_->AddItemWithStringId(
       DISCARD, IDS_DOWNLOAD_MENU_DISCARD);
   malicious_download_menu_model_->AddItemWithStringId(
       KEEP, IDS_DOWNLOAD_MENU_KEEP);
   malicious_download_menu_model_->AddSeparator(ui::NORMAL_SEPARATOR);
   malicious_download_menu_model_->AddItemWithStringId(
       LEARN_MORE_SCANNING, IDS_DOWNLOAD_MENU_LEARN_MORE_SCANNING);
 
   return malicious_download_menu_model_.get();
 }