Refactor ResourceHandler API.

content/browser/loader/resource_loader_unittest.cc

 // Copyright (c) 2013 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/browser/loader/resource_loader.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 307 matching lines @@
   int total_bytes_downloaded() const { return total_bytes_downloaded_; }
 
   net::EffectiveConnectionType observed_effective_connection_type() const {
     return observed_effective_connection_type_;
   }
 
   void Resume() {
     controller()->Resume();
   }
 
-  bool OnRequestRedirected(const net::RedirectInfo& redirect_info,
+  void OnRequestRedirected(const net::RedirectInfo& redirect_info,
                            ResourceResponse* response,
-                           bool* defer) override {
+                           bool* defer_or_cancel) override {
     redirect_response_ = response;
     received_request_redirected_ = true;
-    return true;
   }
 
-  bool OnResponseStarted(ResourceResponse* response, bool* defer) override {
+  void OnResponseStarted(ResourceResponse* response,
+                         bool* defer_or_cancel) override {
     EXPECT_FALSE(response_.get());
     response_ = response;
     observed_effective_connection_type_ =
         response->head.effective_connection_type;
-    return true;
   }
 
-  bool OnWillStart(const GURL& url, bool* defer) override {
+  void OnWillStart(const GURL& url, bool* defer_or_cancel) override {
     EXPECT_TRUE(start_url_.is_empty());
     start_url_ = url;
     if (defer_request_on_will_start_) {
-      *defer = true;
+      *defer_or_cancel = true;
       deferred_run_loop_.Quit();
     }
-    return true;
   }
 
   bool OnWillRead(scoped_refptr<net::IOBuffer>* buf,
                   int* buf_size,
                   int min_size) override {
     EXPECT_TRUE(expect_reads_);
     EXPECT_FALSE(received_on_will_read_);
     EXPECT_FALSE(received_eof_);
     EXPECT_FALSE(received_response_completed_);
 
     *buf = read_buffer_;
     *buf_size = kReadBufSize;
     received_on_will_read_ = true;
     return true;
   }
 
-  bool OnReadCompleted(int bytes_read, bool* defer) override {
+  void OnReadCompleted(int bytes_read, bool* defer_or_cancel) override {
     EXPECT_TRUE(received_on_will_read_);
     EXPECT_TRUE(expect_reads_);
     EXPECT_FALSE(received_response_completed_);
 
     if (bytes_read == 0) {
       received_eof_ = true;
       if (defer_eof_) {
         defer_eof_ = false;
-        *defer = true;
+        *defer_or_cancel = true;
         deferred_run_loop_.Quit();
       }
     }
 
     // Need another OnWillRead() call before seeing an OnReadCompleted().
     received_on_will_read_ = false;
 
-    return !cancel_on_read_completed_;
+    if (cancel_on_read_completed_) {
+      *defer_or_cancel = true;
+      controller()->Cancel();
+    }
   }
 
   void OnResponseCompleted(const net::URLRequestStatus& status,
                            bool* defer) override {
     EXPECT_FALSE(received_response_completed_);
     if (status.is_success() && expect_reads_)
       EXPECT_TRUE(received_eof_);
 
     received_response_completed_ = true;
     status_ = status;
@@ skipping 763 matching lines @@
 
 // Tests that the effective connection type is not set on non-main frame
 // requests.
 TEST_F(EffectiveConnectionTypeResourceLoaderTest, DoesNotBelongToMainFrame) {
   VerifyEffectiveConnectionType(RESOURCE_TYPE_OBJECT, false,
                                 net::EFFECTIVE_CONNECTION_TYPE_3G,
                                 net::EFFECTIVE_CONNECTION_TYPE_UNKNOWN);
 }
 
 }  // namespace content