Refactor blocking network delegates

net/url_request/url_request_unittest.cc

 // Copyright (c) 2012 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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shlobj.h>
 #endif
@@ skipping 128 matching lines @@
     return false;
 
   for (size_t i = 0; i < size; ++i) {
     if (!a[i].Equals(b[i]))
       return false;
   }
 
   return true;
 }
 
+// A common base for BlockingNetworkDelegate* classes. Takes care of
+// when-to-block and what-to return book-keeping.
+class BlockingNetworkDelegateBase : public TestNetworkDelegate {
+ public:
+  enum State {  // When to block.
+    NOT_BLOCKED = 0,
+    ON_BEFORE_URL_REQUEST = 1 << 0,
+    ON_BEFORE_SEND_HEADERS = 1 << 1,
+    ON_HEADERS_RECEIVED = 1 << 2,
+    ON_AUTH_REQUIRED = 1 << 3
+  };
+
+  void set_retval(int retval) {
+    retval_ = retval;
+  }
+
+  State state() {
+    return state_;
+  }
+
+  // Activates blocking on |state|.
+  void BlockOn(State state) {
+    block_on_ |= state;
+  }
+
+  // Runs the message loop until |state| is reached.
+  void WaitForState(State state) {
+    while (state_ != state)
+      MessageLoop::current()->RunAllPending();
+  }
+
+ protected:
+  BlockingNetworkDelegateBase(int block_on,
+                              int retval,
+                              bool call_base_on_auth_required);
+
+  void ResetState() {
+    state_ = NOT_BLOCKED;
+  }
+
+  // TestNetworkDelegate implementation.
+  virtual int OnBeforeURLRequest(URLRequest* request,
+                                 const CompletionCallback& callback,
+                                 GURL* new_url) OVERRIDE;
+
+  virtual int OnBeforeSendHeaders(URLRequest* request,
+                                  const CompletionCallback& callback,
+                                  HttpRequestHeaders* headers) OVERRIDE;
+
+  virtual int OnHeadersReceived(
+      URLRequest* request,
+      const CompletionCallback& callback,
+      HttpResponseHeaders* original_response_headers,
+      scoped_refptr<HttpResponseHeaders>* override_response_headers) OVERRIDE;
+
+  virtual NetworkDelegate::AuthRequiredResponse OnAuthRequired(
+      URLRequest* request,
+      const AuthChallengeInfo& auth_info,
+      const AuthCallback& callback,
+      AuthCredentials* credentials) OVERRIDE;
+
+ private:
+  int block_on_;  // Bit mask on which states to block.
+  State state_;
+  int retval_;
+  // Should we call TestNetworkDelegate::OnAuthRequired in OnAuthRequired?
+  bool call_base_on_auth_required_;
+
+  DISALLOW_COPY_AND_ASSIGN(BlockingNetworkDelegateBase);
+};
+
+BlockingNetworkDelegateBase::BlockingNetworkDelegateBase(
+    int block_on,
+    int retval,
+    bool call_base_on_auth_required)
+    : block_on_(block_on),
+      state_(NOT_BLOCKED),
+      retval_(retval),
+      call_base_on_auth_required_(call_base_on_auth_required) {
+}
+
+int BlockingNetworkDelegateBase::OnBeforeURLRequest(
+    URLRequest* request,
+    const CompletionCallback& callback,
+    GURL* new_url) {

[mmenke, 2012/09/13 15:28:02]

Suggest you inline these, for consistency with the rest of this file.  Also
think the functions are short enough, that the choice increases readability in
this case.

[vabr (Chromium), 2012/09/13 17:23:35]

I see the lack of consistency, but these are the reasons I have against
in-lining:

* Cascading in-lining in a class hierarchy accumulates long chunks of code which
are copied on each call place, leading to a code bloat. Scott Meyers makes this
point especially about constructors in Item 30 of Effective C++ (3rd edition),
but it applies to member functions as well.

* The style guide says in particular that "virtual functions should never be
declared this way" -- note that the On* methods are virtual. I'm actually
tempted to change this in the existing two classes. In general, the style guide
is against in-lining except for cases where it is proven as necessary. I guess
such a proof should involve a profiler, not just readability or consistency.

My last reason is subjective, but for readability, I actually think that moving
function definition out of class definition is a plus. The interface of the
class fits in a much less space, and is thus easier to read. People interested
in the definition only have to seek at the end of the class.

[mmenke, 2012/09/13 18:48:07]

Rightly or wrongly, in practice this rule tends to be largely ignored in classes
declared in C++ files.
I don't agree with this.  BlockingNetworkDelegateBase does not actually
implement the TestNetworkDelegate interface, and in fact interacts with its
child classes in a rather non-transparent manner.  Without reading both the base
class and the subclasses in their entirety, it's not clear what they actually
do.  As such, I found reading the BlockingNetworkDelegateBase declaration
leaving me with more questions than answers.  If you want to add documentation
to make this no longer the case, I'm fine with that.

+  TestNetworkDelegate::OnBeforeURLRequest(request, callback, new_url);
+  if ((block_on_ & ON_BEFORE_URL_REQUEST) != 0) {

[mmenke, 2012/09/13 15:28:02]

nit:  Suggest you put the "== 0" case first, for consistency.

[vabr (Chromium), 2012/09/13 17:23:35]

Done, also on the places below. Thanks!

+    state_ = ON_BEFORE_URL_REQUEST;
+    return retval_;
+  }
+  return OK;
+}
+
+int BlockingNetworkDelegateBase::OnBeforeSendHeaders(
+    URLRequest* request,
+    const CompletionCallback& callback,
+    HttpRequestHeaders* headers) {
+  TestNetworkDelegate::OnBeforeSendHeaders(request, callback, headers);
+  if ((block_on_ & ON_BEFORE_SEND_HEADERS) != 0) {
+    state_ = ON_BEFORE_SEND_HEADERS;
+    return retval_;
+  }
+  return OK;
+}
+
+int BlockingNetworkDelegateBase::OnHeadersReceived(
+    URLRequest* request,
+    const CompletionCallback& callback,
+    HttpResponseHeaders* original_response_headers,
+    scoped_refptr<HttpResponseHeaders>* override_response_headers) {
+  TestNetworkDelegate::OnHeadersReceived(
+      request, callback,
+      original_response_headers, override_response_headers);
+  if ((block_on_ & ON_HEADERS_RECEIVED) != 0) {
+    state_ = ON_HEADERS_RECEIVED;
+    return retval_;
+  }
+  return OK;
+}
+
+NetworkDelegate::AuthRequiredResponse
+BlockingNetworkDelegateBase::OnAuthRequired(URLRequest* request,
+                                            const AuthChallengeInfo& auth_info,
+                                            const AuthCallback& callback,
+                                            AuthCredentials* credentials) {
+  if (call_base_on_auth_required_) {
+    TestNetworkDelegate::OnAuthRequired(request, auth_info, callback,
+                                        credentials);
+  }
+  if ((block_on_ & ON_AUTH_REQUIRED) != 0) {
+    state_ = ON_AUTH_REQUIRED;
+    // Here we just need to report something different than NO_ACTION.
+    return NetworkDelegate::AUTH_REQUIRED_RESPONSE_CANCEL_AUTH;
+  }
+  return NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
+}
+
 // A network delegate that blocks requests, optionally cancelling or redirecting
 // them.
