Add new UMA stats for parallelizable download

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 253 matching lines @@
       url_chain_(1, url),
       mime_type_(mime_type),
       original_mime_type_(mime_type),
       start_tick_(base::TimeTicks::Now()),
       state_(IN_PROGRESS_INTERNAL),
       start_time_(base::Time::Now()),
       delegate_(delegate),
       current_path_(path),
       net_log_(net_log),
       weak_ptr_factory_(this) {
-  job_ = base::MakeUnique<DownloadJobImpl>(this, std::move(request_handle));
+  job_ =
+      base::MakeUnique<DownloadJobImpl>(this, std::move(request_handle), false);
   delegate_->Attach();
   Init(true /* actively downloading */, SRC_SAVE_PAGE_AS);
 }
 
 DownloadItemImpl::~DownloadItemImpl() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Should always have been nuked before now, at worst in
   // DownloadManager shutdown.
   DCHECK(!download_file_.get());
@@ skipping 938 matching lines @@
     std::unique_ptr<DownloadRequestHandleInterface> req_handle,
     const DownloadCreateInfo& new_create_info) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!download_file_.get());
   DVLOG(20) << __func__ << "() this=" << DebugString(true);
   RecordDownloadCount(START_COUNT);
 
   download_file_ = std::move(file);
   job_ = DownloadJobFactory::CreateJob(this, std::move(req_handle),
                                        new_create_info);
-  if (job_->UsesParallelRequests())
-    RecordParallelDownloadCount(START_COUNT);
+  if (job_->IsParallelizable()) {
+    RecordParallelizableDownloadCount(START_COUNT, IsParallelDownloadEnabled());
+  }
 
   deferred_interrupt_reason_ = DOWNLOAD_INTERRUPT_REASON_NONE;
 
   if (state_ == CANCELLED_INTERNAL) {
     // The download was in the process of resuming when it was cancelled. Don't
     // proceed.
     ReleaseDownloadFile(true);
     job_->Cancel(true);
     return;
   }
@@ skipping 30 matching lines @@
     hash_.clear();
     deferred_interrupt_reason_ = new_create_info.result;
     received_slices_.clear();
     TransitionTo(INTERRUPTED_TARGET_PENDING_INTERNAL);
     DetermineDownloadTarget();
     return;
   }
 
   if (state_ == INITIAL_INTERNAL) {
     RecordDownloadCount(NEW_DOWNLOAD_COUNT);
-    if (job_->UsesParallelRequests())
-      RecordParallelDownloadCount(NEW_DOWNLOAD_COUNT);
+    if (job_->IsParallelizable()) {
+      RecordParallelizableDownloadCount(NEW_DOWNLOAD_COUNT,
+                                        IsParallelDownloadEnabled());
+    }
     RecordDownloadMimeType(mime_type_);
     if (!GetBrowserContext()->IsOffTheRecord()) {
       RecordDownloadCount(NEW_DOWNLOAD_COUNT_NORMAL_PROFILE);
       RecordDownloadMimeTypeForNormalProfile(mime_type_);
     }
   }
 
   // Successful download start.
   DCHECK(download_file_);
   DCHECK(job_);
 
   if (state_ == RESUMING_INTERNAL)
     UpdateValidatorsOnResumption(new_create_info);
 
   // If the download uses parallel requests, and choose not to create parallel
   // request during resumption, clear the received_slices_ vector.
-  if (!job_->UsesParallelRequests() && !received_slices_.empty()) {
+  if (!IsParallelDownloadEnabled() && !received_slices_.empty()) {
     received_bytes_ =
         GetMaxContiguousDataBlockSizeFromBeginning(received_slices_);
     received_slices_.clear();
   }
 
   TransitionTo(TARGET_PENDING_INTERNAL);
 
   job_->Start();
 }
 
 void DownloadItemImpl::StartDownload() {
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&DownloadFile::Initialize,
                  // Safe because we control download file lifetime.
                  base::Unretained(download_file_.get()),
                  base::Bind(&DownloadItemImpl::OnDownloadFileInitialized,
                             weak_ptr_factory_.GetWeakPtr()),
                  base::Bind(&DownloadItemImpl::CancelRequestWithOffset,
                             weak_ptr_factory_.GetWeakPtr()),
-                 received_slices_));
+                 received_slices_, job_ && job_->IsParallelizable()));
 }
 
 void DownloadItemImpl::OnDownloadFileInitialized(
     DownloadInterruptReason result) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(state_ == TARGET_PENDING_INTERNAL ||
          state_ == INTERRUPTED_TARGET_PENDING_INTERNAL)
       << "Unexpected state: " << DebugDownloadStateString(state_);
 
   DVLOG(20) << __func__
@@ skipping 287 matching lines @@
 
   DVLOG(20) << __func__ << "() " << DebugString(false);
 
   DCHECK(all_data_saved_);
   end_time_ = base::Time::Now();
   TransitionTo(COMPLETE_INTERNAL);
   RecordDownloadCompleted(start_tick_, received_bytes_);
   if (!GetBrowserContext()->IsOffTheRecord()) {
     RecordDownloadCount(COMPLETED_COUNT_NORMAL_PROFILE);
   }
-  if (job_ && job_->UsesParallelRequests())
-    RecordParallelDownloadCount(COMPLETED_COUNT);
+  if (job_ && job_->IsParallelizable()) {
+    RecordParallelizableDownloadCount(COMPLETED_COUNT,
+                                      IsParallelDownloadEnabled());
+  }
 
   if (auto_opened_) {
     // If it was already handled by the delegate, do nothing.
   } else if (GetOpenWhenComplete() ||
              ShouldOpenFileBasedOnExtension() ||
              IsTemporary()) {
     // If the download is temporary, like in drag-and-drop, do not open it but
     // we still need to set it auto-opened so that it can be removed from the
     // download shelf.
     if (!IsTemporary())
@@ skipping 127 matching lines @@
   if (IsCancellation(reason)) {
     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);
-    if (job_ && job_->UsesParallelRequests())
-      RecordParallelDownloadCount(CANCELLED_COUNT);
+    if (job_ && job_->IsParallelizable()) {
+      RecordParallelizableDownloadCount(CANCELLED_COUNT,
+                                        IsParallelDownloadEnabled());
+    }
     DCHECK_EQ(last_reason_, reason);
     TransitionTo(CANCELLED_INTERNAL);
     return;
   }
 
   RecordDownloadInterrupted(reason, received_bytes_, total_bytes_,
-                            job_ && job_->UsesParallelRequests());
+                            job_ && job_->IsParallelizable(),
+                            IsParallelDownloadEnabled());
   if (!GetWebContents())
     RecordDownloadCount(INTERRUPTED_WITHOUT_WEBCONTENTS);
 
   // TODO(asanka): This is not good. We can transition to interrupted from
   // target-pending, which is something we don't want to do. Perhaps we should
   // explicitly transition to target-resolved prior to switching to interrupted.
   DCHECK_EQ(last_reason_, reason);
   TransitionTo(INTERRUPTED_INTERNAL);
   AutoResumeIfValid();
 }
@@ skipping 477 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