[WebRTC] Copy HttpAuthCache from main request context into webrtc context

jingle/glue/proxy_resolving_client_socket_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 "jingle/glue/proxy_resolving_client_socket.h"
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/base/test_completion_callback.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/proxy/proxy_service.h"
 #include "net/socket/socket_test_util.h"
+#include "net/test/gtest_util.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 class MyTestURLRequestContext : public net::TestURLRequestContext {
  public:
   MyTestURLRequestContext() : TestURLRequestContext(true) {
     context_storage_.set_proxy_service(
@@ skipping 83 matching lines @@
   net::URLRequestContext* context =
       url_request_context_getter_->GetURLRequestContext();
   const net::ProxyRetryInfoMap& retry_info =
       context->proxy_service()->proxy_retry_info();
 
   EXPECT_EQ(1u, retry_info.size());
   net::ProxyRetryInfoMap::const_iterator iter = retry_info.find("bad:99");
   EXPECT_TRUE(iter != retry_info.end());
 }
 
+TEST_F(ProxyResolvingClientSocketTest, ReusesHTTPAuthCache_Lookup) {
+  scoped_refptr<net::TestURLRequestContextGetter> url_request_context_getter(
+      new net::TestURLRequestContextGetter(
+          base::ThreadTaskRunnerHandle::Get(),
+          std::unique_ptr<net::TestURLRequestContext>(
+              new MyTestURLRequestContext)));
+  net::MockClientSocketFactory socket_factory;
+  net::HostPortPair dest("example.com", 443);
+
+  // Initial connect without credentials. The server responds with a 407.
+  net::MockWrite kConnectWrites1[] = {
+      net::MockWrite("CONNECT example.com:443 HTTP/1.1\r\n"
+                     "Host: example.com:443\r\n"
+                     "Proxy-Connection: keep-alive\r\n"
+                     "\r\n")};
+  net::MockRead kConnectReads1[] = {
+      net::MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"
+                    "Proxy-Authenticate: Basic realm=\"test_realm\"\r\n"
+                    "\r\n")};
+
+  // Second connect attempt includes credentials.
+  net::MockWrite kConnectWrites2[] = {
+      net::MockWrite("CONNECT example.com:443 HTTP/1.1\r\n"
+                     "Host: example.com:443\r\n"
+                     "Proxy-Connection: keep-alive\r\n"
+                     "Proxy-Authorization: Basic dXNlcjpwYXNzd29yZA==\r\n"
+                     "\r\n")};
+  net::MockRead kConnectReads2[] = {
+      net::MockRead("HTTP/1.1 200 Success\r\n\r\n")};
+
+  net::StaticSocketDataProvider kSocketData1(
+      kConnectReads1, arraysize(kConnectReads1), kConnectWrites1,
+      arraysize(kConnectWrites1));
+  socket_factory.AddSocketDataProvider(&kSocketData1);
+
+  net::StaticSocketDataProvider kSocketData2(
+      kConnectReads2, arraysize(kConnectReads2), kConnectWrites2,
+      arraysize(kConnectWrites2));
+  socket_factory.AddSocketDataProvider(&kSocketData2);
+
+  net::HttpAuthCache* auth_cache =
+      url_request_context_getter->GetURLRequestContext()
+          ->http_transaction_factory()
+          ->GetSession()
+          ->http_auth_cache();
+
+  // We are adding these credentials at an empty path so that it won't be picked
+  // up by the preemptive authentication step and will only be picked up via
+  // origin + realm + scheme lookup.
+  auth_cache->Add(GURL("http://bad:99"), "test_realm",
+                  net::HttpAuth::AUTH_SCHEME_BASIC,
+                  "Basic realm=\"test_realm\"",
+                  net::AuthCredentials(base::ASCIIToUTF16("user"),
+                                       base::ASCIIToUTF16("password")),
+                  std::string());
+
+  ProxyResolvingClientSocket proxy_resolving_socket(
+      &socket_factory, url_request_context_getter, net::SSLConfig(), dest);
+
+  net::TestCompletionCallback callback;
+  int status = proxy_resolving_socket.Connect(callback.callback());
+  EXPECT_THAT(callback.GetResult(status), net::test::IsOk());
+}
+
+TEST_F(ProxyResolvingClientSocketTest, ReusesHTTPAuthCache_Preemptive) {
+  scoped_refptr<net::TestURLRequestContextGetter> url_request_context_getter(
+      new net::TestURLRequestContextGetter(
+          base::ThreadTaskRunnerHandle::Get(),
+          std::unique_ptr<net::TestURLRequestContext>(
+              new MyTestURLRequestContext)));
+  net::MockClientSocketFactory socket_factory;
+  net::HostPortPair dest("example.com", 443);
+
+  // Initial connect uses preemptive credentials. That is all.
+  net::MockWrite kConnectWrites[] = {
+      net::MockWrite("CONNECT example.com:443 HTTP/1.1\r\n"
+                     "Host: example.com:443\r\n"
+                     "Proxy-Connection: keep-alive\r\n"
+                     "Proxy-Authorization: Basic dXNlcjpwYXNzd29yZA==\r\n"
+                     "\r\n")};
+  net::MockRead kConnectReads[] = {
+      net::MockRead("HTTP/1.1 200 Success\r\n\r\n")};
+
+  net::StaticSocketDataProvider kSocketData(
+      kConnectReads, arraysize(kConnectReads), kConnectWrites,
+      arraysize(kConnectWrites));
+  socket_factory.AddSocketDataProvider(&kSocketData);
+
+  net::HttpAuthCache* auth_cache =
+      url_request_context_getter->GetURLRequestContext()
+          ->http_transaction_factory()
+          ->GetSession()
+          ->http_auth_cache();
+
+  auth_cache->Add(GURL("http://bad:99"), "test_realm",
+                  net::HttpAuth::AUTH_SCHEME_BASIC,
+                  "Basic realm=\"test_realm\"",
+                  net::AuthCredentials(base::ASCIIToUTF16("user"),
+                                       base::ASCIIToUTF16("password")),
+                  "/");
+
+  ProxyResolvingClientSocket proxy_resolving_socket(
+      &socket_factory, url_request_context_getter, net::SSLConfig(), dest);
+
+  net::TestCompletionCallback callback;
+  int status = proxy_resolving_socket.Connect(callback.callback());
+  EXPECT_THAT(callback.GetResult(status), net::test::IsOk());
+}
+
+TEST_F(ProxyResolvingClientSocketTest, ReusesHTTPAuthCache_NoCredentials) {
+  scoped_refptr<net::TestURLRequestContextGetter> url_request_context_getter(
+      new net::TestURLRequestContextGetter(
+          base::ThreadTaskRunnerHandle::Get(),
+          std::unique_ptr<net::TestURLRequestContext>(
+              new MyTestURLRequestContext)));
+  net::MockClientSocketFactory socket_factory;
+  net::HostPortPair dest("example.com", 443);
+
+  // Initial connect uses preemptive credentials. That is all.
+  net::MockWrite kConnectWrites[] = {
+      net::MockWrite("CONNECT example.com:443 HTTP/1.1\r\n"
+                     "Host: example.com:443\r\n"
+                     "Proxy-Connection: keep-alive\r\n"
+                     "\r\n")};
+  net::MockRead kConnectReads[] = {
+      net::MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"
+                    "Proxy-Authenticate: Basic realm=\"test_realm\"\r\n"
+                    "\r\n")};
+
+  net::StaticSocketDataProvider kSocketData(
+      kConnectReads, arraysize(kConnectReads), kConnectWrites,
+      arraysize(kConnectWrites));
+  socket_factory.AddSocketDataProvider(&kSocketData);
+
+  ProxyResolvingClientSocket proxy_resolving_socket(
+      &socket_factory, url_request_context_getter, net::SSLConfig(), dest);
+
+  net::TestCompletionCallback callback;
+  int status = proxy_resolving_socket.Connect(callback.callback());
+  EXPECT_THAT(callback.GetResult(status), net::ERR_PROXY_AUTH_REQUESTED);
+}
+
 // TODO(sanjeevr): Add more unit-tests.
 }  // namespace jingle_glue