[SPDY] Use WeakPtr<SpdySession> everywhere but SpdySessionPool

net/spdy/spdy_proxy_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/spdy/spdy_proxy_client_socket.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/address_list.h"
@@ skipping 90 matching lines @@
                                      "Basic realm=MyRealm1",
                                      AuthCredentials(kFoo, kBar),
                                      "/");
   }
 
   void Run(int steps) {
     data_->StopAfter(steps);
     data_->Run();
   }
 
+  void CloseSpdySession(net::Error error, const std::string& description) {
+    spdy_session_->CloseSessionOnError(error, description);
+  }
+
   SpdyTestUtil spdy_util_;
   scoped_ptr<SpdyProxyClientSocket> sock_;
   TestCompletionCallback read_callback_;
   TestCompletionCallback write_callback_;
   scoped_ptr<DeterministicSocketData> data_;
   CapturingBoundNetLog net_log_;
 
  private:
   scoped_refptr<HttpNetworkSession> session_;
   scoped_refptr<IOBuffer> read_buf_;
   SpdySessionDependencies session_deps_;
   MockConnect connect_data_;
-  scoped_refptr<SpdySession> spdy_session_;
+  base::WeakPtr<SpdySession> spdy_session_;
   BufferedSpdyFramer framer_;
 
   std::string user_agent_;
   GURL url_;
   HostPortPair proxy_host_port_;
   HostPortPair endpoint_host_port_pair_;
   ProxyServer proxy_;
   SpdySessionKey endpoint_spdy_session_key_;
 
   DISALLOW_COPY_AND_ASSIGN(SpdyProxyClientSocketTest);
 };
 
 INSTANTIATE_TEST_CASE_P(
     NextProto,
     SpdyProxyClientSocketTest,
     testing::Values(kProtoSPDY2, kProtoSPDY3, kProtoSPDY31, kProtoSPDY4a2));
 
 SpdyProxyClientSocketTest::SpdyProxyClientSocketTest()
     : spdy_util_(GetParam()),
       session_(NULL),
       read_buf_(NULL),
       session_deps_(GetParam()),
       connect_data_(SYNCHRONOUS, OK),
-      spdy_session_(NULL),
       framer_(spdy_util_.spdy_version(), false),
       user_agent_(kUserAgent),
       url_(kRequestUrl),
       proxy_host_port_(kProxyHost, kProxyPort),
       endpoint_host_port_pair_(kOriginHost, kOriginPort),
       proxy_(ProxyServer::SCHEME_HTTPS, proxy_host_port_),
       endpoint_spdy_session_key_(endpoint_host_port_pair_,
                                  proxy_,
                                  kPrivacyModeDisabled) {
   session_deps_.net_log = net_log_.bound().net_log();
@@ skipping 1030 matching lines @@
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   AssertConnectSucceeds();
 
   EXPECT_TRUE(sock_->IsConnected());
 
   scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1));
   EXPECT_EQ(ERR_IO_PENDING,
             sock_->Write(buf.get(), buf->size(), write_callback_.callback()));
 
-  Run(1);
+  CloseSpdySession(ERR_ABORTED, std::string());
 
   EXPECT_EQ(ERR_CONNECTION_CLOSED, write_callback_.WaitForResult());
 }
 
 // If the socket is Disconnected with a pending Write(), the callback
 // should not be called.
 TEST_P(SpdyProxyClientSocketTest, DisconnectWithWritePending) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
@@ skipping 51 matching lines @@
   EXPECT_FALSE(sock_->IsConnected());
   EXPECT_FALSE(read_callback_.have_result());
 }
 
 // If the socket is Reset when both a read and write are pending,
 // both should be called back.
 TEST_P(SpdyProxyClientSocketTest, RstWithReadAndWritePending) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
-    MockWrite(ASYNC, ERR_ABORTED, 2),
+    MockWrite(ASYNC, ERR_ABORTED, 3),
   };
 
   scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
   scoped_ptr<SpdyFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
   MockRead reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
-    CreateMockRead(*rst, 3, ASYNC),
+    CreateMockRead(*rst, 2, ASYNC),
+    MockRead(ASYNC, 0, 4)  // EOF
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   AssertConnectSucceeds();
 
   EXPECT_TRUE(sock_->IsConnected());
 
   scoped_refptr<IOBuffer> read_buf(new IOBuffer(kLen1));
   ASSERT_EQ(ERR_IO_PENDING,
@@ skipping 94 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(DeleteSockCallback);
 };
 
 // If the socket is Reset when both a read and write are pending, and the
 // read callback causes the socket to be deleted, the write callback should
 // not be called.
 TEST_P(SpdyProxyClientSocketTest, RstWithReadAndWritePendingDelete) {
   scoped_ptr<SpdyFrame> conn(ConstructConnectRequestFrame());
   MockWrite writes[] = {
     CreateMockWrite(*conn, 0, SYNCHRONOUS),
-    MockWrite(ASYNC, ERR_ABORTED, 2),
+    MockWrite(ASYNC, ERR_ABORTED, 3),
   };
 
   scoped_ptr<SpdyFrame> resp(ConstructConnectReplyFrame());
   scoped_ptr<SpdyFrame> rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
   MockRead reads[] = {
     CreateMockRead(*resp, 1, ASYNC),
-    CreateMockRead(*rst, 3, ASYNC),
+    CreateMockRead(*rst, 2, ASYNC),
+    MockRead(ASYNC, 0, 4),  // EOF
   };
 
   Initialize(reads, arraysize(reads), writes, arraysize(writes));
 
   AssertConnectSucceeds();
 
   EXPECT_TRUE(sock_->IsConnected());
 
   DeleteSockCallback read_callback(&sock_);
 
   scoped_refptr<IOBuffer> read_buf(new IOBuffer(kLen1));
   ASSERT_EQ(ERR_IO_PENDING,
             sock_->Read(read_buf.get(), kLen1, read_callback.callback()));
 
   scoped_refptr<IOBufferWithSize> write_buf(CreateBuffer(kMsg1, kLen1));
   EXPECT_EQ(
       ERR_IO_PENDING,
       sock_->Write(
           write_buf.get(), write_buf->size(), write_callback_.callback()));
 
-  Run(2);
+  Run(1);
 
   EXPECT_FALSE(sock_.get());
   EXPECT_TRUE(read_callback.have_result());
   EXPECT_FALSE(write_callback_.have_result());
 }
 
 }  // namespace net