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),
+      record_stream_bandwidth_(true),
+      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 25 matching lines @@
                        std::move(save_info_->file), bytes_so_far,
                        save_info_->hash_of_partial_file,
                        std::move(save_info_->hash_state), is_sparse_file_);
   if (result != DOWNLOAD_INTERRUPT_REASON_NONE) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE, base::Bind(callback, result));
     return;
   }
 
   download_start_ = base::TimeTicks::Now();
+  last_update_time_ = download_start_;
 
   // Primarily to make reset to zero in restart visible to owner.
   SendUpdate();
 
   // Initial pull from the straw.
   for (auto& source_stream : source_streams_)
     RegisterAndActivateStream(source_stream.second.get());
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE, base::Bind(
@@ skipping 143 matching lines @@
 }
 
 const base::FilePath& DownloadFileImpl::FullPath() const {
   return file_.full_path();
 }
 
 bool DownloadFileImpl::InProgress() const {
   return file_.in_progress();
 }
 
+void DownloadFileImpl::Pause() {
+  record_stream_bandwidth_ = false;

[xingliu, 2017/03/17 00:02:15]

I think we didn't set it to true again, and didn't use this in the file.

If set it to true again, maybe a Resume call? and maybe guard the bandwidth
metric logic with if (record_stream_bandwidth_).


If we discard the bandwidth metric after a pause, I think that's fine too, so we
only record contiguous download. But still need to if (record_stream_bandwidth_)
somewhere.

[David Trainor- moved to gerrit, 2017/03/17 07:25:40]

Do we need to reset last_update_time_ on resume as well?

[qinmin, 2017/03/17 19:52:54]

We don't record UMA even if resume is called, the value will contain too many
noises and could go very inaccurate.

[qinmin, 2017/03/17 19:52:55]

we should stop recording if a download is ever paused.
The variable is now used in the logic to determine if we should record the
download stats.

+}
+
 void DownloadFileImpl::StreamActive(SourceStream* source_stream) {
   DCHECK(source_stream->stream_reader());
   base::TimeTicks start(base::TimeTicks::Now());
   base::TimeTicks now;
   scoped_refptr<net::IOBuffer> incoming_data;
   size_t incoming_data_size = 0;
   size_t total_incoming_data_size = 0;
   size_t num_buffers = 0;
   bool should_terminate = false;
   ByteStreamReader::StreamState state(ByteStreamReader::STREAM_EMPTY);
@@ skipping 68 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_,
+                                    download_time_with_parallel_streams_,
+                                    bytes_seen_without_parallel_streams_,
+                                    download_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_.
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&DownloadDestinationObserver::DestinationUpdate, observer_,
                  TotalBytesReceived(), rate_estimator_.GetCountPerSecond(),
                  received_slices_));
 }
 
 void DownloadFileImpl::WillWriteToDisk(size_t data_len) {
   if (!update_timer_->IsRunning()) {
     update_timer_->Start(FROM_HERE,
                          base::TimeDelta::FromMilliseconds(kUpdatePeriodMs),
                          this, &DownloadFileImpl::SendUpdate);
   }
   rate_estimator_.Increment(data_len);
+  if (is_sparse_file_) {
+    base::TimeTicks now = base::TimeTicks::Now();
+    base::TimeDelta time_elapsed = (now - last_update_time_);
+    last_update_time_ = now;
+    if (num_active_streams_ > 1) {
+      download_time_with_parallel_streams_ += time_elapsed;
+      bytes_seen_with_parallel_streams_ += data_len;
+    } else {
+      download_time_without_parallel_streams_ += time_elapsed;
+      bytes_seen_without_parallel_streams_ += data_len;
+    }
+  }
 }
 
 DownloadFileImpl::RenameParameters::RenameParameters(
     RenameOption option,
     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