Plumbing for TCP FastOpen for SSL sockets.

net/socket/websocket_transport_client_socket_pool_unittest.cc

 // Copyright 2014 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/socket/websocket_transport_client_socket_pool.h"
 
 #include <queue>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 33 matching lines @@
   base::RunLoop run_loop;
   base::Closure quit_closure(run_loop.QuitClosure());
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE, quit_closure, period);
   run_loop.Run();
 }
 
 class WebSocketTransportClientSocketPoolTest : public testing::Test {
  protected:
   WebSocketTransportClientSocketPoolTest()
-      : params_(new TransportSocketParams(HostPortPair("www.google.com", 80),
-                                          false,
-                                          false,
-                                          OnHostResolutionCallback())),
+      : params_(new TransportSocketParams(
+            HostPortPair("www.google.com", 80),
+            false,
+            false,
+            OnHostResolutionCallback(),
+            TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT)),
         histograms_(new ClientSocketPoolHistograms("TCPUnitTest")),
         host_resolver_(new MockHostResolver),
         client_socket_factory_(&net_log_),
         pool_(kMaxSockets,
               kMaxSocketsPerGroup,
               histograms_.get(),
               host_resolver_.get(),
               &client_socket_factory_,
               NULL) {}
 
   virtual ~WebSocketTransportClientSocketPoolTest() {
     ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
     EXPECT_TRUE(WebSocketEndpointLockManager::GetInstance()->IsEmpty());
   }
 
   int StartRequest(const std::string& group_name, RequestPriority priority) {
     scoped_refptr<TransportSocketParams> params(
-        new TransportSocketParams(HostPortPair("www.google.com", 80),
-                                  false,
-                                  false,
-                                  OnHostResolutionCallback()));
+        new TransportSocketParams(
+            HostPortPair("www.google.com", 80),
+            false,
+            false,
+            OnHostResolutionCallback(),
+            TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT));
     return test_base_.StartRequestUsingPool(
         &pool_, group_name, priority, params);
   }
 
   int GetOrderOfRequest(size_t index) {
     return test_base_.GetOrderOfRequest(index);
   }
 
   bool ReleaseOneConnection(ClientSocketPoolTest::KeepAlive keep_alive) {
     return test_base_.ReleaseOneConnection(keep_alive);
@@ skipping 52 matching lines @@
     EXPECT_EQ(priority, host_resolver_->last_request_priority());
   }
 }
 
 TEST_F(WebSocketTransportClientSocketPoolTest, InitHostResolutionFailure) {
   host_resolver_->rules()->AddSimulatedFailure("unresolvable.host.name");
   TestCompletionCallback callback;
   ClientSocketHandle handle;
   HostPortPair host_port_pair("unresolvable.host.name", 80);
   scoped_refptr<TransportSocketParams> dest(new TransportSocketParams(
-      host_port_pair, false, false, OnHostResolutionCallback()));
+      host_port_pair, false, false, OnHostResolutionCallback(),
+      TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT));
   EXPECT_EQ(ERR_IO_PENDING,
             handle.Init("a",
                         dest,
                         kDefaultPriority,
                         callback.callback(),
                         &pool_,
                         BoundNetLog()));
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, callback.WaitForResult());
 }
 
@@ skipping 229 matching lines @@
       // run through the MessageLoop once to get it completely released.
       handle_->socket()->Disconnect();
       handle_->Reset();
       {
         base::MessageLoop::ScopedNestableTaskAllower allow(
             base::MessageLoop::current());
         base::MessageLoop::current()->RunUntilIdle();
       }
       within_callback_ = true;
       scoped_refptr<TransportSocketParams> dest(
-          new TransportSocketParams(HostPortPair("www.google.com", 80),
-                                    false,
-                                    false,
-                                    OnHostResolutionCallback()));
+          new TransportSocketParams(
+              HostPortPair("www.google.com", 80),
+              false,
+              false,
+              OnHostResolutionCallback(),
+              TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT));
       int rv =
           handle_->Init("a", dest, LOWEST, callback(), pool_, BoundNetLog());
       EXPECT_EQ(OK, rv);
     }
   }
 
   ClientSocketHandle* const handle_;
   WebSocketTransportClientSocketPool* const pool_;
   bool within_callback_;
   CompletionCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(RequestSocketCallback);
 };
 
 TEST_F(WebSocketTransportClientSocketPoolTest, RequestTwice) {
   ClientSocketHandle handle;
   RequestSocketCallback callback(&handle, &pool_);
   scoped_refptr<TransportSocketParams> dest(
-      new TransportSocketParams(HostPortPair("www.google.com", 80),
-                                false,
-                                false,
-                                OnHostResolutionCallback()));
+      new TransportSocketParams(
+          HostPortPair("www.google.com", 80),
+          false,
+          false,
+          OnHostResolutionCallback(),
+          TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT));
   int rv = handle.Init(
       "a", dest, LOWEST, callback.callback(), &pool_, BoundNetLog());
   ASSERT_EQ(ERR_IO_PENDING, rv);
 
   // The callback is going to request "www.google.com". We want it to complete
   // synchronously this time.
   host_resolver_->set_synchronous_mode(true);
 
   EXPECT_EQ(OK, callback.WaitForResult());
 
@@ skipping 688 matching lines @@
   EXPECT_EQ(OK, request(1)->WaitForResult());
   // Third socket should still be waiting for endpoint.
   ASSERT_FALSE(request(2)->handle()->is_initialized());
   EXPECT_EQ(LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET,
             request(2)->handle()->GetLoadState());
 }
 
 }  // namespace
 
 }  // namespace net