Respect cookies set in a 401 responses when restarting the http transaction....

net/http/http_network_transaction_unittest.cc

 // Copyright (c) 2006-2008 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 <math.h>  // ceil
 
 #include "base/compiler_specific.h"
 #include "net/base/client_socket_factory.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/upload_data.h"
@@ skipping 1589 matching lines @@
     MockRead("WWW-Authenticate: NTLM\r\n"),
     MockRead("Connection: close\r\n"),
     MockRead("Content-Length: 42\r\n"),
     MockRead("Content-Type: text/html\r\n"),
     MockRead("Proxy-Support: Session-Based-Authentication\r\n\r\n"),
     // Missing content -- won't matter, as connection will be reset.
     MockRead(false, net::ERR_UNEXPECTED),
   };
 
   MockWrite data_writes2[] = {
-    // After automatically restarting with a null identity, this is the
+    // After restarting with a null identity, this is the
     // request we should be issuing -- the final header line contains a Type
     // 1 message.
     MockWrite("GET /kids/login.aspx HTTP/1.1\r\n"
               "Host: 172.22.68.17\r\n"
               "Connection: keep-alive\r\n"
               "Authorization: NTLM "
               "TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=\r\n\r\n"),
 
     // After calling trans->RestartWithAuth(), we should send a Type 3 message
     // (the credentials for the origin server).  The second request continues
@@ skipping 43 matching lines @@
   mock_sockets[2] = NULL;
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, &callback1);
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(net::OK, rv);
 
+  EXPECT_TRUE(trans->IsReadyToRestartForAuth());
+  TestCompletionCallback callback2;
+  rv = trans->RestartWithAuth(std::wstring(), std::wstring(), &callback2);
+  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  rv = callback2.WaitForResult();
+  EXPECT_EQ(net::OK, rv);
+  EXPECT_FALSE(trans->IsReadyToRestartForAuth());
+
   const net::HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
 
   // The password prompt info should have been set in response->auth_challenge.
   EXPECT_FALSE(response->auth_challenge.get() == NULL);
 
   // TODO(eroman): this should really include the effective port (80)
   EXPECT_EQ(L"172.22.68.17", response->auth_challenge->host);
   EXPECT_EQ(L"", response->auth_challenge->realm);
   EXPECT_EQ(L"ntlm", response->auth_challenge->scheme);
 
-  TestCompletionCallback callback2;
+  TestCompletionCallback callback3;
 