-class BlockingNetworkDelegate : public TestNetworkDelegate {
+class BlockingNetworkDelegate : public BlockingNetworkDelegateBase {
  public:
   BlockingNetworkDelegate()
-      : retval_(ERR_IO_PENDING),
+      : BlockingNetworkDelegateBase(0, ERR_IO_PENDING, true),
         callback_retval_(OK),
         auth_retval_(NetworkDelegate::AUTH_REQUIRED_RESPONSE_IO_PENDING),
         auth_callback_retval_(
             NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION),
         ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {}
 
-  void set_retval(int retval) { retval_ = retval; }
-  void set_callback_retval(int retval) { callback_retval_ = retval; }
-  void set_redirect_url(const GURL& url) { redirect_url_ = url; }
+  void set_callback_retval(int retval) {
+    callback_retval_ = retval;
+  }
+  void set_redirect_url(const GURL& url) {
+    redirect_url_ = url;
+  }
   void set_auth_retval(NetworkDelegate::AuthRequiredResponse retval) {
-    auth_retval_ = retval; }
+    auth_retval_ = retval;
+  }
   void set_auth_callback_retval(NetworkDelegate::AuthRequiredResponse retval) {
-    auth_callback_retval_ = retval; }
+    auth_callback_retval_ = retval;
+  }
   void set_auth_credentials(const AuthCredentials& auth_credentials) {
     auth_credentials_ = auth_credentials;
   }
 
