[Merge-M54] [net] clang-format HttpNetworkTransactionTest.GenerateAuthToken test.

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 11215 matching lines @@
 // need to test all permutations of the backend server).
 //
 // The test proceeds by going over each of the configuration cases, and
 // potentially running up to three rounds in each of the tests. The TestConfig
 // specifies both the configuration for the test as well as the expectations
 // for the results.
 TEST_F(HttpNetworkTransactionTest, GenerateAuthToken) {
   static const char kServer[] = "http://www.example.com";
   static const char kSecureServer[] = "https://www.example.com";
   static const char kProxy[] = "myproxy:70";
-  const int kAuthErr = ERR_INVALID_AUTH_CREDENTIALS;
 
   enum AuthTiming {
     AUTH_NONE,
     AUTH_SYNC,
     AUTH_ASYNC,
   };
 
   const MockWrite kGet(
       "GET / HTTP/1.1\r\n"
       "Host: www.example.com\r\n"
@@ skipping 96 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,
+       ERR_INVALID_AUTH_CREDENTIALS,
+       2,
+       kNoSSL,
+       {TestRound(kGet, kServerChallenge, OK),
+        TestRound(kGetAuth, kFailure, ERR_INVALID_AUTH_CREDENTIALS)}},
+      {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,
+       ERR_INVALID_AUTH_CREDENTIALS,
+       2,
+       kNoSSL,
+       {TestRound(kGet, kServerChallenge, OK),
+        TestRound(kGetAuth, kFailure, ERR_INVALID_AUTH_CREDENTIALS)}},
+      // 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),
-        TestRound(kGetAuthThroughProxy, kFailure, kAuthErr)}},
-    { kProxy, AUTH_NONE, OK, kServer, AUTH_ASYNC, OK, 2, kNoSSL,
-      { TestRound(kGetProxy, kServerChallenge, OK),
+      {kProxy,
+       AUTH_NONE,
+       OK,
+       kServer,
+       AUTH_SYNC,
+       ERR_INVALID_AUTH_CREDENTIALS,
+       2,
+       kNoSSL,
+       {TestRound(kGetProxy, kServerChallenge, OK),
+        TestRound(kGetAuthThroughProxy, kFailure,
+                  ERR_INVALID_AUTH_CREDENTIALS)}},
+      {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),
-        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),
+      {kProxy,
+       AUTH_NONE,
+       OK,
+       kServer,
+       AUTH_ASYNC,
+       ERR_INVALID_AUTH_CREDENTIALS,
+       2,
+       kNoSSL,
+       {TestRound(kGetProxy, kServerChallenge, OK),
+        TestRound(kGetAuthThroughProxy, kFailure,
+                  ERR_INVALID_AUTH_CREDENTIALS)}},
+      // 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),
-        TestRound(kGetProxyAuth, kFailure, kAuthErr)}},
-    { kProxy, AUTH_ASYNC, OK, kServer, AUTH_NONE, OK, 2, kNoSSL,
-      { TestRound(kGetProxy, kProxyChallenge, OK),
+      {kProxy,
+       AUTH_SYNC,
+       ERR_INVALID_AUTH_CREDENTIALS,
+       kServer,
+       AUTH_NONE,
+       OK,
+       2,
+       kNoSSL,
+       {TestRound(kGetProxy, kProxyChallenge, OK),
+        TestRound(kGetProxyAuth, kFailure, ERR_INVALID_AUTH_CREDENTIALS)}},
+      {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),
-        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),
+      {kProxy,
+       AUTH_ASYNC,
+       ERR_INVALID_AUTH_CREDENTIALS,
+       kServer,
+       AUTH_NONE,
+       OK,
+       2,
+       kNoSSL,
+       {TestRound(kGetProxy, kProxyChallenge, OK),
+        TestRound(kGetProxyAuth, kFailure, ERR_INVALID_AUTH_CREDENTIALS)}},
+      // 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),
-        TestRound(kGetProxyAuth, kServerChallenge, OK),
-        TestRound(kGetAuthWithProxyAuth, kFailure, kAuthErr)}},
-    { kProxy, AUTH_ASYNC, OK, kServer, AUTH_SYNC, OK, 3, kNoSSL,
-      { TestRound(kGetProxy, kProxyChallenge, OK),
+      {kProxy,
+       AUTH_SYNC,
+       OK,
+       kServer,
+       AUTH_SYNC,
+       ERR_INVALID_AUTH_CREDENTIALS,
+       3,
+       kNoSSL,
+       {TestRound(kGetProxy, kProxyChallenge, OK),
+        TestRound(kGetProxyAuth, kServerChallenge, OK),
+        TestRound(kGetAuthWithProxyAuth, kFailure,
+                  ERR_INVALID_AUTH_CREDENTIALS)}},
+      {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),
-        TestRound(kGetProxyAuth, kServerChallenge, OK),
-        TestRound(kGetAuthWithProxyAuth, kFailure, kAuthErr)}},
-    { kProxy, AUTH_SYNC, OK, kServer, AUTH_ASYNC, OK, 3, kNoSSL,
-      { TestRound(kGetProxy, kProxyChallenge, OK),
+      {kProxy,
+       AUTH_ASYNC,
+       OK,
+       kServer,
+       AUTH_SYNC,
+       ERR_INVALID_AUTH_CREDENTIALS,
+       3,
+       kNoSSL,
+       {TestRound(kGetProxy, kProxyChallenge, OK),
+        TestRound(kGetProxyAuth, kServerChallenge, OK),
+        TestRound(kGetAuthWithProxyAuth, kFailure,
+                  ERR_INVALID_AUTH_CREDENTIALS)}},
+      {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),
-        TestRound(kGetProxyAuth, kServerChallenge, OK),
-        TestRound(kGetAuthWithProxyAuth, kFailure, kAuthErr)}},
-    { kProxy, AUTH_ASYNC, OK, kServer, AUTH_ASYNC, OK, 3, kNoSSL,
-      { TestRound(kGetProxy, kProxyChallenge, OK),
+      {kProxy,
+       AUTH_SYNC,
+       OK,
+       kServer,
+       AUTH_ASYNC,
+       ERR_INVALID_AUTH_CREDENTIALS,
+       3,
+       kNoSSL,
+       {TestRound(kGetProxy, kProxyChallenge, OK),
+        TestRound(kGetProxyAuth, kServerChallenge, OK),
+        TestRound(kGetAuthWithProxyAuth, kFailure,
+                  ERR_INVALID_AUTH_CREDENTIALS)}},
+      {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),
-        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),
+      {kProxy,
+       AUTH_ASYNC,
+       OK,
+       kServer,
+       AUTH_ASYNC,
+       ERR_INVALID_AUTH_CREDENTIALS,
+       3,
+       kNoSSL,
+       {TestRound(kGetProxy, kProxyChallenge, OK),
+        TestRound(kGetProxyAuth, kServerChallenge, OK),
+        TestRound(kGetAuthWithProxyAuth, kFailure,
+                  ERR_INVALID_AUTH_CREDENTIALS)}},
+      // 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,
+       ERR_INVALID_AUTH_CREDENTIALS,
+       2,
+       0,
+       {TestRound(kGet, kServerChallenge, OK),
+        TestRound(kGetAuth, kFailure, ERR_INVALID_AUTH_CREDENTIALS)}},
+      {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,
+       ERR_INVALID_AUTH_CREDENTIALS,
+       2,
+       0,
+       {TestRound(kGet, kServerChallenge, OK),
+        TestRound(kGetAuth, kFailure, ERR_INVALID_AUTH_CREDENTIALS)}},
+      // 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,
+       ERR_INVALID_AUTH_CREDENTIALS,
+       2,
+       0,
+       {TestRound(kConnect, kProxyConnected, OK, &kGet, &kServerChallenge),
+        TestRound(kGetAuth, kFailure, ERR_INVALID_AUTH_CREDENTIALS)}},
+      {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,
+       ERR_INVALID_AUTH_CREDENTIALS,
+       2,
+       0,
+       {TestRound(kConnect, kProxyConnected, OK, &kGet, &kServerChallenge),
+        TestRound(kGetAuth, kFailure, ERR_INVALID_AUTH_CREDENTIALS)}},
+      // 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),
-        TestRound(kConnectProxyAuth, kFailure, kAuthErr)}},
-    { kProxy, AUTH_ASYNC, OK, kSecureServer, AUTH_NONE, OK, 2, 1,
-      { TestRound(kConnect, kProxyChallenge, OK),
+      {kProxy,
+       AUTH_SYNC,
+       ERR_INVALID_AUTH_CREDENTIALS,
+       kSecureServer,
+       AUTH_NONE,
+       OK,
+       2,
+       kNoSSL,
+       {TestRound(kConnect, kProxyChallenge, OK),
+        TestRound(kConnectProxyAuth, kFailure, ERR_INVALID_AUTH_CREDENTIALS)}},
+      {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),
-        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),
-        TestRound(kGetAuth, kFailure, kAuthErr)}},
+      {kProxy,
+       AUTH_ASYNC,
+       ERR_INVALID_AUTH_CREDENTIALS,
+       kSecureServer,
+       AUTH_NONE,
+       OK,
+       2,
+       kNoSSL,
+       {TestRound(kConnect, kProxyChallenge, OK),
+        TestRound(kConnectProxyAuth, kFailure, ERR_INVALID_AUTH_CREDENTIALS)}},
+      // 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,
+       ERR_INVALID_AUTH_CREDENTIALS,
+       3,
+       1,
+       {TestRound(kConnect, kProxyChallenge, OK),
+        TestRound(kConnectProxyAuth, kProxyConnected, OK, &kGet,
+                  &kServerChallenge),
+        TestRound(kGetAuth, kFailure, ERR_INVALID_AUTH_CREDENTIALS)}},
+      {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,
+       ERR_INVALID_AUTH_CREDENTIALS,
+       3,
+       1,
+       {TestRound(kConnect, kProxyChallenge, OK),
+        TestRound(kConnectProxyAuth, kProxyConnected, OK, &kGet,
+                  &kServerChallenge),
+        TestRound(kGetAuth, kFailure, ERR_INVALID_AUTH_CREDENTIALS)}},
+      {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,
+       ERR_INVALID_AUTH_CREDENTIALS,
+       3,
+       1,
+       {TestRound(kConnect, kProxyChallenge, OK),
+        TestRound(kConnectProxyAuth, kProxyConnected, OK, &kGet,
+                  &kServerChallenge),
+        TestRound(kGetAuth, kFailure, ERR_INVALID_AUTH_CREDENTIALS)}},
+      {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,
+       ERR_INVALID_AUTH_CREDENTIALS,
+       3,
+       1,
+       {TestRound(kConnect, kProxyChallenge, OK),
+        TestRound(kConnectProxyAuth, kProxyConnected, OK, &kGet,
+                  &kServerChallenge),
+        TestRound(kGetAuth, kFailure, ERR_INVALID_AUTH_CREDENTIALS)}},
   };
 
   for (size_t i = 0; i < arraysize(test_configs); ++i) {
     HttpAuthHandlerMock::Factory* auth_factory(
         new HttpAuthHandlerMock::Factory());
     session_deps_.http_auth_handler_factory.reset(auth_factory);
     SSLInfo empty_ssl_info;
     const TestConfig& test_config = test_configs[i];
 
     // Set up authentication handlers as necessary.
@@ skipping 3994 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(trans.GetResponseInfo()->was_fetched_via_spdy);
   HttpRequestHeaders headers;
   ASSERT_TRUE(trans.GetFullRequestHeaders(&headers));
   EXPECT_TRUE(headers.HasHeader(HttpRequestHeaders::kTokenBinding));
 }
 #endif  // !defined(OS_IOS)
 
 }  // namespace net