Make URLRequest::Read to return net errors or bytes read instead of a bool

net/base/layered_network_delegate_unittest.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/base/layered_network_delegate.h"
 
 #include <map>
 #include <memory>
 #include <utility>
 
@@ skipping 62 matching lines @@
       GURL* allowed_unsafe_redirect_url) override {
     IncrementAndCompareCounter("on_headers_received_count");
     return OK;
   }
 
   void OnBeforeRedirect(URLRequest* request,
                         const GURL& new_location) override {
     IncrementAndCompareCounter("on_before_redirect_count");
   }
 
-  void OnResponseStarted(URLRequest* request) override {
+  void OnResponseStarted(URLRequest* request, int net_error) override {
     IncrementAndCompareCounter("on_response_started_count");
   }
 
   void OnNetworkBytesReceived(URLRequest* request,
                               int64_t bytes_received) override {
     IncrementAndCompareCounter("on_network_bytes_received_count");
   }
 
   void OnNetworkBytesSent(URLRequest* request, int64_t bytes_sent) override {
     IncrementAndCompareCounter("on_network_bytes_sent_count");
   }
 
-  void OnCompleted(URLRequest* request, bool started) override {
+  void OnCompleted(URLRequest* request, bool started, int net_error) override {
     IncrementAndCompareCounter("on_completed_count");
   }
 
   void OnURLRequestDestroyed(URLRequest* request) override {
     IncrementAndCompareCounter("on_url_request_destroyed_count");
   }
 
   void OnPACScriptError(int line_number, const base::string16& error) override {
     IncrementAndCompareCounter("on_pac_script_error_count");
   }
@@ skipping 80 matching lines @@
     EXPECT_EQ(OK, OnBeforeURLRequest(request.get(),
                                      completion_callback.callback(), NULL));
     EXPECT_EQ(OK, OnBeforeStartTransaction(NULL, completion_callback.callback(),
                                            request_headers.get()));
     OnBeforeSendHeaders(NULL, ProxyInfo(), proxy_retry_info,
                         request_headers.get());
     OnStartTransaction(NULL, *request_headers);
     OnNetworkBytesSent(request.get(), 42);
     EXPECT_EQ(OK, OnHeadersReceived(NULL, completion_callback.callback(),
                                     response_headers.get(), NULL, NULL));
-    OnResponseStarted(request.get());
+    OnResponseStarted(request.get(), net::OK);
     OnNetworkBytesReceived(request.get(), 42);
-    OnCompleted(request.get(), false);
+    OnCompleted(request.get(), false, net::OK);
     OnURLRequestDestroyed(request.get());
     OnPACScriptError(0, base::string16());
     EXPECT_EQ(
         NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION,
         OnAuthRequired(request.get(), *auth_challenge, AuthCallback(), NULL));
     EXPECT_FALSE(OnCanGetCookies(*request, CookieList()));
     EXPECT_FALSE(OnCanSetCookie(*request, std::string(), NULL));
     EXPECT_FALSE(OnCanAccessFile(*request, base::FilePath()));
     EXPECT_FALSE(OnCanEnablePrivacyMode(GURL(), GURL()));
     EXPECT_FALSE(OnCancelURLRequestWithPolicyViolatingReferrerHeader(
@@ skipping 148 matching lines @@
   CountersMap layered_network_delegate_counters;
   TestNetworkDelegateImpl* test_network_delegate_;
   std::unique_ptr<TestLayeredNetworkDelegate> layered_network_delegate_;
 };
 
 TEST_F(LayeredNetworkDelegateTest, VerifyLayeredNetworkDelegateInternal) {
   layered_network_delegate_->CallAndVerify();
 }
 
 }  // namespace net