-  rv = trans->RestartWithAuth(L"testing-ntlm", L"testing-ntlm", &callback2);
+  rv = trans->RestartWithAuth(L"testing-ntlm", L"testing-ntlm", &callback3);
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
-  rv = callback2.WaitForResult();
+  rv = callback3.WaitForResult();
   EXPECT_EQ(net::OK, rv);
 
   response = trans->GetResponseInfo();
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(13, response->headers->GetContentLength());
 }
 
 // Enter a wrong password, and then the correct one.
 TEST_F(HttpNetworkTransactionTest, NTLMAuth2) {
   net::HttpAuthHandlerNTLM::ScopedProcSetter proc_setter(MockGenerateRandom2,
@@ skipping 21 matching lines @@
     MockRead("WWW-Authenticate: NTLM\r\n"),
     MockRead("Connection: close\r\n"),
     MockRead("Content-Length: 42\r\n"),
     MockRead("Content-Type: text/html\r\n"),
     MockRead("Proxy-Support: Session-Based-Authentication\r\n\r\n"),
     // Missing content -- won't matter, as connection will be reset.
     MockRead(false, net::ERR_UNEXPECTED),
   };
 
   MockWrite data_writes2[] = {
-    // After automatically restarting with a null identity, this is the
+    // After restarting with a null identity, this is the
     // request we should be issuing -- the final header line contains a Type
     // 1 message.
     MockWrite("GET /kids/login.aspx HTTP/1.1\r\n"
               "Host: 172.22.68.17\r\n"
               "Connection: keep-alive\r\n"
               "Authorization: NTLM "
               "TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=\r\n\r\n"),
 
     // After calling trans->RestartWithAuth(), we should send a Type 3 message
     // (the credentials for the origin server).  The second request continues
@@ skipping 30 matching lines @@
     MockRead("WWW-Authenticate: NTLM\r\n"),
     MockRead("Connection: close\r\n"),
     MockRead("Content-Length: 42\r\n"),
     MockRead("Content-Type: text/html\r\n"),
     MockRead("Proxy-Support: Session-Based-Authentication\r\n\r\n"),
     // Missing content -- won't matter, as connection will be reset.
     MockRead(false, net::ERR_UNEXPECTED),
   };
 
   MockWrite data_writes3[] = {
-    // After automatically restarting with a null identity, this is the
+    // After restarting with a null identity, this is the
     // request we should be issuing -- the final header line contains a Type
     // 1 message.
     MockWrite("GET /kids/login.aspx HTTP/1.1\r\n"
               "Host: 172.22.68.17\r\n"
               "Connection: keep-alive\r\n"
               "Authorization: NTLM "
               "TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=\r\n\r\n"),
 
     // After calling trans->RestartWithAuth(), we should send a Type 3 message
     // (the credentials for the origin server).  The second request continues
@@ skipping 47 matching lines @@
   mock_sockets[3] = NULL;
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, &callback1);
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(net::OK, rv);
 
+  EXPECT_TRUE(trans->IsReadyToRestartForAuth());
+  TestCompletionCallback callback2;
+  rv = trans->RestartWithAuth(std::wstring(), std::wstring(), &callback2);
+  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  rv = callback2.WaitForResult();
+  EXPECT_EQ(net::OK, rv);
+  EXPECT_FALSE(trans->IsReadyToRestartForAuth());
+
   const net::HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
 
   // The password prompt info should have been set in response->auth_challenge.
   EXPECT_FALSE(response->auth_challenge.get() == NULL);
 
   // TODO(eroman): this should really include the effective port (80)
   EXPECT_EQ(L"172.22.68.17", response->auth_challenge->host);
   EXPECT_EQ(L"", response->auth_challenge->realm);
   EXPECT_EQ(L"ntlm", response->auth_challenge->scheme);
 
-  TestCompletionCallback callback2;
+  TestCompletionCallback callback3;
 
   // Enter the wrong password.
-  rv = trans->RestartWithAuth(L"testing-ntlm", L"wrongpassword", &callback2);
+  rv = trans->RestartWithAuth(L"testing-ntlm", L"wrongpassword", &callback3);
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
-  rv = callback2.WaitForResult();
+  rv = callback3.WaitForResult();
   EXPECT_EQ(net::OK, rv);
 
+  EXPECT_TRUE(trans->IsReadyToRestartForAuth());
+  TestCompletionCallback callback4;
+  rv = trans->RestartWithAuth(std::wstring(), std::wstring(), &callback4);
+  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  rv = callback4.WaitForResult();
+  EXPECT_EQ(net::OK, rv);
+  EXPECT_FALSE(trans->IsReadyToRestartForAuth());
+
   response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
 
   // The password prompt info should have been set in response->auth_challenge.
   EXPECT_FALSE(response->auth_challenge.get() == NULL);
 
   // TODO(eroman): this should really include the effective port (80)
   EXPECT_EQ(L"172.22.68.17", response->auth_challenge->host);
   EXPECT_EQ(L"", response->auth_challenge->realm);
   EXPECT_EQ(L"ntlm", response->auth_challenge->scheme);
 
-  TestCompletionCallback callback3;
+  TestCompletionCallback callback5;
 
   // Now enter the right password.
-  rv = trans->RestartWithAuth(L"testing-ntlm", L"testing-ntlm", &callback3);
+  rv = trans->RestartWithAuth(L"testing-ntlm", L"testing-ntlm", &callback5);
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
-  rv = callback3.WaitForResult();
+  rv = callback5.WaitForResult();
   EXPECT_EQ(net::OK, rv);
 
   response = trans->GetResponseInfo();
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(13, response->headers->GetContentLength());
 }
 
 // Test reading a server response which has only headers, and no body.
 // After some maximum number of bytes is consumed, the transaction should
 // fail with ERR_RESPONSE_HEADERS_TOO_BIG.
@@ skipping 237 matching lines @@
   mock_sockets[2] = NULL;
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, &callback1);
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(net::OK, rv);
 
