Use modified URLRequest::Read() and delegate methods in components/

components/certificate_transparency/log_proof_fetcher.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 "components/certificate_transparency/log_proof_fetcher.h"
 
 #include <iterator>
 #include <memory>
 
 #include "base/callback_helpers.h"
@@ skipping 29 matching lines @@
  public:
   using FailureCallback = base::Callback<void(int, int)>;
 
   LogFetcher(net::URLRequestContext* request_context,
              const GURL& request_url,
              const base::Closure& success_callback,
              const FailureCallback& failure_callback);
   ~LogFetcher() override {}
 
   // net::URLRequest::Delegate
-  void OnResponseStarted(net::URLRequest* request) override;
+  void OnResponseStarted(net::URLRequest* request, int net_error) override;
   void OnReadCompleted(net::URLRequest* request, int bytes_read) override;
 
   const std::string& assembled_response() const { return assembled_response_; }
 
  private:
   // Handles the final result of a URLRequest::Read call on the request.
   // Returns true if another read should be started, false if the read
   // failed completely or we have to wait for OnResponseStarted to
   // be called.
   bool HandleReadResult(int bytes_read);
@@ skipping 34 matching lines @@
   // This request should not send any cookies or otherwise identifying data,
   // as CT logs are expected to be publicly-accessible and connections to them
   // stateless.
   url_request_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
                              net::LOAD_DO_NOT_SAVE_COOKIES |
                              net::LOAD_DO_NOT_SEND_AUTH_DATA);
 
   url_request_->Start();
 }
 
-void LogFetcher::OnResponseStarted(net::URLRequest* request) {
+void LogFetcher::OnResponseStarted(net::URLRequest* request, int net_error) {
+  DCHECK_NE(net::ERR_IO_PENDING, net_error);
   DCHECK_EQ(url_request_.get(), request);
   int http_response_code = request->GetResponseCode();
 
-  if (!request->status().is_success()) {
-    InvokeFailureCallback(request->status().error(), http_response_code);
+  if (net_error != net::OK) {
+    InvokeFailureCallback(net_error, http_response_code);
     return;
   }
 
   if (http_response_code != net::HTTP_OK) {
     InvokeFailureCallback(net::OK, http_response_code);
     return;
   }
 
   // Lazily initialize |response_buffer_| to avoid consuming memory until an
   // actual response has been received.
   if (!response_buffer_) {
     response_buffer_ =
         new net::IOBufferWithSize(LogProofFetcher::kMaxLogResponseSizeInBytes);
   }
 
   StartNextReadLoop();
 }
 
 void LogFetcher::OnReadCompleted(net::URLRequest* request, int bytes_read) {
   DCHECK_EQ(url_request_.get(), request);
 
   if (HandleReadResult(bytes_read))
     StartNextReadLoop();
 }
 
 bool LogFetcher::HandleReadResult(int bytes_read) {
-  // Start by checking for an error condition.
-  // If there are errors, invoke the failure callback and clean up the
-  // request.
-  if (!url_request_->status().is_success() || bytes_read < 0) {
-    int net_error = url_request_->status().error();
-    if (net_error == net::OK)
-      net_error = net::URLRequestStatus::FAILED;
-
-    InvokeFailureCallback(net_error, net::HTTP_OK);
-    return false;
-  }
-
   // Not an error, but no data available, so wait for OnReadCompleted
   // callback.
-  if (url_request_->status().is_io_pending())
+  if (bytes_read == net::ERR_IO_PENDING)
     return false;
 
   // Nothing more to read from the stream - finish handling the response.
   if (bytes_read == 0) {
     RequestComplete();
     return false;
   }
 
+  // Check for an error condition.

[Ryan Sleevi, 2016/09/07 18:48:08]

You can drop this line; it no longer grammatically fits with the rest of the
code (and probably shouldn't have been included on 137 to begin with)

+  // If there are errors, invoke the failure callback and clean up the
+  // request.
+  if (bytes_read < 0) {
+    int net_error = bytes_read;
+    InvokeFailureCallback(net_error, net::HTTP_OK);
+    return false;
+  }
+
   // Data is available, collect it and indicate another read is needed.
   DCHECK_GE(bytes_read, 0);
   // |bytes_read| is non-negative at this point, casting to size_t should be
   // safe.
   if (base::checked_cast<size_t>(bytes_read) >
           LogProofFetcher::kMaxLogResponseSizeInBytes ||
       LogProofFetcher::kMaxLogResponseSizeInBytes <
           (assembled_response_.size() + bytes_read)) {
     // Log response is too big, invoke the failure callback.
     InvokeFailureCallback(net::ERR_FILE_TOO_BIG, net::HTTP_OK);
     return false;
   }
 
   assembled_response_.append(response_buffer_->data(), bytes_read);
   return true;
 }
 
 void LogFetcher::StartNextReadLoop() {
   bool continue_reading = true;
   while (continue_reading) {
-    int read_bytes = 0;
-    url_request_->Read(response_buffer_.get(), response_buffer_->size(),
-                       &read_bytes);
+    int read_bytes =
+        url_request_->Read(response_buffer_.get(), response_buffer_->size());
     continue_reading = HandleReadResult(read_bytes);
   }
 }
 
 void LogFetcher::RequestComplete() {
   // Get rid of the buffer as it really isn't necessary.
   response_buffer_ = nullptr;
   base::ResetAndReturn(&success_callback_).Run();
   // NOTE: |this| is not valid after invoking the callback, as the LogFetcher
   // instance will be deleted by the callback.
@@ skipping 244 matching lines @@
                                   const base::Closure& requestor_callback) {
   auto it = inflight_fetches_.find(log_handler);
   DCHECK(it != inflight_fetches_.end());
 
   delete *it;
   inflight_fetches_.erase(it);
   requestor_callback.Run();
 }
 
 }  // namespace certificate_transparency