Propagate server response error and interrupt the download.

content/browser/download/parallel_download_job.cc

 // Copyright 2017 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 "content/browser/download/parallel_download_job.h"
 
 #include "base/memory/ptr_util.h"
 #include "content/browser/download/download_create_info.h"
 #include "content/browser/download/parallel_download_utils.h"
 #include "content/public/browser/browser_context.h"
@@ skipping 31 matching lines @@
 
 void ParallelDownloadJob::Resume(bool resume_request) {
   DownloadJobImpl::Resume(resume_request);
   if (!resume_request)
     return;
 
   for (auto& worker : workers_)
     worker->Resume();
 }
 
+void ParallelDownloadJob::OnServerResponseError(
+    DownloadWorker* worker,
+    DownloadInterruptReason reason) {
+  // TODO(xingliu): Consider to let the original request to cover the full

[David Trainor- moved to gerrit, 2017/03/14 18:01:43]

Would this ever depend on how much content we've 'wasted'?  Do we retry the job?

[xingliu, 2017/03/14 21:33:21]

Yes, we have the logic to limit the length of preceding streams in
DownloadFileImpl when later streams starts, so we don't waste more data. 

When we report an error, DownloadItemImpl may restart the whole download.
Added a TODO for retry, retry makes sense for certain error.

Ideally if we refactor the DownloadItemImpl and Job owns File, then complex
stream control can be done cleanly.

+  // content if the sub-requests get invalid response.
+  DownloadJob::Interrupt(reason);
+}
+
 void ParallelDownloadJob::ForkRequestsForNewDownload(int64_t bytes_received,
                                                      int64_t total_bytes,
                                                      int request_count) {
   if (!download_item_ || total_bytes <= 0 || bytes_received >= total_bytes ||
       request_count <= 1) {
     return;
   }
 
   int64_t bytes_left = total_bytes - bytes_received;
   int64_t slice_size = bytes_left / request_count;
   slice_size = slice_size > 0 ? slice_size : 1;
   int num_requests = bytes_left / slice_size;
   int64_t current_offset = bytes_received + slice_size;
 
-  // TODO(xingliu): Add records for slices in history db.
   for (int i = 0; i < num_requests - 1; ++i) {
     int64_t length = (i == (num_requests - 2))
                          ? slice_size + (bytes_left % slice_size)
                          : slice_size;
     CreateRequest(current_offset, length);
     current_offset += slice_size;
   }
 }
 
 void ParallelDownloadJob::BuildParallelRequests() {
@@ skipping 16 matching lines @@
     // new requests. For the remaining slices, they will be handled once some
     // of the workers finish their job.
   } else {
     // TODO(qinmin): Check the size of the last slice. If it is huge, we can
     // split it into N pieces and pass the last N-1 pirces to different workers.
     // Otherwise, just fork |slices_to_download.size()| number of workers.
   }
 }
 
 void ParallelDownloadJob::CreateRequest(int64_t offset, int64_t length) {
-  std::unique_ptr<DownloadWorker> worker = base::MakeUnique<DownloadWorker>();
+  std::unique_ptr<DownloadWorker> worker =
+      base::MakeUnique<DownloadWorker>(this, offset, length);
 
   DCHECK(download_item_);
   StoragePartition* storage_partition =
       BrowserContext::GetStoragePartitionForSite(
           download_item_->GetBrowserContext(), download_item_->GetSiteUrl());
 
   std::unique_ptr<DownloadUrlParameters> download_params(
       new DownloadUrlParameters(download_item_->GetURL(),
                                 storage_partition->GetURLRequestContext()));
   download_params->set_file_path(download_item_->GetFullPath());
   download_params->set_last_modified(download_item_->GetLastModifiedTime());
   download_params->set_etag(download_item_->GetETag());
   download_params->set_offset(offset);
 
   // Setting the length will result in range request to fetch a slice of the
   // file.
   download_params->set_length(length);
 
   // Subsequent range requests have the same referrer URL as the original
   // download request.
   download_params->set_referrer(Referrer(download_item_->GetReferrerUrl(),
                                          blink::WebReferrerPolicyAlways));
   // Send the request.
   worker->SendRequest(std::move(download_params));
   workers_.push_back(std::move(worker));
 }
 
 }  // namespace content