Add UMA for estimating disk bandwidth and the time saved with parallel download

content/browser/download/download_file_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.
 
 #include "content/browser/download/download_file_impl.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 53 matching lines @@
     bool is_sparse_file,
     base::WeakPtr<DownloadDestinationObserver> observer)
     : net_log_(
           net::NetLogWithSource::Make(download_item_net_log.net_log(),
                                       net::NetLogSourceType::DOWNLOAD_FILE)),
       file_(net_log_),
       save_info_(std::move(save_info)),
       default_download_directory_(default_download_directory),
       is_sparse_file_(is_sparse_file),
       bytes_seen_(0),
+      num_active_streams_(0),
+      bytes_seen_with_parallel_streams_(0),
+      bytes_seen_without_parallel_streams_(0),
       received_slices_(received_slices),
       observer_(observer),
       weak_factory_(this) {
   source_streams_[save_info_->offset] = base::MakeUnique<SourceStream>(
       save_info_->offset, DownloadSaveInfo::kLengthFullContent);
   DCHECK(source_streams_.size() == static_cast<size_t>(1));
   source_streams_[save_info_->offset]->SetByteStream(std::move(stream_reader));
 
   download_item_net_log.AddEvent(
       net::NetLogEventType::DOWNLOAD_FILE_CREATED,
@@ skipping 226 matching lines @@
               source_stream->bytes_written() +
                       static_cast<int64_t>(incoming_data_size) >=
                   source_stream->length()) {
             should_terminate = true;
             incoming_data_size =
                 source_stream->length() - source_stream->bytes_written();
           }
           reason = WriteDataToFile(
               source_stream->offset() + source_stream->bytes_written(),
               incoming_data.get()->data(), incoming_data_size);
-          disk_writes_time_ += (base::TimeTicks::Now() - write_start);
+          base::TimeDelta write_time = (base::TimeTicks::Now() - write_start);
+          disk_writes_time_ += write_time;
           bytes_seen_ += incoming_data_size;
+          if (is_sparse_file_) {
+            if (num_active_streams_ > 1) {
+              disk_writes_time_with_parallel_streams_ += write_time;
+              bytes_seen_with_parallel_streams_ += incoming_data_size;
+            } else {
+              disk_writes_time_without_parallel_streams_ += write_time;
+              bytes_seen_without_parallel_streams_ += incoming_data_size;
+            }
+          }
           total_incoming_data_size += incoming_data_size;
           if (reason == DOWNLOAD_INTERRUPT_REASON_NONE)
             source_stream->OnWriteBytesToDisk(incoming_data_size);
         }
         break;
       case ByteStreamReader::STREAM_COMPLETE:
         {
           reason = static_cast<DownloadInterruptReason>(
             source_stream->stream_reader()->GetStatus());
           SendUpdate();
@@ skipping 28 matching lines @@
     // Shut down processing and signal an error to our observer.
     // Our observer will clean us up.
     source_stream->stream_reader()->RegisterCallback(base::Closure());
     weak_factory_.InvalidateWeakPtrs();
     SendUpdate();  // Make info up to date before error.
     std::unique_ptr<crypto::SecureHash> hash_state = file_.Finish();
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&DownloadDestinationObserver::DestinationError, observer_,
                    reason, TotalBytesReceived(), base::Passed(&hash_state)));
+    num_active_streams_--;
   } else if (state == ByteStreamReader::STREAM_COMPLETE || should_terminate) {
     // Signal successful completion or termination of the current stream.
     source_stream->stream_reader()->RegisterCallback(base::Closure());
     source_stream->set_finished(true);
+    num_active_streams_--;
 
     // Inform observers.
     SendUpdate();
 
     // TODO(xingliu): Use slice info to determine if the file is fully
     // downloaded.
     bool all_stream_complete = true;
     for (auto& stream : source_streams_) {
       if (!stream.second->is_finished()) {
         all_stream_complete = false;
         break;
       }
     }
 
     // All the stream reader are completed, shut down file IO processing.
     if (all_stream_complete) {
       RecordFileBandwidth(bytes_seen_, disk_writes_time_,
                           base::TimeTicks::Now() - download_start_);
+      if (is_sparse_file_) {
+        RecordParallelDownloadStats(bytes_seen_with_parallel_streams_,
+                                    disk_writes_time_with_parallel_streams_,
+                                    bytes_seen_without_parallel_streams_,
+                                    disk_writes_time_without_parallel_streams_);
+      }
       weak_factory_.InvalidateWeakPtrs();
       std::unique_ptr<crypto::SecureHash> hash_state = file_.Finish();
       update_timer_.reset();
       BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE,
           base::Bind(&DownloadDestinationObserver::DestinationCompleted,
                      observer_, TotalBytesReceived(),
                      base::Passed(&hash_state)));
     }
   }
   if (net_log_.IsCapturing()) {
     net_log_.AddEvent(net::NetLogEventType::DOWNLOAD_STREAM_DRAINED,
                             base::Bind(&FileStreamDrainedNetLogCallback,
                                        total_incoming_data_size, num_buffers));
   }
 }
 
 void DownloadFileImpl::RegisterAndActivateStream(SourceStream* source_stream) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   ByteStreamReader* stream_reader = source_stream->stream_reader();
   if (stream_reader) {
     stream_reader->RegisterCallback(base::Bind(&DownloadFileImpl::StreamActive,
                                                weak_factory_.GetWeakPtr(),
                                                source_stream));
     StreamActive(source_stream);
+    num_active_streams_++;
   }
 }
 
 int64_t DownloadFileImpl::TotalBytesReceived() const {
   return file_.bytes_so_far();
 }
 
 void DownloadFileImpl::SendUpdate() {
   // TODO(qinmin): For each active stream, add the slice it has written so
   // far along with received_slices_.
@@ skipping 18 matching lines @@
     const base::FilePath& new_path,
     const RenameCompletionCallback& completion_callback)
     : option(option),
       new_path(new_path),
       retries_left(kMaxRenameRetries),
       completion_callback(completion_callback) {}
 
 DownloadFileImpl::RenameParameters::~RenameParameters() {}
 
 }  // namespace content