Add slice information to DownloadDestinationObserver::DestinationUpdate().

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 1025 matching lines @@
   total_bytes_ = total_bytes;
 }
 
 void DownloadItemImpl::OnAllDataSaved(
     int64_t total_bytes,
     std::unique_ptr<crypto::SecureHash> hash_state) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!all_data_saved_);
   all_data_saved_ = true;
   SetTotalBytes(total_bytes);
-  UpdateProgress(total_bytes, 0);
+  UpdateProgress(total_bytes, 0, std::vector<DownloadItem::ReceivedSlice>());
   SetHashState(std::move(hash_state));
   hash_state_.reset();  // No need to retain hash_state_ since we are done with
                         // the download and don't expect to receive any more
                         // data.
 
   DVLOG(20) << __func__ << "() download=" << DebugString(true);
   UpdateObservers();
 }
 
 void DownloadItemImpl::MarkAsComplete() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   DCHECK(all_data_saved_);
   end_time_ = base::Time::Now();
   TransitionTo(COMPLETE_INTERNAL);
   UpdateObservers();
 }
 
-void DownloadItemImpl::DestinationUpdate(int64_t bytes_so_far,
-                                         int64_t bytes_per_sec) {
+void DownloadItemImpl::DestinationUpdate(
+    int64_t bytes_so_far,
+    int64_t bytes_per_sec,
+    const std::vector<DownloadItem::ReceivedSlice>& received_slices) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // If the download is in any other state we don't expect any
   // DownloadDestinationObserver callbacks. An interruption or a cancellation
   // results in a call to ReleaseDownloadFile which invalidates the weak
   // reference held by the DownloadFile and hence cuts off any pending
   // callbacks.
   DCHECK(state_ == TARGET_PENDING_INTERNAL || state_ == IN_PROGRESS_INTERNAL);
 
   // There must be no pending destination_error_.
   DCHECK_EQ(destination_error_, DOWNLOAD_INTERRUPT_REASON_NONE);
 
   DVLOG(20) << __func__ << "() so_far=" << bytes_so_far
             << " per_sec=" << bytes_per_sec
             << " download=" << DebugString(true);
 
-  UpdateProgress(bytes_so_far, bytes_per_sec);
+  UpdateProgress(bytes_so_far, bytes_per_sec, received_slices);
   if (net_log_.IsCapturing()) {
     net_log_.AddEvent(
         net::NetLogEventType::DOWNLOAD_ITEM_UPDATED,
         net::NetLog::Int64Callback("bytes_so_far", received_bytes_));
   }
 
   UpdateObservers();
 }
 
 void DownloadItemImpl::DestinationError(
@@ skipping 124 matching lines @@
         new_create_info.save_info->hash_state
             ? new_create_info.save_info->hash_state->Clone()
             : nullptr;
 
     // Interrupted downloads also need a target path.
     if (target_path_.empty()) {
       received_bytes_ = offset;
       hash_state_ = std::move(hash_state);
       hash_.clear();
       destination_error_ = new_create_info.result;
+      received_slices_.clear();
       TransitionTo(INTERRUPTED_TARGET_PENDING_INTERNAL);
       DetermineDownloadTarget();
       return;
     }
 
     // Otherwise, this was a resumption attempt which ended with an
     // interruption. Continue with current target path.
     TransitionTo(TARGET_RESOLVED_INTERNAL);
     InterruptWithPartialState(
         offset, std::move(hash_state), new_create_info.result);
@@ skipping 26 matching lines @@
   DVLOG(20) << __func__
             << "() result:" << DownloadInterruptReasonToString(result);
   if (result != DOWNLOAD_INTERRUPT_REASON_NONE) {
     // Whoops. That didn't work. Proceed as an interrupted download, but reset
     // the partial state. Currently, the partial stub cannot be recovered if the
     // download file initialization fails.
     received_bytes_ = 0;
     hash_state_.reset();
     hash_.clear();
     destination_error_ = result;
+    received_slices_.clear();
     TransitionTo(INTERRUPTED_TARGET_PENDING_INTERNAL);
   }
 
   DetermineDownloadTarget();
 }
 
 void DownloadItemImpl::DetermineDownloadTarget() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DVLOG(20) << __func__ << "() " << DebugString(true);
 
