Fix crash bug in SpdyProxyClientSocket.GetPeerAddress where

net/spdy/spdy_proxy_client_socket_unittest.cc

 // Copyright (c) 2011 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/spdy/spdy_proxy_client_socket.h"
 
 #include "base/utf_string_conversions.h"
 #include "net/base/address_list.h"
 #include "net/base/net_log.h"
 #include "net/base/net_log_unittest.h"
@@ skipping 131 matching lines @@
       endpoint_host_port_pair_(kOriginHost, kOriginPort),
       proxy_(ProxyServer::SCHEME_HTTPS, proxy_host_port_),
       endpoint_host_port_proxy_pair_(endpoint_host_port_pair_, proxy_),
       transport_params_(new TransportSocketParams(proxy_host_port_,
                                             LOWEST,
                                             false,
                                             false)) {
 }
 
 void SpdyProxyClientSocketTest::TearDown() {
+  sock_.reset(NULL);
   if (session_ != NULL)
     session_->spdy_session_pool()->CloseAllSessions();
 
   spdy::SpdyFramer::set_enable_compression_default(true);
   // Empty the current queue.
   MessageLoop::current()->RunAllPending();
   PlatformTest::TearDown();
 }
 
 void SpdyProxyClientSocketTest::Initialize(MockRead* reads,
@@ skipping 443 matching lines @@
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   net::AddressList addr;
   EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, sock_->GetPeerAddress(&addr));
 
   AssertConnectSucceeds();
   EXPECT_TRUE(sock_->IsConnected());
   EXPECT_EQ(OK, sock_->GetPeerAddress(&addr));
 
+  Run(1);
+  EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, sock_->GetPeerAddress(&addr));

[wtc, 2011/12/02 23:16:40]

Should we also do
  EXPECT_FALSE(sock_->IsConnected());
?

[Ryan Hamilton, 2011/12/02 23:59:17]

Done.

+
   sock_->Disconnect();
+
   EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, sock_->GetPeerAddress(&addr));
 }
 
 // ----------- Write
 
 TEST_F(SpdyProxyClientSocketTest, WriteSendsDataInDataFrame) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
   scoped_ptr<spdy::SpdyFrame> msg2(ConstructBodyFrame(kMsg2, kLen2));
   MockWrite writes[] = {
@@ skipping 389 matching lines @@
     CreateMockRead(*resp, 1, true),
     MockRead(true, 0, 2),  // EOF
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   AssertConnectSucceeds();
 
   Run(1);
 
+  ASSERT_FALSE(sock_->IsConnected());
   ASSERT_EQ(0, sock_->Read(NULL, 1, NULL));
-  ASSERT_EQ(ERR_CONNECTION_CLOSED, sock_->Read(NULL, 1, NULL));
-  ASSERT_EQ(ERR_CONNECTION_CLOSED, sock_->Read(NULL, 1, NULL));
+
+  ASSERT_EQ(ERR_SOCKET_NOT_CONNECTED, sock_->Read(NULL, 1, NULL));
+  ASSERT_EQ(ERR_SOCKET_NOT_CONNECTED, sock_->Read(NULL, 1, NULL));
   ASSERT_FALSE(sock_->IsConnectedAndIdle());
 }
 
 // Read pending when socket is closed should return 0
 TEST_F(SpdyProxyClientSocketTest, PendingReadOnCloseReturnsZero) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, false),
   };
 
@@ skipping 51 matching lines @@
     CreateMockRead(*msg1, 2, true),
     MockRead(true, 0, 3),  // EOF
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   AssertConnectSucceeds();
 
   Run(2);
 
-  AssertSyncReadEquals(kMsg1, kLen1);
+  scoped_refptr<IOBuffer> buf(new IOBuffer(kLen1));
+  ASSERT_EQ(kLen1, sock_->Read(buf, kLen1, NULL));
+  ASSERT_EQ(std::string(kMsg1, kLen1), std::string(buf->data(), kLen1));
+
   ASSERT_EQ(0, sock_->Read(NULL, 1, NULL));
-  ASSERT_EQ(ERR_CONNECTION_CLOSED, sock_->Read(NULL, 1, NULL));
+  ASSERT_EQ(ERR_SOCKET_NOT_CONNECTED, sock_->Read(NULL, 1, NULL));
   // Verify that read *still* returns ERR_CONNECTION_CLOSED
-  ASSERT_EQ(ERR_CONNECTION_CLOSED, sock_->Read(NULL, 1, NULL));
+  ASSERT_EQ(ERR_SOCKET_NOT_CONNECTED, sock_->Read(NULL, 1, NULL));
 }
 
 // Calling Write() on a closed socket is an error
 TEST_F(SpdyProxyClientSocketTest, WriteOnClosedStream) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, false),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
   scoped_ptr<spdy::SpdyFrame> msg1(ConstructBodyFrame(kMsg1, kLen1));
   MockRead reads[] = {
     CreateMockRead(*resp, 1, true),
     MockRead(true, 0, 2),  // EOF
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   AssertConnectSucceeds();
 
   Run(1);  // Read EOF which will close the stream
   scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1));
-  EXPECT_EQ(ERR_CONNECTION_CLOSED, sock_->Write(buf, buf->size(), NULL));
+  EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, sock_->Write(buf, buf->size(), NULL));
 }
 
 // Calling Write() on a disconnected socket is an error
 TEST_F(SpdyProxyClientSocketTest, WriteOnDisconnectedSocket) {
   scoped_ptr<spdy::SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, false),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructConnectReplyFrame());
@@ skipping 190 matching lines @@
                                          &write_callback_));
 
   Run(2);
 
   EXPECT_FALSE(sock_.get());
   EXPECT_TRUE(read_callback.have_result());
   EXPECT_FALSE(write_callback_.have_result());
 }
 
 }  // namespace net