+  // TODO(vabr): remove when corresponding On* overrides are implemented.

[mmenke, 2012/09/13 15:28:02]

Aren't these already implemented by BlockingNetworkDelegateBase?

[vabr (Chromium), 2012/09/13 17:23:35]

Yes, they are, but they will not post the callback task, so the behaviour would
not be as expected.

[mmenke, 2012/09/13 18:48:07]

This sort of gets at one of my main complaints - the functions of the base class
implement the functionality needed by the interface functions of the same name. 
Callbacks are handled and recorded by the child classes based on the parent
class's return value of the function with the same name.

[mmenke, 2012/09/13 20:44:20]

Sorry, that was worded really poorly.  And I ended up including the issue in my
other comments, anyawys.  If you need me to clarify anything, just ask.

+  void BlockOn(State state) {
+    DCHECK(state != ON_BEFORE_SEND_HEADERS && state != ON_HEADERS_RECEIVED);
+    BlockingNetworkDelegateBase::BlockOn(state);
+  }
+
  private:
   // TestNetworkDelegate implementation.
   virtual int OnBeforeURLRequest(URLRequest* request,
                                  const CompletionCallback& callback,
                                  GURL* new_url) OVERRIDE {
     if (redirect_url_ == request->url()) {
       // We've already seen this request and redirected elsewhere.
       return OK;
     }
 
-    TestNetworkDelegate::OnBeforeURLRequest(request, callback, new_url);
+    int retval = BlockingNetworkDelegateBase::OnBeforeURLRequest(
+        request, callback, new_url);
 
     if (!redirect_url_.is_empty())
       *new_url = redirect_url_;
 
-    if (retval_ != ERR_IO_PENDING)
-      return retval_;
+    if (retval != ERR_IO_PENDING)
+      return retval;
 
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&BlockingNetworkDelegate::DoCallback,
                    weak_factory_.GetWeakPtr(), callback));
     return ERR_IO_PENDING;
   }
 
   virtual NetworkDelegate::AuthRequiredResponse OnAuthRequired(
       URLRequest* request,
       const AuthChallengeInfo& auth_info,
       const AuthCallback& callback,
       AuthCredentials* credentials) OVERRIDE {
-    TestNetworkDelegate::OnAuthRequired(request, auth_info, callback,
-                                        credentials);
+    BlockingNetworkDelegateBase::OnAuthRequired(request, auth_info, callback,
+                                                credentials);
     switch (auth_retval_) {
       case NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION:
         break;
       case NetworkDelegate::AUTH_REQUIRED_RESPONSE_SET_AUTH:
         *credentials = auth_credentials_;
       case NetworkDelegate::AUTH_REQUIRED_RESPONSE_CANCEL_AUTH:
         break;
       case NetworkDelegate::AUTH_REQUIRED_RESPONSE_IO_PENDING:
         MessageLoop::current()->PostTask(
             FROM_HERE,
@@ skipping 11 matching lines @@
   void DoAuthCallback(const AuthCallback& callback,
                       AuthCredentials* credentials) {
     if (auth_callback_retval_ ==
         NetworkDelegate::AUTH_REQUIRED_RESPONSE_SET_AUTH) {
       *credentials = auth_credentials_;
     }
     callback.Run(auth_callback_retval_);
   }
 
 
-  int retval_;
   int callback_retval_;
   GURL redirect_url_;
   NetworkDelegate::AuthRequiredResponse auth_retval_;
   NetworkDelegate::AuthRequiredResponse auth_callback_retval_;
   AuthCredentials auth_credentials_;
   base::WeakPtrFactory<BlockingNetworkDelegate> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(BlockingNetworkDelegate);
 };
 
 // A network delegate that allows blocking requests until a callback function is
 // called.
-class BlockingNetworkDelegateWithManualCallback : public TestNetworkDelegate {
+class BlockingNetworkDelegateWithManualCallback
+    : public BlockingNetworkDelegateBase {
  public:
-  enum State {
-    NOT_BLOCKED = 0,
-    ON_BEFORE_URL_REQUEST = 1 << 0,
-    ON_BEFORE_SEND_HEADERS = 1 << 1,
-    ON_HEADERS_RECEIVED = 1 << 2,
-    ON_AUTH_REQUIRED = 1 << 3
-  };
-
   BlockingNetworkDelegateWithManualCallback()
-      : block_on_(0),
-        state_(NOT_BLOCKED) {
-  }
-
-  // Activates blocking on |state|.
-  void BlockOn(State state) {
-    block_on_ |= state;
+      : BlockingNetworkDelegateBase(0, ERR_IO_PENDING, false) {
   }
 
   void DoCallback(int rv) {
-    ASSERT_NE(NOT_BLOCKED, state_);
+    ASSERT_NE(BlockingNetworkDelegateBase::NOT_BLOCKED, state());
     CompletionCallback callback = callback_;
     Reset();
     callback.Run(rv);
   }
 
   void DoAuthCallback(NetworkDelegate::AuthRequiredResponse response) {
-    ASSERT_EQ(ON_AUTH_REQUIRED, state_);
+    ASSERT_EQ(BlockingNetworkDelegateBase::ON_AUTH_REQUIRED, state());
     AuthCallback auth_callback = auth_callback_;
     Reset();
     auth_callback.Run(response);
   }
 
-  // Runs the message loop until |state| is reached.
-  void WaitForState(State state) {
-    while (state_ != state)
-      MessageLoop::current()->RunAllPending();
-  }
-
  private:
   // TestNetworkDelegate implementation.
   virtual int OnBeforeURLRequest(URLRequest* request,
                                  const CompletionCallback& callback,
                                  GURL* new_url) OVERRIDE {
-    TestNetworkDelegate::OnBeforeURLRequest(request, callback, new_url);
-    if ((block_on_ & ON_BEFORE_URL_REQUEST) == 0) {
-      return OK;
-    } else {
-      state_ = ON_BEFORE_URL_REQUEST;
+    int retval = BlockingNetworkDelegateBase::OnBeforeURLRequest(
+        request, callback, new_url);
+    if (retval == ERR_IO_PENDING)
       callback_ = callback;
-      return ERR_IO_PENDING;
-    }
+    return retval;
   }
 
   virtual int OnBeforeSendHeaders(URLRequest* request,
                                   const CompletionCallback& callback,
                                   HttpRequestHeaders* headers) OVERRIDE {
-    TestNetworkDelegate::OnBeforeSendHeaders(request, callback, headers);
-    if ((block_on_ & ON_BEFORE_SEND_HEADERS) == 0) {
-      return OK;
-    } else {
-      state_ = ON_BEFORE_SEND_HEADERS;
+    int retval = BlockingNetworkDelegateBase::OnBeforeSendHeaders(
+        request, callback, headers);
+    if (retval == ERR_IO_PENDING)
       callback_ = callback;
-      return ERR_IO_PENDING;
-    }
+    return retval;
   }
 
   virtual int OnHeadersReceived(
       URLRequest* request,
       const CompletionCallback& callback,
       HttpResponseHeaders* original_response_headers,
       scoped_refptr<HttpResponseHeaders>* override_response_headers)
       OVERRIDE {
-    TestNetworkDelegate::OnHeadersReceived(
-        request, callback, original_response_headers,
-        override_response_headers);
-    if ((block_on_ & ON_HEADERS_RECEIVED) == 0) {
-      return OK;
-    } else {
-      state_ = ON_HEADERS_RECEIVED;
+    int retval = BlockingNetworkDelegateBase::OnHeadersReceived(
+        request, callback,
+        original_response_headers, override_response_headers);
+    if (retval == ERR_IO_PENDING)
       callback_ = callback;
-      return ERR_IO_PENDING;
-    }
+    return retval;
   }
 
   virtual NetworkDelegate::AuthRequiredResponse OnAuthRequired(
       URLRequest* request,
       const AuthChallengeInfo& auth_info,
       const AuthCallback& callback,
       AuthCredentials* credentials) OVERRIDE {
-    if ((block_on_ & ON_AUTH_REQUIRED) == 0) {
-      return NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
-    } else {
-      state_ = ON_AUTH_REQUIRED;
+    if (BlockingNetworkDelegateBase::OnAuthRequired(
+            request, auth_info, callback, credentials) !=
+        NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION) {
+      // We should block on authorisation requirement.
       auth_callback_ = callback;
       return NetworkDelegate::AUTH_REQUIRED_RESPONSE_IO_PENDING;
     }
+    return NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
   }
 
   void Reset() {
-    state_ = NOT_BLOCKED;
+    ResetState();
     callback_.Reset();
     auth_callback_.Reset();
   }
 
-  int block_on_;  // Bit mask on which states to block.
-  State state_;
   CompletionCallback callback_;
   AuthCallback auth_callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(BlockingNetworkDelegateWithManualCallback);
 };
 
 
 // A simple Interceptor that returns a pre-built URLRequestJob one time.
 class TestJobInterceptor : public URLRequestJobFactory::Interceptor {
  public:
   TestJobInterceptor()
       : main_intercept_job_(NULL) {
   }
 
@@ skipping 1577 matching lines @@
     EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, network_delegate.last_error());
   }
 }
 
 // Tests that the network delegate can block and cancel a request.
 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequest) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate;
+  network_delegate.BlockOn(BlockingNetworkDelegateBase::ON_BEFORE_URL_REQUEST);
   network_delegate.set_callback_retval(ERR_EMPTY_RESPONSE);
 
   TestURLRequestContextWithProxy context(
       test_server_.host_port_pair().ToString(),
       &network_delegate);
 
   {
     URLRequest r(test_server_.GetURL(""), &d, &context);
 
     r.Start();
     MessageLoop::current()->Run();
 
     EXPECT_EQ(URLRequestStatus::FAILED, r.status().status());
     EXPECT_EQ(ERR_EMPTY_RESPONSE, r.status().error());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that the network delegate can cancel a request synchronously.
 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestSynchronously) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate;
+  network_delegate.BlockOn(BlockingNetworkDelegateBase::ON_BEFORE_URL_REQUEST);
   network_delegate.set_retval(ERR_EMPTY_RESPONSE);
 
   TestURLRequestContextWithProxy context(
       test_server_.host_port_pair().ToString(),
       &network_delegate);
 
   {
     URLRequest r(test_server_.GetURL(""), &d, &context);
 
     r.Start();
     MessageLoop::current()->Run();
 
     EXPECT_EQ(URLRequestStatus::FAILED, r.status().status());
     EXPECT_EQ(ERR_EMPTY_RESPONSE, r.status().error());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that the network delegate can block and redirect a request to a new
 // URL.
 TEST_F(URLRequestTestHTTP, NetworkDelegateRedirectRequest) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate;
+  network_delegate.BlockOn(BlockingNetworkDelegateBase::ON_BEFORE_URL_REQUEST);
   GURL redirect_url(test_server_.GetURL("simple.html"));
   network_delegate.set_redirect_url(redirect_url);
 
   TestURLRequestContextWithProxy context(
       test_server_.host_port_pair().ToString(),
       &network_delegate);
 
   {
     GURL original_url(test_server_.GetURL("empty.html"));
     URLRequest r(original_url, &d, &context);
@@ skipping 12 matching lines @@
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that the network delegate can block and redirect a request to a new
 // URL by setting a redirect_url and returning in OnBeforeURLRequest directly.
 TEST_F(URLRequestTestHTTP, NetworkDelegateRedirectRequestSynchronously) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate;
+  network_delegate.BlockOn(BlockingNetworkDelegateBase::ON_BEFORE_URL_REQUEST);
   GURL redirect_url(test_server_.GetURL("simple.html"));
   network_delegate.set_redirect_url(redirect_url);
   network_delegate.set_retval(OK);
 
   TestURLRequestContextWithProxy context(
       test_server_.host_port_pair().ToString(),
       &network_delegate);
 
   {
     GURL original_url(test_server_.GetURL("empty.html"));
@@ skipping 14 matching lines @@
 }
 
 // Tests that redirects caused by the network delegate preserve POST data.
 TEST_F(URLRequestTestHTTP, NetworkDelegateRedirectRequestPost) {
   ASSERT_TRUE(test_server_.Start());
 
   const char kData[] = "hello world";
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate;
+  network_delegate.BlockOn(BlockingNetworkDelegateBase::ON_BEFORE_URL_REQUEST);
   GURL redirect_url(test_server_.GetURL("echo"));
   network_delegate.set_redirect_url(redirect_url);
 
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   {
     GURL original_url(test_server_.GetURL("empty.html"));
     URLRequest r(original_url, &d, &context);
@@ skipping 21 matching lines @@
 
 // Tests that the network delegate can synchronously complete OnAuthRequired
 // by taking no action. This indicates that the NetworkDelegate does not want to
 // handle the challenge, and is passing the buck along to the
 // URLRequest::Delegate.
 TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredSyncNoAction) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate;
+  network_delegate.BlockOn(BlockingNetworkDelegateBase::ON_BEFORE_URL_REQUEST);
   network_delegate.set_auth_retval(
       NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION);
 
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   d.set_credentials(AuthCredentials(kUser, kSecret));
 
   {
@@ skipping 12 matching lines @@
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that the network delegate can synchronously complete OnAuthRequired
 // by setting credentials.
 TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredSyncSetAuth) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate;
+  network_delegate.BlockOn(BlockingNetworkDelegateBase::ON_BEFORE_URL_REQUEST);
   network_delegate.set_auth_retval(
       NetworkDelegate::AUTH_REQUIRED_RESPONSE_SET_AUTH);
 
   network_delegate.set_auth_credentials(AuthCredentials(kUser, kSecret));
 
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   {
@@ skipping 12 matching lines @@
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that the network delegate can synchronously complete OnAuthRequired
 // by cancelling authentication.
 TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredSyncCancel) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate;
+  network_delegate.BlockOn(BlockingNetworkDelegateBase::ON_BEFORE_URL_REQUEST);
   network_delegate.set_auth_retval(
       NetworkDelegate::AUTH_REQUIRED_RESPONSE_CANCEL_AUTH);
 
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   {
     GURL url(test_server_.GetURL("auth-basic"));
     URLRequest r(url, &d, &context);
@@ skipping 12 matching lines @@
 
 // Tests that the network delegate can asynchronously complete OnAuthRequired
 // by taking no action. This indicates that the NetworkDelegate does not want
 // to handle the challenge, and is passing the buck along to the
 // URLRequest::Delegate.
 TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredAsyncNoAction) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate;
+  network_delegate.BlockOn(BlockingNetworkDelegateBase::ON_BEFORE_URL_REQUEST);
   network_delegate.set_auth_retval(
       NetworkDelegate::AUTH_REQUIRED_RESPONSE_IO_PENDING);
   network_delegate.set_auth_callback_retval(
       NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION);
 
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   d.set_credentials(AuthCredentials(kUser, kSecret));
@@ skipping 14 matching lines @@
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that the network delegate can asynchronously complete OnAuthRequired
 // by setting credentials.
 TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredAsyncSetAuth) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate;
+  network_delegate.BlockOn(BlockingNetworkDelegateBase::ON_BEFORE_URL_REQUEST);
   network_delegate.set_auth_retval(
       NetworkDelegate::AUTH_REQUIRED_RESPONSE_IO_PENDING);
   network_delegate.set_auth_callback_retval(
       NetworkDelegate::AUTH_REQUIRED_RESPONSE_SET_AUTH);
 
   AuthCredentials auth_credentials(kUser, kSecret);
   network_delegate.set_auth_credentials(auth_credentials);
 
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
@@ skipping 16 matching lines @@
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that the network delegate can asynchronously complete OnAuthRequired
 // by cancelling authentication.
 TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredAsyncCancel) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   BlockingNetworkDelegate network_delegate;
+  network_delegate.BlockOn(BlockingNetworkDelegateBase::ON_BEFORE_URL_REQUEST);
   network_delegate.set_auth_retval(
       NetworkDelegate::AUTH_REQUIRED_RESPONSE_IO_PENDING);
   network_delegate.set_auth_callback_retval(
       NetworkDelegate::AUTH_REQUIRED_RESPONSE_CANCEL_AUTH);
 
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   {
@@ skipping 13 matching lines @@
 }
 
 // Tests that we can handle when a network request was canceled while we were
 // waiting for the network delegate.
 // Part 1: Request is cancelled while waiting for OnBeforeURLRequest callback.
 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelWhileWaiting1) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   BlockingNetworkDelegateWithManualCallback network_delegate;
-  network_delegate.BlockOn(
-      BlockingNetworkDelegateWithManualCallback::ON_BEFORE_URL_REQUEST);
+  network_delegate.BlockOn(BlockingNetworkDelegateBase::ON_BEFORE_URL_REQUEST);
 
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   {
     URLRequest r(test_server_.GetURL(""), &d, &context);
 
     r.Start();
     network_delegate.WaitForState(
-        BlockingNetworkDelegateWithManualCallback::ON_BEFORE_URL_REQUEST);
+        BlockingNetworkDelegateBase::ON_BEFORE_URL_REQUEST);
     EXPECT_EQ(0, network_delegate.completed_requests());
     // Cancel before callback.
     r.Cancel();
     // Ensure that network delegate is notified.
     EXPECT_EQ(1, network_delegate.completed_requests());
     EXPECT_EQ(URLRequestStatus::CANCELED, r.status().status());
     EXPECT_EQ(ERR_ABORTED, r.status().error());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that we can handle when a network request was canceled while we were
 // waiting for the network delegate.
 // Part 2: Request is cancelled while waiting for OnBeforeSendHeaders callback.
 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelWhileWaiting2) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   BlockingNetworkDelegateWithManualCallback network_delegate;
-  network_delegate.BlockOn(
-      BlockingNetworkDelegateWithManualCallback::ON_BEFORE_SEND_HEADERS);
+  network_delegate.BlockOn(BlockingNetworkDelegateBase::ON_BEFORE_SEND_HEADERS);
 
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   {
     URLRequest r(test_server_.GetURL(""), &d, &context);
 
     r.Start();
     network_delegate.WaitForState(
-        BlockingNetworkDelegateWithManualCallback::ON_BEFORE_SEND_HEADERS);
+        BlockingNetworkDelegateBase::ON_BEFORE_SEND_HEADERS);
     EXPECT_EQ(0, network_delegate.completed_requests());
     // Cancel before callback.
     r.Cancel();
     // Ensure that network delegate is notified.
     EXPECT_EQ(1, network_delegate.completed_requests());
     EXPECT_EQ(URLRequestStatus::CANCELED, r.status().status());
     EXPECT_EQ(ERR_ABORTED, r.status().error());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that we can handle when a network request was canceled while we were
 // waiting for the network delegate.
 // Part 3: Request is cancelled while waiting for OnHeadersReceived callback.
 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelWhileWaiting3) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   BlockingNetworkDelegateWithManualCallback network_delegate;