@@ skipping 348 matching lines @@
   // after we download all the data, and b) if there were, that would probably
   // simply result in a null range request, which would generate a
   // DestinationCompleted() notification from the DownloadFile, which would
   // behave properly with setting all_data_saved_ to false here.
   all_data_saved_ = false;
 
   if (current_path_.empty()) {
     hash_state_.reset();
     hash_.clear();
     received_bytes_ = 0;
+    received_slices_.clear();
   } else {
-    UpdateProgress(bytes_so_far, 0);
+    UpdateProgress(bytes_so_far, 0, std::vector<DownloadItem::ReceivedSlice>());
     SetHashState(std::move(hash_state));
   }
 
   if (request_handle_)
     request_handle_->CancelRequest();
 
   if (reason == DOWNLOAD_INTERRUPT_REASON_USER_CANCELED ||
       reason == DOWNLOAD_INTERRUPT_REASON_USER_SHUTDOWN) {
     if (IsDangerous()) {
       RecordDangerousDownloadDiscard(
           reason == DOWNLOAD_INTERRUPT_REASON_USER_CANCELED
               ? DOWNLOAD_DISCARD_DUE_TO_USER_ACTION
               : DOWNLOAD_DISCARD_DUE_TO_SHUTDOWN,
           GetDangerType(), GetTargetFilePath());
     }
 
     RecordDownloadCount(CANCELLED_COUNT);
     TransitionTo(CANCELLED_INTERNAL);
     return;
   }
 
   RecordDownloadInterrupted(reason, received_bytes_, total_bytes_);
   if (!GetWebContents())
     RecordDownloadCount(INTERRUPTED_WITHOUT_WEBCONTENTS);
 
   TransitionTo(INTERRUPTED_INTERNAL);
   AutoResumeIfValid();
 }
 
-void DownloadItemImpl::UpdateProgress(int64_t bytes_so_far,
-                                      int64_t bytes_per_sec) {
+void DownloadItemImpl::UpdateProgress(
+    int64_t bytes_so_far,
+    int64_t bytes_per_sec,
+    const std::vector<DownloadItem::ReceivedSlice>& received_slices) {
   received_bytes_ = bytes_so_far;
   bytes_per_sec_ = bytes_per_sec;
 
   // If we've received more data than we were expecting (bad server info?),
   // revert to 'unknown size mode'.
   if (received_bytes_ > total_bytes_)
     total_bytes_ = 0;
+
+  received_slices_ = received_slices;
 }
 
 void DownloadItemImpl::SetHashState(
     std::unique_ptr<crypto::SecureHash> hash_state) {
   hash_state_ = std::move(hash_state);
   if (!hash_state_) {
     hash_.clear();
     return;
   }
 
@@ skipping 225 matching lines @@
 
   // Reset the appropriate state if restarting.
   ResumeMode mode = GetResumeMode();
   if (mode == RESUME_MODE_IMMEDIATE_RESTART ||
       mode == RESUME_MODE_USER_RESTART) {
     received_bytes_ = 0;
     last_modified_time_.clear();
     etag_.clear();
     hash_.clear();
     hash_state_.reset();
+    received_slices_.clear();
   }
 
   StoragePartition* storage_partition =
       BrowserContext::GetStoragePartitionForSite(GetBrowserContext(),
                                                  site_url_);
 
   // Avoid using the WebContents even if it's still around. Resumption requests
   // are consistently routed through the no-renderer code paths so that the
   // request will not be dropped if the WebContents (and by extension, the
   // associated renderer) goes away before a response is received.
@@ skipping 192 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