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
+  // content if the sub-requests get invalid response. Consider retry on certain
+  // error.
+  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