Add new UMA stats for parallelizable download

content/public/test/test_file_error_injector.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/public/test/test_file_error_injector.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
@@ skipping 25 matching lines @@
       std::unique_ptr<ByteStreamReader> byte_stream,
       const net::NetLogWithSource& net_log,
       base::WeakPtr<DownloadDestinationObserver> observer,
       const TestFileErrorInjector::FileErrorInfo& error_info,
       const base::Closure& ctor_callback,
       const base::Closure& dtor_callback);
 
   ~DownloadFileWithError() override;
 
   void Initialize(const InitializeCallback& callback,
-                  const DownloadItem::ReceivedSlices& received_slices) override;
+                  const DownloadItem::ReceivedSlices& received_slices,
+                  bool is_parallelizable) override;
 
   // DownloadFile interface.
   DownloadInterruptReason WriteDataToFile(int64_t offset,
                                           const char* data,
                                           size_t data_len) override;
 
   void RenameAndUniquify(const base::FilePath& full_path,
                          const RenameCompletionCallback& callback) override;
   void RenameAndAnnotate(const base::FilePath& full_path,
                          const std::string& client_guid,
@@ skipping 70 matching lines @@
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, ctor_callback);
 }
 
 DownloadFileWithError::~DownloadFileWithError() {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   destruction_callback_.Run();
 }
 
 void DownloadFileWithError::Initialize(
     const InitializeCallback& callback,
-    const DownloadItem::ReceivedSlices& received_slices) {
+    const DownloadItem::ReceivedSlices& received_slices,
+    bool is_parallelizable) {
   DownloadInterruptReason error_to_return = DOWNLOAD_INTERRUPT_REASON_NONE;
   InitializeCallback callback_to_use = callback;
 
   // Replace callback if the error needs to be overwritten.
   if (OverwriteError(
           TestFileErrorInjector::FILE_OPERATION_INITIALIZE,
           &error_to_return)) {
     if (DOWNLOAD_INTERRUPT_REASON_NONE != error_to_return) {
       // Don't execute a, probably successful, Initialize; just
       // return the error.
       BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE, base::Bind(
               callback, error_to_return));
       return;
     }
 
     // Otherwise, just wrap the return.
     callback_to_use = base::Bind(&InitializeErrorCallback, callback,
                                  error_to_return);
   }
 
-  DownloadFileImpl::Initialize(callback_to_use, received_slices);
+  DownloadFileImpl::Initialize(callback_to_use, received_slices,
+                               is_parallelizable);
 }
 
 DownloadInterruptReason DownloadFileWithError::WriteDataToFile(
     int64_t offset,
     const char* data,
     size_t data_len) {
   return ShouldReturnError(
       TestFileErrorInjector::FILE_OPERATION_WRITE,
       DownloadFileImpl::WriteDataToFile(offset, data, data_len));
 }
@@ skipping 240 matching lines @@
     case FILE_OPERATION_RENAME_ANNOTATE:
       return "RENAME_ANNOTATE";
     default:
       break;
   }
 
   return "Unknown";
 }
 
 }  // namespace content