[net/http auth] Make HttpAuthHandler challenge handling asynchronous.

net/http/http_network_transaction_unittest.cc

 // Copyright 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 "net/http/http_network_transaction.h"
 
 #include <math.h>  // ceil
 #include <stdarg.h>
 #include <stdint.h>
 
@@ skipping 10313 matching lines @@
     const char* const proxy_url;
     AuthTiming proxy_auth_timing;
     int proxy_auth_rv;
     const char* const server_url;
     AuthTiming server_auth_timing;
     int server_auth_rv;
     int num_auth_rounds;
     int first_ssl_round;
     TestRound rounds[3];
   } test_configs[] = {
-    // Non-authenticating HTTP server with a direct connection.
-    { NULL, AUTH_NONE, OK, kServer, AUTH_NONE, OK, 1, kNoSSL,
-      { TestRound(kGet, kSuccess, OK)}},
-    // Authenticating HTTP server with a direct connection.
-    { NULL, AUTH_NONE, OK, kServer, AUTH_SYNC, OK, 2, kNoSSL,
-      { TestRound(kGet, kServerChallenge, OK),
-        TestRound(kGetAuth, kSuccess, OK)}},
-    { NULL, AUTH_NONE, OK, kServer, AUTH_SYNC, kAuthErr, 2, kNoSSL,
-      { TestRound(kGet, kServerChallenge, OK),
-        TestRound(kGetAuth, kFailure, kAuthErr)}},
-    { NULL, AUTH_NONE, OK, kServer, AUTH_ASYNC, OK, 2, kNoSSL,
-      { TestRound(kGet, kServerChallenge, OK),
-        TestRound(kGetAuth, kSuccess, OK)}},
-    { NULL, AUTH_NONE, OK, kServer, AUTH_ASYNC, kAuthErr, 2, kNoSSL,
-      { TestRound(kGet, kServerChallenge, OK),
-        TestRound(kGetAuth, kFailure, kAuthErr)}},
-    // Non-authenticating HTTP server through a non-authenticating proxy.
-    { kProxy, AUTH_NONE, OK, kServer, AUTH_NONE, OK, 1, kNoSSL,
-      { TestRound(kGetProxy, kSuccess, OK)}},
-    // Authenticating HTTP server through a non-authenticating proxy.
-    { kProxy, AUTH_NONE, OK, kServer, AUTH_SYNC, OK, 2, kNoSSL,
-      { TestRound(kGetProxy, kServerChallenge, OK),
+      // Non-authenticating HTTP server with a direct connection.
+      {NULL,
+       AUTH_NONE,
+       OK,
+       kServer,
+       AUTH_NONE,
+       OK,
+       1,
+       kNoSSL,
+       {TestRound(kGet, kSuccess, OK)}},
+      // Authenticating HTTP server with a direct connection.
+      {NULL,
+       AUTH_NONE,
+       OK,
+       kServer,
+       AUTH_SYNC,
+       OK,
+       2,
+       kNoSSL,
+       {TestRound(kGet, kServerChallenge, OK),
+        TestRound(kGetAuth, kSuccess, OK)}},
+      {NULL,
+       AUTH_NONE,
+       OK,
+       kServer,
+       AUTH_SYNC,
+       kAuthErr,
+       2,
+       kNoSSL,
+       {TestRound(kGet, kServerChallenge, OK),
+        TestRound(kGetAuth, kFailure, kAuthErr)}},
+      {NULL,
+       AUTH_NONE,
+       OK,
+       kServer,
+       AUTH_ASYNC,
+       OK,
+       2,
+       kNoSSL,
+       {TestRound(kGet, kServerChallenge, OK),
+        TestRound(kGetAuth, kSuccess, OK)}},
+      {NULL,
+       AUTH_NONE,
+       OK,
+       kServer,
+       AUTH_ASYNC,
+       kAuthErr,
+       2,
+       kNoSSL,
+       {TestRound(kGet, kServerChallenge, OK),
+        TestRound(kGetAuth, kFailure, kAuthErr)}},
+      // Non-authenticating HTTP server through a non-authenticating proxy.
+      {kProxy,
+       AUTH_NONE,
+       OK,
+       kServer,
+       AUTH_NONE,
+       OK,
+       1,
+       kNoSSL,
+       {TestRound(kGetProxy, kSuccess, OK)}},
+      // Authenticating HTTP server through a non-authenticating proxy.
+      {kProxy,
+       AUTH_NONE,
+       OK,
+       kServer,
+       AUTH_SYNC,
+       OK,
+       2,
+       kNoSSL,
+       {TestRound(kGetProxy, kServerChallenge, OK),
         TestRound(kGetAuthThroughProxy, kSuccess, OK)}},
-    { kProxy, AUTH_NONE, OK, kServer, AUTH_SYNC, kAuthErr, 2, kNoSSL,
-      { TestRound(kGetProxy, kServerChallenge, OK),
+      {kProxy,
+       AUTH_NONE,
+       OK,
+       kServer,
+       AUTH_SYNC,
+       kAuthErr,
+       2,
+       kNoSSL,
+       {TestRound(kGetProxy, kServerChallenge, OK),
         TestRound(kGetAuthThroughProxy, kFailure, kAuthErr)}},
-    { kProxy, AUTH_NONE, OK, kServer, AUTH_ASYNC, OK, 2, kNoSSL,
-      { TestRound(kGetProxy, kServerChallenge, OK),
+      {kProxy,
+       AUTH_NONE,
+       OK,
+       kServer,
+       AUTH_ASYNC,
+       OK,
+       2,
+       kNoSSL,
+       {TestRound(kGetProxy, kServerChallenge, OK),
         TestRound(kGetAuthThroughProxy, kSuccess, OK)}},
-    { kProxy, AUTH_NONE, OK, kServer, AUTH_ASYNC, kAuthErr, 2, kNoSSL,
-      { TestRound(kGetProxy, kServerChallenge, OK),
+      {kProxy,
+       AUTH_NONE,
+       OK,
+       kServer,
+       AUTH_ASYNC,
+       kAuthErr,
+       2,
+       kNoSSL,
+       {TestRound(kGetProxy, kServerChallenge, OK),
         TestRound(kGetAuthThroughProxy, kFailure, kAuthErr)}},
-    // Non-authenticating HTTP server through an authenticating proxy.
-    { kProxy, AUTH_SYNC, OK, kServer, AUTH_NONE, OK, 2, kNoSSL,
-      { TestRound(kGetProxy, kProxyChallenge, OK),
+      // Non-authenticating HTTP server through an authenticating proxy.
+      {kProxy,
+       AUTH_SYNC,
+       OK,
+       kServer,
+       AUTH_NONE,
+       OK,
+       2,
+       kNoSSL,
+       {TestRound(kGetProxy, kProxyChallenge, OK),
         TestRound(kGetProxyAuth, kSuccess, OK)}},
-    { kProxy, AUTH_SYNC, kAuthErr, kServer, AUTH_NONE, OK, 2, kNoSSL,
-      { TestRound(kGetProxy, kProxyChallenge, OK),
+      {kProxy,
+       AUTH_SYNC,
+       kAuthErr,
+       kServer,
+       AUTH_NONE,
+       OK,
+       2,
+       kNoSSL,
+       {TestRound(kGetProxy, kProxyChallenge, OK),
         TestRound(kGetProxyAuth, kFailure, kAuthErr)}},
-    { kProxy, AUTH_ASYNC, OK, kServer, AUTH_NONE, OK, 2, kNoSSL,
-      { TestRound(kGetProxy, kProxyChallenge, OK),
+      {kProxy,
+       AUTH_ASYNC,
+       OK,
+       kServer,
+       AUTH_NONE,
+       OK,
+       2,
+       kNoSSL,
+       {TestRound(kGetProxy, kProxyChallenge, OK),
         TestRound(kGetProxyAuth, kSuccess, OK)}},
-    { kProxy, AUTH_ASYNC, kAuthErr, kServer, AUTH_NONE, OK, 2, kNoSSL,
-      { TestRound(kGetProxy, kProxyChallenge, OK),
+      {kProxy,
+       AUTH_ASYNC,
+       kAuthErr,
+       kServer,
+       AUTH_NONE,
+       OK,
+       2,
+       kNoSSL,
+       {TestRound(kGetProxy, kProxyChallenge, OK),
         TestRound(kGetProxyAuth, kFailure, kAuthErr)}},
-    // Authenticating HTTP server through an authenticating proxy.
-    { kProxy, AUTH_SYNC, OK, kServer, AUTH_SYNC, OK, 3, kNoSSL,
-      { TestRound(kGetProxy, kProxyChallenge, OK),
+      // Authenticating HTTP server through an authenticating proxy.
+      {kProxy,
+       AUTH_SYNC,
+       OK,
+       kServer,
+       AUTH_SYNC,
+       OK,
+       3,
+       kNoSSL,
+       {TestRound(kGetProxy, kProxyChallenge, OK),
         TestRound(kGetProxyAuth, kServerChallenge, OK),
         TestRound(kGetAuthWithProxyAuth, kSuccess, OK)}},
-    { kProxy, AUTH_SYNC, OK, kServer, AUTH_SYNC, kAuthErr, 3, kNoSSL,
-      { TestRound(kGetProxy, kProxyChallenge, OK),
+      {kProxy,
+       AUTH_SYNC,
+       OK,
+       kServer,
+       AUTH_SYNC,
+       kAuthErr,
+       3,
+       kNoSSL,
+       {TestRound(kGetProxy, kProxyChallenge, OK),
         TestRound(kGetProxyAuth, kServerChallenge, OK),
         TestRound(kGetAuthWithProxyAuth, kFailure, kAuthErr)}},
-    { kProxy, AUTH_ASYNC, OK, kServer, AUTH_SYNC, OK, 3, kNoSSL,
-      { TestRound(kGetProxy, kProxyChallenge, OK),
+      {kProxy,
+       AUTH_ASYNC,
+       OK,
+       kServer,
+       AUTH_SYNC,
+       OK,
+       3,
+       kNoSSL,
+       {TestRound(kGetProxy, kProxyChallenge, OK),
         TestRound(kGetProxyAuth, kServerChallenge, OK),
         TestRound(kGetAuthWithProxyAuth, kSuccess, OK)}},
-    { kProxy, AUTH_ASYNC, OK, kServer, AUTH_SYNC, kAuthErr, 3, kNoSSL,
-      { TestRound(kGetProxy, kProxyChallenge, OK),
+      {kProxy,
+       AUTH_ASYNC,
+       OK,
+       kServer,
+       AUTH_SYNC,
+       kAuthErr,
+       3,
+       kNoSSL,
+       {TestRound(kGetProxy, kProxyChallenge, OK),
         TestRound(kGetProxyAuth, kServerChallenge, OK),
         TestRound(kGetAuthWithProxyAuth, kFailure, kAuthErr)}},
-    { kProxy, AUTH_SYNC, OK, kServer, AUTH_ASYNC, OK, 3, kNoSSL,
-      { TestRound(kGetProxy, kProxyChallenge, OK),
+      {kProxy,
+       AUTH_SYNC,
+       OK,
+       kServer,
+       AUTH_ASYNC,
+       OK,
+       3,
+       kNoSSL,
+       {TestRound(kGetProxy, kProxyChallenge, OK),
         TestRound(kGetProxyAuth, kServerChallenge, OK),
         TestRound(kGetAuthWithProxyAuth, kSuccess, OK)}},
-    { kProxy, AUTH_SYNC, OK, kServer, AUTH_ASYNC, kAuthErr, 3, kNoSSL,
-      { TestRound(kGetProxy, kProxyChallenge, OK),
+      {kProxy,
+       AUTH_SYNC,
+       OK,
+       kServer,
+       AUTH_ASYNC,
+       kAuthErr,
+       3,
+       kNoSSL,
+       {TestRound(kGetProxy, kProxyChallenge, OK),
         TestRound(kGetProxyAuth, kServerChallenge, OK),
         TestRound(kGetAuthWithProxyAuth, kFailure, kAuthErr)}},
-    { kProxy, AUTH_ASYNC, OK, kServer, AUTH_ASYNC, OK, 3, kNoSSL,
-      { TestRound(kGetProxy, kProxyChallenge, OK),
+      {kProxy,
+       AUTH_ASYNC,
+       OK,
+       kServer,
+       AUTH_ASYNC,
+       OK,
+       3,
+       kNoSSL,
+       {TestRound(kGetProxy, kProxyChallenge, OK),
         TestRound(kGetProxyAuth, kServerChallenge, OK),
         TestRound(kGetAuthWithProxyAuth, kSuccess, OK)}},
-    { kProxy, AUTH_ASYNC, OK, kServer, AUTH_ASYNC, kAuthErr, 3, kNoSSL,
-      { TestRound(kGetProxy, kProxyChallenge, OK),
+      {kProxy,
+       AUTH_ASYNC,
+       OK,
+       kServer,
+       AUTH_ASYNC,
+       kAuthErr,
+       3,
+       kNoSSL,
+       {TestRound(kGetProxy, kProxyChallenge, OK),
         TestRound(kGetProxyAuth, kServerChallenge, OK),
         TestRound(kGetAuthWithProxyAuth, kFailure, kAuthErr)}},
-    // Non-authenticating HTTPS server with a direct connection.
-    { NULL, AUTH_NONE, OK, kSecureServer, AUTH_NONE, OK, 1, 0,
-      { TestRound(kGet, kSuccess, OK)}},
-    // Authenticating HTTPS server with a direct connection.
-    { NULL, AUTH_NONE, OK, kSecureServer, AUTH_SYNC, OK, 2, 0,
-      { TestRound(kGet, kServerChallenge, OK),
-        TestRound(kGetAuth, kSuccess, OK)}},
-    { NULL, AUTH_NONE, OK, kSecureServer, AUTH_SYNC, kAuthErr, 2, 0,
-      { TestRound(kGet, kServerChallenge, OK),
-        TestRound(kGetAuth, kFailure, kAuthErr)}},
-    { NULL, AUTH_NONE, OK, kSecureServer, AUTH_ASYNC, OK, 2, 0,
-      { TestRound(kGet, kServerChallenge, OK),
-        TestRound(kGetAuth, kSuccess, OK)}},
-    { NULL, AUTH_NONE, OK, kSecureServer, AUTH_ASYNC, kAuthErr, 2, 0,
-      { TestRound(kGet, kServerChallenge, OK),
-        TestRound(kGetAuth, kFailure, kAuthErr)}},
-    // Non-authenticating HTTPS server with a non-authenticating proxy.
-    { kProxy, AUTH_NONE, OK, kSecureServer, AUTH_NONE, OK, 1, 0,
-      { TestRound(kConnect, kProxyConnected, OK, &kGet, &kSuccess)}},
-    // Authenticating HTTPS server through a non-authenticating proxy.
-    { kProxy, AUTH_NONE, OK, kSecureServer, AUTH_SYNC, OK, 2, 0,
-      { TestRound(kConnect, kProxyConnected, OK, &kGet, &kServerChallenge),
-        TestRound(kGetAuth, kSuccess, OK)}},
-    { kProxy, AUTH_NONE, OK, kSecureServer, AUTH_SYNC, kAuthErr, 2, 0,
-      { TestRound(kConnect, kProxyConnected, OK, &kGet, &kServerChallenge),
-        TestRound(kGetAuth, kFailure, kAuthErr)}},
-    { kProxy, AUTH_NONE, OK, kSecureServer, AUTH_ASYNC, OK, 2, 0,
-      { TestRound(kConnect, kProxyConnected, OK, &kGet, &kServerChallenge),
-        TestRound(kGetAuth, kSuccess, OK)}},
-    { kProxy, AUTH_NONE, OK, kSecureServer, AUTH_ASYNC, kAuthErr, 2, 0,
-      { TestRound(kConnect, kProxyConnected, OK, &kGet, &kServerChallenge),
-        TestRound(kGetAuth, kFailure, kAuthErr)}},
-    // Non-Authenticating HTTPS server through an authenticating proxy.
-    { kProxy, AUTH_SYNC, OK, kSecureServer, AUTH_NONE, OK, 2, 1,
-      { TestRound(kConnect, kProxyChallenge, OK),
+      // Non-authenticating HTTPS server with a direct connection.
+      {NULL,
+       AUTH_NONE,
+       OK,
+       kSecureServer,
+       AUTH_NONE,
+       OK,
+       1,
+       0,
+       {TestRound(kGet, kSuccess, OK)}},
+      // Authenticating HTTPS server with a direct connection.
+      {NULL,
+       AUTH_NONE,
+       OK,
+       kSecureServer,
+       AUTH_SYNC,
+       OK,
+       2,
+       0,
+       {TestRound(kGet, kServerChallenge, OK),
+        TestRound(kGetAuth, kSuccess, OK)}},
+      {NULL,
+       AUTH_NONE,
+       OK,
+       kSecureServer,
+       AUTH_SYNC,
+       kAuthErr,
+       2,
+       0,
+       {TestRound(kGet, kServerChallenge, OK),
+        TestRound(kGetAuth, kFailure, kAuthErr)}},
+      {NULL,
+       AUTH_NONE,
+       OK,
+       kSecureServer,
+       AUTH_ASYNC,
+       OK,
+       2,
+       0,
+       {TestRound(kGet, kServerChallenge, OK),
+        TestRound(kGetAuth, kSuccess, OK)}},
+      {NULL,
+       AUTH_NONE,
+       OK,
+       kSecureServer,
+       AUTH_ASYNC,
+       kAuthErr,
+       2,
+       0,
+       {TestRound(kGet, kServerChallenge, OK),
+        TestRound(kGetAuth, kFailure, kAuthErr)}},
+      // Non-authenticating HTTPS server with a non-authenticating proxy.
+      {kProxy,
+       AUTH_NONE,
+       OK,
+       kSecureServer,
+       AUTH_NONE,
+       OK,
+       1,
+       0,
+       {TestRound(kConnect, kProxyConnected, OK, &kGet, &kSuccess)}},
+      // Authenticating HTTPS server through a non-authenticating proxy.
+      {kProxy,
+       AUTH_NONE,
+       OK,
+       kSecureServer,
+       AUTH_SYNC,
+       OK,
+       2,
+       0,
+       {TestRound(kConnect, kProxyConnected, OK, &kGet, &kServerChallenge),
+        TestRound(kGetAuth, kSuccess, OK)}},
+      {kProxy,
+       AUTH_NONE,
+       OK,
+       kSecureServer,
+       AUTH_SYNC,
+       kAuthErr,
+       2,
+       0,
+       {TestRound(kConnect, kProxyConnected, OK, &kGet, &kServerChallenge),
+        TestRound(kGetAuth, kFailure, kAuthErr)}},
+      {kProxy,
+       AUTH_NONE,
+       OK,
+       kSecureServer,
+       AUTH_ASYNC,
+       OK,
+       2,
+       0,
+       {TestRound(kConnect, kProxyConnected, OK, &kGet, &kServerChallenge),
+        TestRound(kGetAuth, kSuccess, OK)}},
+      {kProxy,
+       AUTH_NONE,
+       OK,
+       kSecureServer,
+       AUTH_ASYNC,
+       kAuthErr,
+       2,
+       0,
+       {TestRound(kConnect, kProxyConnected, OK, &kGet, &kServerChallenge),
+        TestRound(kGetAuth, kFailure, kAuthErr)}},
+      // Non-Authenticating HTTPS server through an authenticating proxy.
+      {kProxy,
+       AUTH_SYNC,
+       OK,
+       kSecureServer,
+       AUTH_NONE,
+       OK,
+       2,
+       1,
+       {TestRound(kConnect, kProxyChallenge, OK),
         TestRound(kConnectProxyAuth, kProxyConnected, OK, &kGet, &kSuccess)}},
-    { kProxy, AUTH_SYNC, kAuthErr, kSecureServer, AUTH_NONE, OK, 2, kNoSSL,
-      { TestRound(kConnect, kProxyChallenge, OK),
+      {kProxy,
+       AUTH_SYNC,
+       kAuthErr,
+       kSecureServer,
+       AUTH_NONE,
+       OK,
+       2,
+       kNoSSL,
+       {TestRound(kConnect, kProxyChallenge, OK),
         TestRound(kConnectProxyAuth, kFailure, kAuthErr)}},
-    { kProxy, AUTH_ASYNC, OK, kSecureServer, AUTH_NONE, OK, 2, 1,
-      { TestRound(kConnect, kProxyChallenge, OK),
+      {kProxy,
+       AUTH_ASYNC,
+       OK,
+       kSecureServer,
+       AUTH_NONE,
+       OK,
+       2,
+       1,
+       {TestRound(kConnect, kProxyChallenge, OK),
         TestRound(kConnectProxyAuth, kProxyConnected, OK, &kGet, &kSuccess)}},
-    { kProxy, AUTH_ASYNC, kAuthErr, kSecureServer, AUTH_NONE, OK, 2, kNoSSL,
-      { TestRound(kConnect, kProxyChallenge, OK),
+      {kProxy,
+       AUTH_ASYNC,
+       kAuthErr,
+       kSecureServer,
+       AUTH_NONE,
+       OK,
+       2,
+       kNoSSL,
+       {TestRound(kConnect, kProxyChallenge, OK),
         TestRound(kConnectProxyAuth, kFailure, kAuthErr)}},
-    // Authenticating HTTPS server through an authenticating proxy.
-    { kProxy, AUTH_SYNC, OK, kSecureServer, AUTH_SYNC, OK, 3, 1,
-      { TestRound(kConnect, kProxyChallenge, OK),
-        TestRound(kConnectProxyAuth, kProxyConnected, OK,
-                  &kGet, &kServerChallenge),
-        TestRound(kGetAuth, kSuccess, OK)}},
-    { kProxy, AUTH_SYNC, OK, kSecureServer, AUTH_SYNC, kAuthErr, 3, 1,
-      { TestRound(kConnect, kProxyChallenge, OK),
-        TestRound(kConnectProxyAuth, kProxyConnected, OK,
-                  &kGet, &kServerChallenge),
-        TestRound(kGetAuth, kFailure, kAuthErr)}},
-    { kProxy, AUTH_ASYNC, OK, kSecureServer, AUTH_SYNC, OK, 3, 1,
-      { TestRound(kConnect, kProxyChallenge, OK),
-        TestRound(kConnectProxyAuth, kProxyConnected, OK,
-                  &kGet, &kServerChallenge),
-        TestRound(kGetAuth, kSuccess, OK)}},
-    { kProxy, AUTH_ASYNC, OK, kSecureServer, AUTH_SYNC, kAuthErr, 3, 1,
-      { TestRound(kConnect, kProxyChallenge, OK),
-        TestRound(kConnectProxyAuth, kProxyConnected, OK,
-                  &kGet, &kServerChallenge),
-        TestRound(kGetAuth, kFailure, kAuthErr)}},
-    { kProxy, AUTH_SYNC, OK, kSecureServer, AUTH_ASYNC, OK, 3, 1,
-      { TestRound(kConnect, kProxyChallenge, OK),
-        TestRound(kConnectProxyAuth, kProxyConnected, OK,
-                  &kGet, &kServerChallenge),
-        TestRound(kGetAuth, kSuccess, OK)}},
-    { kProxy, AUTH_SYNC, OK, kSecureServer, AUTH_ASYNC, kAuthErr, 3, 1,
-      { TestRound(kConnect, kProxyChallenge, OK),
-        TestRound(kConnectProxyAuth, kProxyConnected, OK,
-                  &kGet, &kServerChallenge),
-        TestRound(kGetAuth, kFailure, kAuthErr)}},
-    { kProxy, AUTH_ASYNC, OK, kSecureServer, AUTH_ASYNC, OK, 3, 1,
-      { TestRound(kConnect, kProxyChallenge, OK),
-        TestRound(kConnectProxyAuth, kProxyConnected, OK,
-                  &kGet, &kServerChallenge),
-        TestRound(kGetAuth, kSuccess, OK)}},
-    { kProxy, AUTH_ASYNC, OK, kSecureServer, AUTH_ASYNC, kAuthErr, 3, 1,
-      { TestRound(kConnect, kProxyChallenge, OK),
-        TestRound(kConnectProxyAuth, kProxyConnected, OK,
-                  &kGet, &kServerChallenge),
+      // Authenticating HTTPS server through an authenticating proxy.
+      {kProxy,
+       AUTH_SYNC,
+       OK,
+       kSecureServer,
+       AUTH_SYNC,
+       OK,
+       3,
+       1,
+       {TestRound(kConnect, kProxyChallenge, OK),
+        TestRound(kConnectProxyAuth, kProxyConnected, OK, &kGet,
+                  &kServerChallenge),
+        TestRound(kGetAuth, kSuccess, OK)}},
+      {kProxy,
+       AUTH_SYNC,
+       OK,
+       kSecureServer,
+       AUTH_SYNC,
+       kAuthErr,
+       3,
+       1,
+       {TestRound(kConnect, kProxyChallenge, OK),
+        TestRound(kConnectProxyAuth, kProxyConnected, OK, &kGet,
+                  &kServerChallenge),
+        TestRound(kGetAuth, kFailure, kAuthErr)}},
+      {kProxy,
+       AUTH_ASYNC,
+       OK,
+       kSecureServer,
+       AUTH_SYNC,
+       OK,
+       3,
+       1,
+       {TestRound(kConnect, kProxyChallenge, OK),
+        TestRound(kConnectProxyAuth, kProxyConnected, OK, &kGet,
+                  &kServerChallenge),
+        TestRound(kGetAuth, kSuccess, OK)}},
+      {kProxy,
+       AUTH_ASYNC,
+       OK,
+       kSecureServer,
+       AUTH_SYNC,
+       kAuthErr,
+       3,
+       1,
+       {TestRound(kConnect, kProxyChallenge, OK),
+        TestRound(kConnectProxyAuth, kProxyConnected, OK, &kGet,
+                  &kServerChallenge),
+        TestRound(kGetAuth, kFailure, kAuthErr)}},
+      {kProxy,
+       AUTH_SYNC,
+       OK,
+       kSecureServer,
+       AUTH_ASYNC,
+       OK,
+       3,
+       1,
+       {TestRound(kConnect, kProxyChallenge, OK),
+        TestRound(kConnectProxyAuth, kProxyConnected, OK, &kGet,
+                  &kServerChallenge),
+        TestRound(kGetAuth, kSuccess, OK)}},
+      {kProxy,
+       AUTH_SYNC,
+       OK,
+       kSecureServer,
+       AUTH_ASYNC,
+       kAuthErr,
+       3,
+       1,
+       {TestRound(kConnect, kProxyChallenge, OK),
+        TestRound(kConnectProxyAuth, kProxyConnected, OK, &kGet,
+                  &kServerChallenge),
+        TestRound(kGetAuth, kFailure, kAuthErr)}},
+      {kProxy,
+       AUTH_ASYNC,
+       OK,
+       kSecureServer,
+       AUTH_ASYNC,
+       OK,
+       3,
+       1,
+       {TestRound(kConnect, kProxyChallenge, OK),
+        TestRound(kConnectProxyAuth, kProxyConnected, OK, &kGet,
+                  &kServerChallenge),
+        TestRound(kGetAuth, kSuccess, OK)}},
+      {kProxy,
+       AUTH_ASYNC,
+       OK,
+       kSecureServer,
+       AUTH_ASYNC,
+       kAuthErr,
+       3,
+       1,
+       {TestRound(kConnect, kProxyChallenge, OK),
+        TestRound(kConnectProxyAuth, kProxyConnected, OK, &kGet,
+                  &kServerChallenge),
         TestRound(kGetAuth, kFailure, kAuthErr)}},
   };
 
   for (size_t i = 0; i < arraysize(test_configs); ++i) {
     SCOPED_TRACE(::testing::Message() << "Test config " << i);
     HttpAuthHandlerMock::Factory* auth_factory(
         new HttpAuthHandlerMock::Factory());
     session_deps_.http_auth_handler_factory.reset(auth_factory);
     const TestConfig& test_config = test_configs[i];
 
     // Set up authentication handlers as necessary.
     if (test_config.proxy_auth_timing != AUTH_NONE) {
       for (int n = 0; n < 2; n++) {
         scoped_ptr<HttpAuthHandlerMock> auth_handler(new HttpAuthHandlerMock());
         auth_handler->SetGenerateExpectation(
             test_config.proxy_auth_timing == AUTH_ASYNC,
             test_config.proxy_auth_rv);
         auth_factory->AddMockHandler(
             auth_handler.Pass(), n == 0
                                      ? HttpAuthHandlerCreateReason::CHALLENGE
                                      : HttpAuthHandlerCreateReason::PREEMPTIVE);
       }
     }
     if (test_config.server_auth_timing != AUTH_NONE) {
       scoped_ptr<HttpAuthHandlerMock> auth_handler(new HttpAuthHandlerMock());
+      auth_handler->SetInitExpectation(
+          test_config.server_auth_timing == AUTH_ASYNC, OK);
       auth_handler->SetGenerateExpectation(
           test_config.server_auth_timing == AUTH_ASYNC,
           test_config.server_auth_rv);
       auth_factory->AddMockHandler(auth_handler.Pass(),
                                    HttpAuthHandlerCreateReason::CHALLENGE);
     }
     if (test_config.proxy_url) {
       session_deps_.proxy_service =
           ProxyService::CreateFixed(test_config.proxy_url);
     } else {
@@ skipping 54 matching lines @@
       const TestRound& read_write_round = test_config.rounds[round];
       // Start or restart the transaction.
       TestCompletionCallback callback;
       int rv;
       if (round == 0) {
         rv = trans.Start(&request, callback.callback(), BoundNetLog());
       } else {
         rv = trans.RestartWithAuth(
             AuthCredentials(kFoo, kBar), callback.callback());
       }
-      if (rv == ERR_IO_PENDING)
-        rv = callback.WaitForResult();
+      rv = callback.GetResult(rv);
 
       // Compare results with expected data.
       EXPECT_EQ(read_write_round.expected_rv, rv);
       const HttpResponseInfo* response = trans.GetResponseInfo();
       if (read_write_round.expected_rv != OK) {
         EXPECT_EQ(round + 1, test_config.num_auth_rounds);
         continue;
       }
       if (round + 1 < test_config.num_auth_rounds) {
         EXPECT_FALSE(response->auth_challenge.get() == NULL);
@@ skipping 161 matching lines @@
   // release the socket back to the pool.
   scoped_refptr<IOBufferWithSize> io_buf(new IOBufferWithSize(50));
   rv = trans->Read(io_buf.get(), io_buf->size(), callback.callback());
   EXPECT_EQ(3, callback.GetResult(rv));
   rv = trans->Read(io_buf.get(), io_buf->size(), callback.callback());
   EXPECT_EQ(0, rv);
   // There are still 0 idle sockets, since the trans_compete transaction
   // will be handed it immediately after trans releases it to the group.
   EXPECT_EQ(0, transport_pool->IdleSocketCountInGroup(kSocketGroup));
 
-  // The competing request can now finish. Wait for the headers and then
-  // read the body.
+  // The competing request can now finish. Wait for the headers and then read
+  // the body. Explicitly ignore the request to create a preemptive auth handler
+  // for the competing request.
+  auth_factory->AddMockHandler(scoped_ptr<HttpAuthHandler>(),
+                               HttpAuthHandlerCreateReason::PREEMPTIVE);
   rv = callback_compete.WaitForResult();
   EXPECT_EQ(OK, rv);
   rv = trans_compete->Read(io_buf.get(), io_buf->size(), callback.callback());
   EXPECT_EQ(3, callback.GetResult(rv));
   rv = trans_compete->Read(io_buf.get(), io_buf->size(), callback.callback());
   EXPECT_EQ(0, rv);
 
   // Finally, the socket is released to the group.
   EXPECT_EQ(1, transport_pool->IdleSocketCountInGroup(kSocketGroup));
 }
@@ skipping 135 matching lines @@
   TestNetLog net_log;
   session_deps_.net_log = &net_log;
   GURL request_url;
   {
     HttpAuthHandlerMock::Factory* auth_factory =
         new HttpAuthHandlerMock::Factory();
     scoped_ptr<UrlRecordingHttpAuthHandlerMock> auth_handler(
         new UrlRecordingHttpAuthHandlerMock(&request_url));
     auth_factory->AddMockHandler(auth_handler.Pass(),
                                  HttpAuthHandlerCreateReason::CHALLENGE);
+
+    // Explicitly ignore the request to create a preemptive auth handler.
+    auth_factory->AddMockHandler(scoped_ptr<HttpAuthHandler>(),
+                                 HttpAuthHandlerCreateReason::PREEMPTIVE);
     session_deps_.http_auth_handler_factory.reset(auth_factory);
   }
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.example.org");
   request.load_flags = 0;
 
   // First round goes unauthenticated through the proxy.
   MockWrite data_writes_1[] = {
@@ skipping 3812 matching lines @@
   std::string response_data;
   EXPECT_EQ(OK, ReadTransaction(trans.get(), &response_data));
 
   EXPECT_EQ(CountWriteBytes(data_writes, arraysize(data_writes)),
             trans->GetTotalSentBytes());
   EXPECT_EQ(CountReadBytes(data_reads, arraysize(data_reads)),
             trans->GetTotalReceivedBytes());
 }
 
 }  // namespace net