[Downloads] Always call DM::StartDownload() for explicit downloads.

content/public/test/test_download_request_handler.cc

 // Copyright 2015 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_download_request_handler.h"
 
 #include <inttypes.h>
 #include <utility>
 
 #include "base/logging.h"
@@ skipping 95 matching lines @@
   int GetResponseCode() const override;
   int ReadRawData(net::IOBuffer* buf, int buf_size) override;
 
  private:
   PartialResponseJob(scoped_ptr<Parameters> parameters,
                      base::WeakPtr<Interceptor> interceptor,
                      net::URLRequest* url_request,
                      net::NetworkDelegate* network_delegate);
 
   ~PartialResponseJob() override;
-  void ReportCompletedRequest(int64_t transferred_byte_count);
+  void ReportCompletedRequest();
   static void OnStartResponseCallbackOnPossiblyIncorrectThread(
       base::WeakPtr<PartialResponseJob> job,
       const std::string& headers,
       net::Error error);
   void OnStartResponseCallback(const std::string& headers, net::Error error);
 
   // In general, the Parameters object can specify an explicit OnStart handler.
   // In its absence or if the explicit OnStart handler requests the default
   // behavior, this method can be invoked to respond to the request based on the
   // remaining Parameters fields (as if there was no OnStart handler).
@@ skipping 15 matching lines @@
   // re-entrancy.
   void NotifyHeadersCompleteAndPrepareToRead();
 
   scoped_ptr<Parameters> parameters_;
 
   base::WeakPtr<Interceptor> interceptor_;
   net::HttpResponseInfo response_info_;
   int64_t offset_of_next_read_ = -1;
   int64_t requested_range_begin_ = -1;
   int64_t requested_range_end_ = -1;
+  int64_t read_byte_count_ = 0;
   base::WeakPtrFactory<PartialResponseJob> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PartialResponseJob);
 };
 
 namespace {
 
 template <class T>
 void StoreValueAndInvokeClosure(const base::Closure& closure,
                                 T* value_receiver,
@@ skipping 53 matching lines @@
     net::NetworkDelegate* network_delegate)
     : net::URLRequestJob(request, network_delegate),
       parameters_(std::move(parameters)),
       interceptor_(interceptor),
       weak_factory_(this) {
   DCHECK(parameters_.get());
   DCHECK_LT(0, parameters_->size);
   DCHECK_NE(-1, parameters_->pattern_generator_seed);
 }
 
-TestDownloadRequestHandler::PartialResponseJob::~PartialResponseJob() {}
+TestDownloadRequestHandler::PartialResponseJob::~PartialResponseJob() {
+  ReportCompletedRequest();
+}
 
 void TestDownloadRequestHandler::PartialResponseJob::Start() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "Starting request for " << request()->url().spec();
 
   if (parameters_->on_start_handler.is_null() || !interceptor_.get()) {
     HandleOnStartDefault();
     return;
   }
 
@@ skipping 29 matching lines @@
 }
 
 int TestDownloadRequestHandler::PartialResponseJob::ReadRawData(
     net::IOBuffer* buf,
     int buf_size) {
   DVLOG(1) << "Preparing to read " << buf_size << " bytes";
 
   // requested_range_begin_ == -1 implies that the body was empty.
   if (offset_of_next_read_ > requested_range_end_ ||
       requested_range_begin_ == -1) {
-    ReportCompletedRequest(requested_range_end_ - requested_range_begin_ + 1);
     DVLOG(1) << "Done reading.";
     return 0;
   }
 
   int64_t range_end =
       std::min(requested_range_end_, offset_of_next_read_ + buf_size - 1);
 
   if (!parameters_->injected_errors.empty()) {
     const InjectedError& injected_error = parameters_->injected_errors.front();
 
     if (offset_of_next_read_ == injected_error.offset) {
       int error = injected_error.error;
       DVLOG(1) << "Returning error " << net::ErrorToString(error);
-      ReportCompletedRequest(injected_error.offset - requested_range_begin_);
       parameters_->injected_errors.pop();
       return error;
     }
 
     if (offset_of_next_read_ < injected_error.offset &&
         injected_error.offset <= range_end)
       range_end = injected_error.offset - 1;
   }
   int bytes_to_copy = (range_end - offset_of_next_read_) + 1;
 
   TestDownloadRequestHandler::GetPatternBytes(
       parameters_->pattern_generator_seed, offset_of_next_read_, bytes_to_copy,
       buf->data());
   DVLOG(1) << "Read " << bytes_to_copy << " bytes at offset "
            << offset_of_next_read_;
   offset_of_next_read_ += bytes_to_copy;
+  read_byte_count_ += bytes_to_copy;
   return bytes_to_copy;
 }
 
-void TestDownloadRequestHandler::PartialResponseJob::ReportCompletedRequest(
-    int64_t transferred_byte_count) {
+void TestDownloadRequestHandler::PartialResponseJob::ReportCompletedRequest() {
   if (interceptor_.get()) {
     TestDownloadRequestHandler::CompletedRequest completed_request;
-    completed_request.transferred_byte_count = transferred_byte_count;
+    completed_request.transferred_byte_count = read_byte_count_;
     completed_request.request_headers = request()->extra_request_headers();
     interceptor_->AddCompletedRequest(completed_request);
   }
 }
 
 // static
 void TestDownloadRequestHandler::PartialResponseJob::
     OnStartResponseCallbackOnPossiblyIncorrectThread(
         base::WeakPtr<PartialResponseJob> job,
         const std::string& headers,
@@ skipping 339 matching lines @@
   base::RunLoop run_loop;
   BrowserThread::PostTaskAndReply(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&Interceptor::GetAndResetCompletedRequests, interceptor_,
                  requests),
       run_loop.QuitClosure());
   run_loop.Run();
 }
 
 }  // namespace content