[Downloads] Do not store error responses during resumption.

content/browser/download/download_item_impl.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.
 
 // File method ordering: Methods in this file are in the same order as
 // in download_item_impl.h, with the following exception: The public
 // interface Start is placed in chronological order with the other
 // (private) routines that together define a DownloadItem's state
 // transitions as the download progresses.  See "Download progression
 // cascade" later in this file.
@@ skipping 355 matching lines @@
 
     case COMPLETING_INTERNAL:
     case COMPLETE_INTERNAL:
     case CANCELLED_INTERNAL:
     case RESUMING_INTERNAL:
       return;
 
     case INTERRUPTED_INTERNAL:
       auto_resume_count_ = 0;  // User input resets the counter.
       ResumeInterruptedDownload();
+      UpdateObservers();

[svaldez, 2016/01/13 17:29:18]

Does this need to go at the bottom of "AutoResumeIfValid"?

[asanka, 2016/01/28 02:24:17]

Nope. AutoResumeIfValid() may or may not resume the download depending on
whether the download can be resumed automatically. Since it's called after the
download is interrupted, the observers should be updated regardless of what
AutoResumeIfValid() does. Since it's a bit out of place for AutoResumeIfValid()
to update observers if it doesn't do anything, we've placed the
UpdateObservers() call after the AutoResumeIfValid() call. That way, when the
observers are updated, they will see that the download is either interrupted or
{in-progress but with a potentially new interrupt reason}.

       return;
 
     case MAX_DOWNLOAD_INTERNAL_STATE:
       NOTREACHED();
   }
 }
 
 void DownloadItemImpl::Cancel(bool user_cancel) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
@@ skipping 500 matching lines @@
         mode = RESUME_MODE_USER_RESTART;
       else
         mode = RESUME_MODE_IMMEDIATE_RESTART;
       break;
 
     case DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED:
     case DOWNLOAD_INTERRUPT_REASON_NETWORK_DISCONNECTED:
     case DOWNLOAD_INTERRUPT_REASON_NETWORK_SERVER_DOWN:
     case DOWNLOAD_INTERRUPT_REASON_NETWORK_INVALID_REQUEST:
     case DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED:
+    case DOWNLOAD_INTERRUPT_REASON_SERVER_UNREACHABLE:
     case DOWNLOAD_INTERRUPT_REASON_USER_SHUTDOWN:
     case DOWNLOAD_INTERRUPT_REASON_CRASH:
       if (force_restart)
         mode = RESUME_MODE_USER_RESTART;
       else
         mode = RESUME_MODE_USER_CONTINUE;
       break;
 
     case DOWNLOAD_INTERRUPT_REASON_FILE_FAILED:
     case DOWNLOAD_INTERRUPT_REASON_FILE_ACCESS_DENIED:
@@ skipping 505 matching lines @@
 void DownloadItemImpl::OnResumeRequestStarted(
     DownloadItem* item,
     DownloadInterruptReason interrupt_reason) {
   // If |item| is not NULL, then Start() has been called already, and nothing
   // more needs to be done here.
   if (item) {
     DCHECK_EQ(DOWNLOAD_INTERRUPT_REASON_NONE, interrupt_reason);
     DCHECK_EQ(static_cast<DownloadItem*>(this), item);
     return;
   }
+
   // Otherwise, the request failed without passing through
   // DownloadResourceHandler::OnResponseStarted.
   DCHECK_NE(DOWNLOAD_INTERRUPT_REASON_NONE, interrupt_reason);
   Interrupt(interrupt_reason);
 }
 
 // **** End of Download progression cascade
 
 // An error occurred somewhere.
 void DownloadItemImpl::Interrupt(DownloadInterruptReason reason) {
@@ skipping 355 matching lines @@
     case RESUME_MODE_USER_CONTINUE:
       return "USER_CONTINUE";
     case RESUME_MODE_USER_RESTART:
       return "USER_RESTART";
   }
   NOTREACHED() << "Unknown resume mode " << mode;
   return "unknown";
 }
 
 }  // namespace content