Revert of Adjust callers and networking delegates in net/ to modified APIs

net/cert_net/cert_net_fetcher_impl.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 "net/cert_net/cert_net_fetcher_impl.h"
 
 #include <tuple>
 #include <utility>
 
 #include "base/callback_helpers.h"
@@ skipping 160 matching lines @@
   void StartURLRequest(URLRequestContext* context);
 
  private:
   // The pointers in RequestList are not owned by the Job.
   using RequestList = base::LinkedList<RequestImpl>;
 
   // Implementation of URLRequest::Delegate
   void OnReceivedRedirect(URLRequest* request,
                           const RedirectInfo& redirect_info,
                           bool* defer_redirect) override;
-  void OnResponseStarted(URLRequest* request, int net_error) override;
+  void OnResponseStarted(URLRequest* request) override;
   void OnReadCompleted(URLRequest* request, int bytes_read) override;
 
   // Clears the URLRequest and timer. Helper for doing work common to
   // cancellation and job completion.
   void Stop();
 
   // Reads as much data as available from |request|.
   void ReadBody(URLRequest* request);
 
   // Helper to copy the partial bytes read from the read IOBuffer to an
   // aggregated buffer.
   bool ConsumeBytesRead(URLRequest* request, int num_bytes);
 
+  // Called once the job has exceeded its deadline.
+  void OnTimeout();
+
   // Called when the URLRequest has completed (either success or failure).
-  void OnUrlRequestCompleted(int net_error);
+  void OnUrlRequestCompleted(URLRequest* request);
 
   // Called when the Job has completed. The job may finish in response to a
   // timeout, an invalid URL, or the URLRequest completing. By the time this
-  // method is called, the |response_body_| variable have been assigned.
-  void OnJobCompleted(Error error);
-
-  // Cancels a request with a specified error code and calls
-  // OnUrlRequestCompleted().
-  void FailRequest(Error error);
+  // method is called, the response variables have been assigned
+  // (result_net_error_ and response_body_).
+  void OnJobCompleted();
 
   // The requests attached to this job.
   RequestList requests_;
 
   // The input parameters for starting a URLRequest.
   std::unique_ptr<RequestParams> request_params_;
 
   // The URLRequest response information.
   std::vector<uint8_t> response_body_;
+  Error result_net_error_;
 
   std::unique_ptr<URLRequest> url_request_;
   scoped_refptr<IOBuffer> read_buffer_;
 
   // Used to timeout the job when the URLRequest takes too long. This timer is
   // also used for notifying a failure to start the URLRequest.
   base::OneShotTimer timer_;
 
   // Non-owned pointer to the CertNetFetcherImpl that created this job.
   CertNetFetcherImpl* parent_;
 
   DISALLOW_COPY_AND_ASSIGN(Job);
 };
 
 CertNetFetcherImpl::RequestImpl::~RequestImpl() {
   if (job_)
     job_->DetachRequest(this);
 }
 
 CertNetFetcherImpl::Job::Job(std::unique_ptr<RequestParams> request_params,
                              CertNetFetcherImpl* parent)
     : request_params_(std::move(request_params)),
+      result_net_error_(ERR_IO_PENDING),
       parent_(parent) {}
 
 CertNetFetcherImpl::Job::~Job() {
   Cancel();
 }
 
 void CertNetFetcherImpl::Job::Cancel() {
   parent_ = nullptr;
 
   // Notify each request of cancellation and remove it from the list.
@@ skipping 24 matching lines @@
 
   // If there are no longer any requests attached to the job then
   // cancel and delete it.
   if (requests_.empty() && !parent_->IsCurrentlyCompletingJob(this))
     delete_this = parent_->RemoveJob(this);
 }
 
 void CertNetFetcherImpl::Job::StartURLRequest(URLRequestContext* context) {
   Error error = CanFetchUrl(request_params_->url);
   if (error != OK) {
+    result_net_error_ = error;
     // The CertNetFetcher's API contract is that requests always complete
     // asynchronously. Use the timer class so the task is easily cancelled.
-    timer_.Start(
-        FROM_HERE, base::TimeDelta(),
-        base::Bind(&Job::OnJobCompleted, base::Unretained(this), error));
+    timer_.Start(FROM_HERE, base::TimeDelta(), this, &Job::OnJobCompleted);
     return;
   }
 
   // Start the URLRequest.
   read_buffer_ = new IOBuffer(kReadBufferSizeInBytes);
   url_request_ =
       context->CreateRequest(request_params_->url, DEFAULT_PRIORITY, this);
   if (request_params_->http_method == HTTP_METHOD_POST)
     url_request_->set_method("POST");
   url_request_->SetLoadFlags(LOAD_DO_NOT_SAVE_COOKIES |
                              LOAD_DO_NOT_SEND_COOKIES);
   url_request_->Start();
 
   // Start a timer to limit how long the job runs for.
   if (request_params_->timeout > base::TimeDelta())
-    timer_.Start(
-        FROM_HERE, request_params_->timeout,
-        base::Bind(&Job::FailRequest, base::Unretained(this), ERR_TIMED_OUT));
+    timer_.Start(FROM_HERE, request_params_->timeout, this, &Job::OnTimeout);
 }
 
 void CertNetFetcherImpl::Job::OnReceivedRedirect(
     URLRequest* request,
     const RedirectInfo& redirect_info,
     bool* defer_redirect) {
   DCHECK_EQ(url_request_.get(), request);
 
   // Ensure that the new URL matches the policy.
   Error error = CanFetchUrl(redirect_info.new_url);
   if (error != OK) {
-    FailRequest(error);
+    request->CancelWithError(error);
+    OnUrlRequestCompleted(request);
     return;
   }
 }
 
