Make net/sdch to use new URLRequest::Read and its modified delegate methods.

net/url_request/sdch_dictionary_fetcher.cc

 // Copyright 2014 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/url_request/sdch_dictionary_fetcher.h"
 
 #include <stdint.h>
 #include <queue>
 #include <set>
 
@@ skipping 14 matching lines @@
 #include "net/url_request/url_request_throttler_manager.h"
 
 namespace net {
 
 namespace {
 
 const int kBufferSize = 4096;
 
 // Map the bytes_read result from a read attempt and a URLRequest's
 // status into a single net return value.
-int GetReadResult(int bytes_read, const URLRequest* request) {
-  int rv = request->status().error();
-  if (request->status().is_success() && bytes_read < 0) {
+int GetReadResult(int rv, const URLRequest* request) {
+  DCHECK_NE(ERR_IO_PENDING, rv);
+
+  if (rv < 0) {
     rv = ERR_FAILED;
     request->net_log().AddEventWithNetErrorCode(
         NetLogEventType::SDCH_DICTIONARY_FETCH_IMPLIED_ERROR, rv);
   }
 
-  if (rv == OK)
-    rv = bytes_read;
-
   return rv;
 }
 
 struct FetchInfo {
   FetchInfo(const GURL& url,
             bool cache_only,
             const SdchDictionaryFetcher::OnDictionaryFetchedCallback& callback)
       : url(url), cache_only(cache_only), callback(callback) {}
   FetchInfo() {}
 
@@ skipping 93 matching lines @@
     URLRequest* request,
     const RedirectInfo& redirect_info,
     bool* defer_redirect) {
   DCHECK_EQ(next_state_, STATE_SEND_REQUEST_PENDING);
 
   next_state_ = STATE_RECEIVED_REDIRECT;
 
   DoLoop(OK);
 }
 
-void SdchDictionaryFetcher::OnResponseStarted(URLRequest* request) {
+void SdchDictionaryFetcher::OnResponseStarted(URLRequest* request,
+                                              int net_error) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(request, current_request_.get());
   DCHECK_EQ(next_state_, STATE_SEND_REQUEST_PENDING);
   DCHECK(!in_loop_);
+  DCHECK_NE(ERR_IO_PENDING, net_error);
 
   // Confirm that the response isn't a stale read from the cache (as
   // may happen in the reload case).  If the response was not retrieved over
   // HTTP, it is presumed to be fresh.
   HttpResponseHeaders* response_headers = request->response_headers();
-  int result = request->status().error();
-  if (result == OK && response_headers) {
+  if (net_error == OK && response_headers) {
     ValidationType validation_type = response_headers->RequiresValidation(
         request->response_info().request_time,
         request->response_info().response_time, base::Time::Now());
     // TODO(rdsmith): Maybe handle VALIDATION_ASYNCHRONOUS by queueing
     // a non-reload request for the dictionary.
     if (validation_type != VALIDATION_NONE)
-      result = ERR_FAILED;
+      net_error = ERR_FAILED;
   }
 
-  DoLoop(result);
+  DoLoop(net_error);
 }
 
 void SdchDictionaryFetcher::OnReadCompleted(URLRequest* request,
                                             int bytes_read) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(request, current_request_.get());
   DCHECK_EQ(next_state_, STATE_READ_BODY_COMPLETE);
   DCHECK(!in_loop_);
+  DCHECK_NE(ERR_IO_PENDING, bytes_read);
 
   DoLoop(GetReadResult(bytes_read, current_request_.get()));
 }
 
 bool SdchDictionaryFetcher::ScheduleInternal(
     const GURL& dictionary_url,
     bool reload,
     const OnDictionaryFetchedCallback& callback) {
   DCHECK(CalledOnValidThread());
 
@@ skipping 124 matching lines @@
   DCHECK(CalledOnValidThread());
 
   // If there's been an error, abort the current request.
   if (rv != OK) {
     ResetRequest();
     next_state_ = STATE_SEND_REQUEST;
     return OK;
   }
 
   next_state_ = STATE_READ_BODY_COMPLETE;
-  int bytes_read = 0;
-  current_request_->Read(buffer_.get(), kBufferSize, &bytes_read);
-  if (current_request_->status().is_io_pending())
+  int bytes_read = current_request_->Read(buffer_.get(), kBufferSize);
+  if (bytes_read == ERR_IO_PENDING)
     return ERR_IO_PENDING;
 
   return GetReadResult(bytes_read, current_request_.get());
 }
 
 int SdchDictionaryFetcher::DoReadBodyComplete(int rv) {
   DCHECK(CalledOnValidThread());
 
   // An error; abort the current request.
   if (rv < 0) {
     ResetRequest();
     next_state_ = STATE_SEND_REQUEST;
     return OK;
   }
 
-  DCHECK(current_request_->status().is_success());
+  DCHECK_GE(rv, 0);
 
   // Data; append to the dictionary and look for more data.
   if (rv > 0) {
     dictionary_->append(buffer_->data(), rv);
     next_state_ = STATE_READ_BODY;
     return OK;
   }
 
   // End of file; complete the request.
   next_state_ = STATE_REQUEST_COMPLETE;
   return OK;
 }
 
 int SdchDictionaryFetcher::DoCompleteRequest(int rv) {
   DCHECK(CalledOnValidThread());
 
   // If the dictionary was successfully fetched, add it to the manager.
   if (rv == OK) {
     current_callback_.Run(*dictionary_, current_request_->url(),
                           current_request_->net_log(),
                           current_request_->was_cached());
   }
 
   ResetRequest();
   next_state_ = STATE_SEND_REQUEST;
   return OK;
 }
 
 }  // namespace net