Initial implementation of RequestPriority-based HTTP/2 dependencies.

net/http/http_proxy_client_socket_pool_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 "net/http/http_proxy_client_socket_pool.h"
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 23 matching lines @@
 
 enum HttpProxyType {
   HTTP,
   HTTPS,
   SPDY
 };
 
 struct HttpProxyClientSocketPoolTestParams {
   HttpProxyClientSocketPoolTestParams()
       : proxy_type(HTTP),
-        protocol(kProtoSPDY31) {}
+        protocol(kProtoSPDY31),
+        priority_to_dependency(false) {}
 
-  HttpProxyClientSocketPoolTestParams(
-      HttpProxyType proxy_type,
-      NextProto protocol)
+  HttpProxyClientSocketPoolTestParams(HttpProxyType proxy_type,
+                                      NextProto protocol,
+                                      bool priority_to_dependency)
       : proxy_type(proxy_type),
-        protocol(protocol) {}
+        protocol(protocol),
+        priority_to_dependency(priority_to_dependency) {}
 
   HttpProxyType proxy_type;
   NextProto protocol;
+  bool priority_to_dependency;
 };
 
 typedef ::testing::TestWithParam<HttpProxyType> TestWithHttpParam;
 
 const char kHttpProxyHost[] = "httpproxy.example.com";
 const char kHttpsProxyHost[] = "httpsproxy.example.com";
 
 class TestProxyDelegate : public ProxyDelegate {
  public:
   TestProxyDelegate()
@@ skipping 78 matching lines @@
   bool on_before_tunnel_request_called_;
   bool on_tunnel_request_completed_called_;
   bool on_tunnel_headers_received_called_;
   HostPortPair on_tunnel_request_completed_endpoint_;
   HostPortPair on_tunnel_request_completed_proxy_server_;
   HostPortPair on_tunnel_headers_received_origin_;
   HostPortPair on_tunnel_headers_received_proxy_server_;
   std::string on_tunnel_headers_received_status_line_;
 };
 
+}  // namespace
 
 class HttpProxyClientSocketPoolTest
     : public ::testing::TestWithParam<HttpProxyClientSocketPoolTestParams> {
  protected:
   HttpProxyClientSocketPoolTest()
       : session_deps_(GetParam().protocol),
         transport_socket_pool_(kMaxSockets,
                                kMaxSocketsPerGroup,
                                session_deps_.socket_factory.get()),
         ssl_socket_pool_(kMaxSockets,
                          kMaxSocketsPerGroup,
                          session_deps_.cert_verifier.get(),
                          NULL /* channel_id_store */,
                          NULL /* transport_security_state */,
                          NULL /* cert_transparency_verifier */,
                          NULL /* cert_policy_enforcer */,
                          std::string() /* ssl_session_cache_shard */,
                          session_deps_.socket_factory.get(),
                          &transport_socket_pool_,
                          NULL,
                          NULL,
                          session_deps_.ssl_config_service.get(),
                          BoundNetLog().net_log()),
         session_(CreateNetworkSession()),
-        spdy_util_(GetParam().protocol),
+        spdy_util_(GetParam().protocol, GetParam().priority_to_dependency),
         pool_(kMaxSockets,
               kMaxSocketsPerGroup,
               &transport_socket_pool_,
               &ssl_socket_pool_,
-              NULL) {}
+              NULL) {
+    SpdySession::SetPriorityDependencyDefaultForTesting(
+        GetParam().priority_to_dependency);
+  }
 
   virtual ~HttpProxyClientSocketPoolTest() {
+    SpdySession::SetPriorityDependencyDefaultForTesting(false);
   }
 
   void AddAuthToCache() {
     const base::string16 kFoo(base::ASCIIToUTF16("foo"));
     const base::string16 kBar(base::ASCIIToUTF16("bar"));
     GURL proxy_url(GetParam().proxy_type == HTTP ?
                    (std::string("http://") + kHttpProxyHost) :
                    (std::string("https://") + kHttpsProxyHost));
     session_->http_auth_cache()->Add(proxy_url,
                                      "MyRealm1",
@@ skipping 122 matching lines @@
 
 //-----------------------------------------------------------------------------
 // All tests are run with three different proxy types: HTTP, HTTPS (non-SPDY)
 // and SPDY.
 //
 // TODO(akalin): Use ::testing::Combine() when we are able to use
 // <tr1/tuple>.
 INSTANTIATE_TEST_CASE_P(
     HttpProxyClientSocketPoolTests,
     HttpProxyClientSocketPoolTest,
-    ::testing::Values(HttpProxyClientSocketPoolTestParams(HTTP, kProtoSPDY31),
-                      HttpProxyClientSocketPoolTestParams(HTTPS, kProtoSPDY31),
-                      HttpProxyClientSocketPoolTestParams(SPDY, kProtoSPDY31),
-                      HttpProxyClientSocketPoolTestParams(HTTP, kProtoHTTP2),
-                      HttpProxyClientSocketPoolTestParams(HTTPS, kProtoHTTP2),
-                      HttpProxyClientSocketPoolTestParams(SPDY, kProtoHTTP2)));
+    ::testing::Values(
+        HttpProxyClientSocketPoolTestParams(HTTP, kProtoSPDY31, false),
+        HttpProxyClientSocketPoolTestParams(HTTPS, kProtoSPDY31, false),
+        HttpProxyClientSocketPoolTestParams(SPDY, kProtoSPDY31, false),
+        HttpProxyClientSocketPoolTestParams(HTTP, kProtoHTTP2, false),
+        HttpProxyClientSocketPoolTestParams(HTTP, kProtoHTTP2, true),
+        HttpProxyClientSocketPoolTestParams(HTTPS, kProtoHTTP2, false),
+        HttpProxyClientSocketPoolTestParams(HTTPS, kProtoHTTP2, true),
+        HttpProxyClientSocketPoolTestParams(SPDY, kProtoHTTP2, false),
+        HttpProxyClientSocketPoolTestParams(SPDY, kProtoHTTP2, true)));
 
 TEST_P(HttpProxyClientSocketPoolTest, NoTunnel) {
   Initialize(NULL, 0, NULL, 0, NULL, 0, NULL, 0);
 
   scoped_ptr<TestProxyDelegate> proxy_delegate(new TestProxyDelegate());
   int rv = handle_.Init("a", CreateNoTunnelParams(proxy_delegate.get()), LOW,
                         CompletionCallback(), &pool_, BoundNetLog());
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(handle_.is_initialized());
   ASSERT_TRUE(handle_.socket());
@@ skipping 463 matching lines @@
 
     // Make sure Location header was included and correct.
     std::string location;
     EXPECT_TRUE(headers->IsRedirect(&location));
     EXPECT_EQ(location, redirectTarget);
   }
 }
 
 // It would be nice to also test the timeouts in HttpProxyClientSocketPool.
 
-}  // namespace
-
 }  // namespace net