-  network_delegate.BlockOn(
-      BlockingNetworkDelegateWithManualCallback::ON_HEADERS_RECEIVED);
+  network_delegate.BlockOn(BlockingNetworkDelegateBase::ON_HEADERS_RECEIVED);
 
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   {
     URLRequest r(test_server_.GetURL(""), &d, &context);
 
     r.Start();
     network_delegate.WaitForState(
-        BlockingNetworkDelegateWithManualCallback::ON_HEADERS_RECEIVED);
+        BlockingNetworkDelegateBase::ON_HEADERS_RECEIVED);
     EXPECT_EQ(0, network_delegate.completed_requests());
     // Cancel before callback.
     r.Cancel();
     // Ensure that network delegate is notified.
     EXPECT_EQ(1, network_delegate.completed_requests());
     EXPECT_EQ(URLRequestStatus::CANCELED, r.status().status());
     EXPECT_EQ(ERR_ABORTED, r.status().error());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
   EXPECT_EQ(1, network_delegate.destroyed_requests());
 }
 
 // Tests that we can handle when a network request was canceled while we were
 // waiting for the network delegate.
 // Part 4: Request is cancelled while waiting for OnAuthRequired callback.
 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelWhileWaiting4) {
   ASSERT_TRUE(test_server_.Start());
 
   TestDelegate d;
   BlockingNetworkDelegateWithManualCallback network_delegate;
   network_delegate.BlockOn(
-      BlockingNetworkDelegateWithManualCallback::ON_AUTH_REQUIRED);
+      BlockingNetworkDelegateBase::ON_AUTH_REQUIRED);
 
   TestURLRequestContext context(true);
   context.set_network_delegate(&network_delegate);
   context.Init();
 
   {
     URLRequest r(test_server_.GetURL("auth-basic"), &d, &context);
 
     r.Start();
     network_delegate.WaitForState(
-        BlockingNetworkDelegateWithManualCallback::ON_AUTH_REQUIRED);
+        BlockingNetworkDelegateBase::ON_AUTH_REQUIRED);
     EXPECT_EQ(0, network_delegate.completed_requests());
     // Cancel before callback.
     r.Cancel();
     // Ensure that network delegate is notified.
     EXPECT_EQ(1, network_delegate.completed_requests());
     EXPECT_EQ(URLRequestStatus::CANCELED, r.status().status());
     EXPECT_EQ(ERR_ABORTED, r.status().error());
     EXPECT_EQ(1, network_delegate.created_requests());
     EXPECT_EQ(0, network_delegate.destroyed_requests());
   }
@@ skipping 2249 matching lines @@
 
     EXPECT_FALSE(r.is_pending());
     EXPECT_EQ(1, d->response_started_count());
     EXPECT_FALSE(d->received_data_before_response());
     EXPECT_EQ(d->bytes_received(), static_cast<int>(file_size));
   }
 }
 #endif  // !defined(DISABLE_FTP_SUPPORT)
 
 }  // namespace net