Make sure the key into the spdy session pool identifies the actual proxy used...

net/spdy/spdy_network_transaction_unittest.cc

 // Copyright (c) 2010 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 <string>
 #include <vector>
 
 #include "net/base/net_log_unittest.h"
 #include "net/http/http_stream_handle.h"
 #include "net/http/http_transaction_unittest.h"
@@ skipping 3842 matching lines @@
 
   // Verify that we consumed all test data.
   helper.VerifyDataConsumed();
 }
 
 // Test to make sure we can correctly connect through a proxy.
 TEST_P(SpdyNetworkTransactionTest, ProxyConnect) {
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
   helper.session_deps().reset(new SpdySessionDependencies(
-      net::SpdyCreateFixedProxyService("myproxy:70")));
+      ProxyService::CreateFixedFromPacResult("PROXY myproxy:70")));
   helper.SetSession(SpdySessionDependencies::SpdyCreateSession(
       helper.session_deps().get()));
   helper.RunPreTestSetup();
   HttpNetworkTransaction* trans = helper.trans();
 
   const char kConnect443[] = {"CONNECT www.google.com:443 HTTP/1.1\r\n"
                            "Host: www.google.com\r\n"
                            "Proxy-Connection: keep-alive\r\n\r\n"};
   const char kConnect80[] = {"CONNECT www.google.com:80 HTTP/1.1\r\n"
                            "Host: www.google.com\r\n"
@@ skipping 76 matching lines @@
 }
 
 // Test to make sure we can correctly connect through a proxy to www.google.com,
 // if there already exists a direct spdy connection to www.google.com. See
 // http://crbug.com/49874
 TEST_P(SpdyNetworkTransactionTest, DirectConnectProxyReconnect) {
   // When setting up the first transaction, we store the SpdySessionPool so that
   // we can use the same pool in the second transaction.
   NormalSpdyTransactionHelper helper(CreateGetRequest(),
                                      BoundNetLog(), GetParam());
+
+  // Use a proxy service which returns a proxy fallback list from DIRECT to
+  // myproxy:70. For this test there will be no fallback, so it is equivalent
+  // to simply DIRECT. The reason for appending the second proxy is to verify
+  // that the session pool key used does is just "DIRECT".
+  helper.session_deps().reset(new SpdySessionDependencies(
+      ProxyService::CreateFixedFromPacResult("DIRECT; PROXY myproxy:70")));
+  helper.SetSession(SpdySessionDependencies::SpdyCreateSession(
+      helper.session_deps().get()));
+
   scoped_refptr<SpdySessionPool> spdy_session_pool =
       helper.session_deps()->spdy_session_pool;
   helper.RunPreTestSetup();
 
   // Construct and send a simple GET request.
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite writes[] = {
     CreateMockWrite(*req, 1),
   };
 
@@ skipping 23 matching lines @@
   EXPECT_TRUE(response->headers != NULL);
   EXPECT_TRUE(response->was_fetched_via_spdy);
   out.rv = ReadTransaction(trans, &out.response_data);
   EXPECT_EQ(OK, out.rv);
   out.status_line = response->headers->GetStatusLine();
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 
   // Check that the SpdySession is still in the SpdySessionPool.
   HostPortPair host_port_pair("www.google.com", helper.port());
-  HostPortProxyPair pair(host_port_pair, "DIRECT");
-  EXPECT_TRUE(spdy_session_pool->HasSession(pair));
-  HostPortProxyPair nonexistent_pair(host_port_pair, "PROXY www.foo.com");
-  EXPECT_FALSE(spdy_session_pool->HasSession(nonexistent_pair));
+  HostPortProxyPair session_pool_key_direct(host_port_pair, "DIRECT");
+  EXPECT_TRUE(spdy_session_pool->HasSession(session_pool_key_direct));
+  HostPortProxyPair session_pool_key_proxy(host_port_pair, "PROXY www.foo.com");
+  EXPECT_FALSE(spdy_session_pool->HasSession(session_pool_key_proxy));
 
   // Set up data for the proxy connection.
   const char kConnect443[] = {"CONNECT www.google.com:443 HTTP/1.1\r\n"
                            "Host: www.google.com\r\n"
                            "Proxy-Connection: keep-alive\r\n\r\n"};
   const char kConnect80[] = {"CONNECT www.google.com:80 HTTP/1.1\r\n"
                            "Host: www.google.com\r\n"
                            "Proxy-Connection: keep-alive\r\n\r\n"};
   const char kHTTP200[] = {"HTTP/1.1 200 OK\r\n\r\n"};
   scoped_ptr<spdy::SpdyFrame> req2(ConstructSpdyGet(
@@ skipping 55 matching lines @@
     default:
       NOTREACHED();
   }
 
   // Create another request to www.google.com, but this time through a proxy.
   HttpRequestInfo request_proxy;
   request_proxy.method = "GET";
   request_proxy.url = GURL("http://www.google.com/foo.dat");
   request_proxy.load_flags = 0;
   scoped_ptr<SpdySessionDependencies> ssd_proxy(
-      new SpdySessionDependencies(net::SpdyCreateFixedProxyService(
-          "myproxy:70")));
+      new SpdySessionDependencies(
+          ProxyService::CreateFixedFromPacResult("PROXY myproxy:70")));
   // Ensure that this transaction uses the same SpdySessionPool.
   ssd_proxy->spdy_session_pool = spdy_session_pool;
   scoped_refptr<HttpNetworkSession> session_proxy =
       SpdySessionDependencies::SpdyCreateSession(ssd_proxy.get());
   NormalSpdyTransactionHelper helper_proxy(request_proxy,
                                            BoundNetLog(), GetParam());
   helper_proxy.session_deps().swap(ssd_proxy);
   helper_proxy.SetSession(session_proxy);
   helper_proxy.RunPreTestSetup();
   helper_proxy.AddData(data_proxy.get());
@@ skipping 94 matching lines @@
       rv = ReadTransaction(trans.get(), &response_data);
       EXPECT_EQ(OK, rv);
       EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
       EXPECT_EQ("hello!", response_data);
     }
 
     helper.VerifyDataConsumed();
   }
 }
 }  // namespace net