Don't check for unflushed bytes in SSLClientSocketOpenSSL::IsConnectedAndIdle.

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 2805 matching lines @@
   EXPECT_TRUE(sock->WasEverUsed());
 
   // TODO(davidben): Read one byte to ensure the test server has responded and
   // then assert IsConnectedAndIdle is false. This currently doesn't work
   // because neither SSLClientSocketNSS nor SSLClientSocketOpenSSL check their
   // SSL implementation's internal buffers. Either call PR_Available and
   // SSL_pending, although the former isn't actually implemented or perhaps
   // attempt to read one byte extra.
 }
 
+// Tests that IsConnectedAndIdle treats a socket as idle even if a Write hasn't
+// been flushed completely out of SSLClientSocket's internal buffers. This is a
+// regression test for https://crbug.com/466147.
+TEST_F(SSLClientSocketTest, ReusableAfterWrite) {
+  SpawnedTestServer test_server(SpawnedTestServer::TYPE_HTTPS,
+                                SpawnedTestServer::kLocalhost,
+                                base::FilePath());
+  ASSERT_TRUE(test_server.Start());
+
+  AddressList addr;
+  ASSERT_TRUE(test_server.GetAddressList(&addr));
+
+  TestCompletionCallback callback;
+  scoped_ptr<StreamSocket> real_transport(
+      new TCPClientSocket(addr, NULL, NetLog::Source()));
+  scoped_ptr<FakeBlockingStreamSocket> transport(
+      new FakeBlockingStreamSocket(real_transport.Pass()));
+  FakeBlockingStreamSocket* raw_transport = transport.get();
+  ASSERT_EQ(OK, callback.GetResult(transport->Connect(callback.callback())));
+
+  scoped_ptr<SSLClientSocket> sock(CreateSSLClientSocket(
+      transport.Pass(), test_server.host_port_pair(), SSLConfig()));
+  ASSERT_EQ(OK, callback.GetResult(sock->Connect(callback.callback())));
+
+  // Block any application data from reaching the network.
+  raw_transport->BlockWrite();
+
+  // Write a partial HTTP request.
+  const char kRequestText[] = "GET / HTTP/1.0";
+  const size_t kRequestLen = arraysize(kRequestText) - 1;
+  scoped_refptr<IOBuffer> request_buffer(new IOBuffer(kRequestLen));
+  memcpy(request_buffer->data(), kRequestText, kRequestLen);
+
+  // Although transport writes are blocked, both SSLClientSocketOpenSSL and
+  // SSLClientSocketNSS complete the outer Write operation.
+  EXPECT_EQ(static_cast<int>(kRequestLen),
+            callback.GetResult(sock->Write(request_buffer.get(), kRequestLen,
+                                           callback.callback())));
+
+  // The Write operation is complete, so the socket should be treated as
+  // reusable, in case the server returns an HTTP response before completely
+  // consuming the request body. In this case, we assume the server will
+  // properly drain the request body before trying to read the next request.
+  EXPECT_TRUE(sock->IsConnectedAndIdle());
+}
+
 // Tests that basic session resumption works.
 TEST_F(SSLClientSocketTest, SessionResumption) {
   SpawnedTestServer::SSLOptions ssl_options;
   ASSERT_TRUE(StartTestServer(ssl_options));
 
   // First, perform a full handshake.
   SSLConfig ssl_config;
   TestCompletionCallback callback;
   scoped_ptr<StreamSocket> transport(
       new TCPClientSocket(addr(), &log_, NetLog::Source()));
@@ skipping 549 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