+  EXPECT_TRUE(trans->IsReadyToRestartForAuth());
+  TestCompletionCallback callback2;
+  rv = trans->RestartWithAuth(std::wstring(), std::wstring(), &callback2);
+  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  rv = callback2.WaitForResult();
+  EXPECT_EQ(net::OK, rv);
+  EXPECT_FALSE(trans->IsReadyToRestartForAuth());
+
   const net::HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
 
   // There is no challenge info, since the identity in URL worked.
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
 
   EXPECT_EQ(100, response->headers->GetContentLength());
 
   // Empty the current queue.
   MessageLoop::current()->RunAllPending();
@@ skipping 283 matching lines @@
     mock_sockets[2] = NULL;
 
     TestCompletionCallback callback1;
 
     int rv = trans->Start(&request, &callback1);
     EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
     rv = callback1.WaitForResult();
     EXPECT_EQ(net::OK, rv);
 
+    EXPECT_TRUE(trans->IsReadyToRestartForAuth());
+    TestCompletionCallback callback2;
+    rv = trans->RestartWithAuth(std::wstring(), std::wstring(), &callback2);
+    EXPECT_EQ(net::ERR_IO_PENDING, rv);
+    rv = callback2.WaitForResult();
+    EXPECT_EQ(net::OK, rv);
+    EXPECT_FALSE(trans->IsReadyToRestartForAuth());
+
     const net::HttpResponseInfo* response = trans->GetResponseInfo();
     EXPECT_FALSE(response == NULL);
     EXPECT_TRUE(response->auth_challenge.get() == NULL);
     EXPECT_EQ(100, response->headers->GetContentLength());
   }
 
   // ------------------------------------------------------------------------
 
   // Transaction 5: request a URL in MyRealm, but the server rejects the
   // cached identity. Should invalidate and re-prompt.
@@ skipping 67 matching lines @@
     mock_sockets[3] = NULL;
 
     TestCompletionCallback callback1;
 
     int rv = trans->Start(&request, &callback1);
     EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
     rv = callback1.WaitForResult();
     EXPECT_EQ(net::OK, rv);
 
+    EXPECT_TRUE(trans->IsReadyToRestartForAuth());
+    TestCompletionCallback callback2;
+    rv = trans->RestartWithAuth(std::wstring(), std::wstring(), &callback2);
+    EXPECT_EQ(net::ERR_IO_PENDING, rv);
+    rv = callback2.WaitForResult();
+    EXPECT_EQ(net::OK, rv);
+    EXPECT_FALSE(trans->IsReadyToRestartForAuth());
+
     const net::HttpResponseInfo* response = trans->GetResponseInfo();
     EXPECT_FALSE(response == NULL);
 
     // The password prompt info should have been set in
     // response->auth_challenge.
     EXPECT_FALSE(response->auth_challenge.get() == NULL);
 
     // TODO(eroman): this should really include the effective port (80)
     EXPECT_EQ(L"www.google.com", response->auth_challenge->host);
     EXPECT_EQ(L"MyRealm1", response->auth_challenge->realm);
     EXPECT_EQ(L"basic", response->auth_challenge->scheme);
 
-    TestCompletionCallback callback2;
+    TestCompletionCallback callback3;
 
-    rv = trans->RestartWithAuth(L"foo3", L"bar3", &callback2);
+    rv = trans->RestartWithAuth(L"foo3", L"bar3", &callback3);
     EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
-    rv = callback2.WaitForResult();
+    rv = callback3.WaitForResult();
     EXPECT_EQ(net::OK, rv);
 
     response = trans->GetResponseInfo();
     EXPECT_FALSE(response == NULL);
     EXPECT_TRUE(response->auth_challenge.get() == NULL);
     EXPECT_EQ(100, response->headers->GetContentLength());
   }
 }
 
 // Test the ResetStateForRestart() private method.
@@ skipping 49 matching lines @@
   EXPECT_EQ(NULL, trans->response_.auth_challenge.get());
   EXPECT_EQ(NULL, trans->response_.headers.get());
   EXPECT_EQ(false, trans->response_.was_cached);
   EXPECT_EQ(base::kInvalidPlatformFileValue,
             trans->response_.response_data_file);
   EXPECT_EQ(0, trans->response_.ssl_info.cert_status);
   EXPECT_FALSE(trans->response_.vary_data.is_valid());
 }
 
 }  // namespace net