-void CertNetFetcherImpl::Job::OnResponseStarted(URLRequest* request,
-                                                int net_error) {
+void CertNetFetcherImpl::Job::OnResponseStarted(URLRequest* request) {
   DCHECK_EQ(url_request_.get(), request);
-  DCHECK_NE(ERR_IO_PENDING, net_error);
 
-  if (net_error != OK) {
-    OnUrlRequestCompleted(net_error);
+  if (!request->status().is_success()) {
+    OnUrlRequestCompleted(request);
     return;
   }
 
   if (request->GetResponseCode() != 200) {
     // TODO(eroman): Use a more specific error code.
-    FailRequest(ERR_FAILED);
+    request->CancelWithError(ERR_FAILED);
+    OnUrlRequestCompleted(request);
     return;
   }
 
   ReadBody(request);
 }
 
 void CertNetFetcherImpl::Job::OnReadCompleted(URLRequest* request,
                                               int bytes_read) {
   DCHECK_EQ(url_request_.get(), request);
-  DCHECK_NE(ERR_IO_PENDING, bytes_read);
 
   // Keep reading the response body.
   if (ConsumeBytesRead(request, bytes_read))
     ReadBody(request);
 }
 
 void CertNetFetcherImpl::Job::Stop() {
   timer_.Stop();
   url_request_.reset();
 }
 
 void CertNetFetcherImpl::Job::ReadBody(URLRequest* request) {
   // Read as many bytes as are available synchronously.
-  int num_bytes = 0;
-  while (num_bytes >= 0) {
-    num_bytes = request->Read(read_buffer_.get(), kReadBufferSizeInBytes);
+  int num_bytes;
+  while (
+      request->Read(read_buffer_.get(), kReadBufferSizeInBytes, &num_bytes)) {
     if (!ConsumeBytesRead(request, num_bytes))
       return;
   }
 
   // Check whether the read failed synchronously.
-  if (num_bytes != ERR_IO_PENDING)
-    OnUrlRequestCompleted(num_bytes);
+  if (!request->status().is_io_pending())
+    OnUrlRequestCompleted(request);
   return;
 }
 
 bool CertNetFetcherImpl::Job::ConsumeBytesRead(URLRequest* request,
                                                int num_bytes) {
   if (num_bytes <= 0) {
     // Error while reading, or EOF.
-    OnUrlRequestCompleted(num_bytes);
+    OnUrlRequestCompleted(request);
     return false;
   }
 
   // Enforce maximum size bound.
   if (num_bytes + response_body_.size() > request_params_->max_response_bytes) {
-    FailRequest(ERR_FILE_TOO_BIG);
+    request->CancelWithError(ERR_FILE_TOO_BIG);
+    OnUrlRequestCompleted(request);
     return false;
   }
 
   // Append the data to |response_body_|.
   response_body_.reserve(num_bytes);
   response_body_.insert(response_body_.end(), read_buffer_->data(),
                         read_buffer_->data() + num_bytes);
   return true;
 }
 
-void CertNetFetcherImpl::Job::OnUrlRequestCompleted(int net_error) {
-  Error result = static_cast<Error>(net_error);
-  OnJobCompleted(result);
+void CertNetFetcherImpl::Job::OnTimeout() {
+  result_net_error_ = ERR_TIMED_OUT;
+  url_request_->CancelWithError(result_net_error_);
+  OnJobCompleted();
 }
 
-void CertNetFetcherImpl::Job::OnJobCompleted(Error error) {
+void CertNetFetcherImpl::Job::OnUrlRequestCompleted(URLRequest* request) {
+  DCHECK_EQ(request, url_request_.get());
+
+  if (request->status().is_success())
+    result_net_error_ = OK;
+  else
+    result_net_error_ = static_cast<Error>(request->status().error());
+
+  OnJobCompleted();
+}
+
+void CertNetFetcherImpl::Job::OnJobCompleted() {
   // Stop the timer and clear the URLRequest.
   Stop();
 
   // Invoking the callbacks is subtle as state may be mutated while iterating
   // through the callbacks:
   //
   //   * The parent CertNetFetcherImpl may be deleted
   //   * Requests in this job may be cancelled
 
   std::unique_ptr<Job> delete_this = parent_->RemoveJob(this);
   parent_->SetCurrentlyCompletingJob(this);
 
   while (!requests_.empty()) {
     base::LinkNode<RequestImpl>* request = requests_.head();
     request->RemoveFromList();
-    request->value()->OnJobCompleted(this, error, response_body_);
+    request->value()->OnJobCompleted(this, result_net_error_, response_body_);
   }
 
   if (parent_)
     parent_->ClearCurrentlyCompletingJob(this);
 }
 
-void CertNetFetcherImpl::Job::FailRequest(Error error) {
-  int result = url_request_->CancelWithError(error);
-  OnUrlRequestCompleted(result);
-}
-
 CertNetFetcherImpl::CertNetFetcherImpl(URLRequestContext* context)
     : currently_completing_job_(nullptr), context_(context) {
 }
 
 CertNetFetcherImpl::~CertNetFetcherImpl() {
   base::STLDeleteElements(&jobs_);
 
   // The CertNetFetcherImpl was destroyed in a FetchCallback. Detach all
   // remaining requests from the job so no further callbacks are called.
   if (currently_completing_job_)
@@ skipping 108 matching lines @@
 void CertNetFetcherImpl::ClearCurrentlyCompletingJob(Job* job) {
   DCHECK_EQ(currently_completing_job_, job);
   currently_completing_job_ = nullptr;
 }
 
 bool CertNetFetcherImpl::IsCurrentlyCompletingJob(Job* job) {
   return job == currently_completing_job_;
 }
 
 }  // namespace net