Make SSLClientSocketFalseStartTest.NoSessionResumptionBeforeFinish not a no-op.

net/socket/ssl_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 "net/socket/ssl_client_socket.h"
 
 #include "base/callback_helpers.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/time/time.h"
@@ skipping 3160 matching lines @@
   // Start a handshake up to the server Finished message.
   TestCompletionCallback callback;
   FakeBlockingStreamSocket* raw_transport1;
   scoped_ptr<SSLClientSocket> sock1;
   ASSERT_NO_FATAL_FAILURE(CreateAndConnectUntilServerFinishedReceived(
       client_config, &callback, &raw_transport1, &sock1));
   // Although raw_transport1 has the server Finished blocked, the handshake
   // still completes.
   EXPECT_EQ(OK, callback.WaitForResult());
 
+  // Leave the server Finished blocked, but wait for it to arrive. This ensures
+  // the server has completed the handshake and added the session to its session
+  // cache.

[Ryan Sleevi, 2015/03/09 21:56:12]

Suggested reword:

// Continue to block the client (|sock1|) from processing the Finished
// message, but allow it to arrive on the socket. This ensures that
// from the server's point of view, it has completed the handshake and
// added the session to its session cache.
// The actual read on |sock1| will not complete until the Finished message
// is processed; however, pump the underlying transport so that it is
// read from the socket. This still has the potential to race, but is
// generally unlikely due to socket buffer sizes.

[davidben, 2015/03/09 22:01:13]

Done.

+  scoped_refptr<IOBuffer> buf(new IOBuffer(4096));
+  int rv = sock1->Read(buf.get(), 4096, callback.callback());
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+  raw_transport1->WaitForReadResult();
+
   // Drop the old socket. This is needed because the Python test server can't
   // service two sockets in parallel.
   sock1.reset();
 
   // Start a second connection.
   scoped_ptr<StreamSocket> transport2(
       new TCPClientSocket(addr(), &log_, NetLog::Source()));
   EXPECT_EQ(OK, callback.GetResult(transport2->Connect(callback.callback())));
   scoped_ptr<SSLClientSocket> sock2 = CreateSSLClientSocket(
       transport2.Pass(), test_server()->host_port_pair(), client_config);
@@ skipping 61 matching lines @@
   ssl_config.channel_id_enabled = true;
 
   int rv;
   ASSERT_TRUE(CreateAndConnectSSLClientSocket(ssl_config, &rv));
 
   EXPECT_EQ(ERR_UNEXPECTED, rv);
   EXPECT_FALSE(sock_->IsConnected());
 }
 
 }  // namespace net