[SPDY] Use WeakPtr<SpdySession> everywhere but SpdySessionPool

net/spdy/spdy_test_util_common.cc

 // Copyright (c) 2013 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_test_util_common.h"
 
 #include <cstddef>
 
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 251 matching lines @@
   size_t frame_size = frame.size();
   if (framer.ProcessInput(frame.data(), frame_size) != frame_size) {
     return false;
   }
   *priority = priority_getter.priority();
   return true;
 }
 
 base::WeakPtr<SpdyStream> CreateStreamSynchronously(
     SpdyStreamType type,
-    const scoped_refptr<SpdySession>& session,
+    const base::WeakPtr<SpdySession>& session,
     const GURL& url,
     RequestPriority priority,
     const BoundNetLog& net_log) {
   SpdyStreamRequest stream_request;
   int rv = stream_request.StartRequest(type, session, url, priority, net_log,
                                        CompletionCallback());
   return
       (rv == OK) ? stream_request.ReleaseStream() : base::WeakPtr<SpdyStream>();
 }
 
@@ skipping 199 matching lines @@
 
 SpdyURLRequestContext::~SpdyURLRequestContext() {
 }
 
 bool HasSpdySession(SpdySessionPool* pool, const SpdySessionKey& key) {
   return pool->FindAvailableSession(key, BoundNetLog()) != NULL;
 }
 
 namespace {
 
-scoped_refptr<SpdySession> CreateSpdySessionHelper(
+base::WeakPtr<SpdySession> CreateSpdySessionHelper(
     const scoped_refptr<HttpNetworkSession>& http_session,
     const SpdySessionKey& key,
     const BoundNetLog& net_log,
     Error expected_status,
     bool is_secure) {
   EXPECT_FALSE(HasSpdySession(http_session->spdy_session_pool(), key));
 
   scoped_refptr<TransportSocketParams> transport_params(
       new TransportSocketParams(
           key.host_port_pair(), MEDIUM, false, false,
@@ skipping 33 matching lines @@
                           http_session->GetTransportSocketPool(
                               HttpNetworkSession::NORMAL_SOCKET_POOL),
                           net_log);
   }
 
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
 
   EXPECT_EQ(OK, rv);
 
-  scoped_refptr<SpdySession> spdy_session;
+  base::WeakPtr<SpdySession> spdy_session;
   EXPECT_EQ(
       expected_status,
       http_session->spdy_session_pool()->CreateAvailableSessionFromSocket(
           key, connection.Pass(), net_log, OK, &spdy_session,
           is_secure));
   EXPECT_EQ(expected_status == OK, spdy_session != NULL);
   EXPECT_EQ(expected_status == OK,
             HasSpdySession(http_session->spdy_session_pool(), key));
   return spdy_session;
 }
 
 }  // namespace
 
-scoped_refptr<SpdySession> CreateInsecureSpdySession(
+base::WeakPtr<SpdySession> CreateInsecureSpdySession(
     const scoped_refptr<HttpNetworkSession>& http_session,
     const SpdySessionKey& key,
     const BoundNetLog& net_log) {
   return CreateSpdySessionHelper(http_session, key, net_log,
                                  OK, false /* is_secure */);
 }
 
 void TryCreateInsecureSpdySessionExpectingFailure(
     const scoped_refptr<HttpNetworkSession>& http_session,
     const SpdySessionKey& key,
     Error expected_error,
     const BoundNetLog& net_log) {
   DCHECK_LT(expected_error, ERR_IO_PENDING);
   CreateSpdySessionHelper(http_session, key, net_log,
                           expected_error, false /* is_secure */);
 }
 
-scoped_refptr<SpdySession> CreateSecureSpdySession(
+base::WeakPtr<SpdySession> CreateSecureSpdySession(
     const scoped_refptr<HttpNetworkSession>& http_session,
     const SpdySessionKey& key,
     const BoundNetLog& net_log) {
   return CreateSpdySessionHelper(http_session, key, net_log,
                                  OK, true /* is_secure */);
 }
 
 namespace {
 
 // A ClientSocket used for CreateFakeSpdySession() below.
@@ skipping 44 matching lines @@
 
   virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE {
     ADD_FAILURE();
     return false;
   }
 
  private:
   int read_result_;
 };
 
-scoped_refptr<SpdySession> CreateFakeSpdySessionHelper(
+base::WeakPtr<SpdySession> CreateFakeSpdySessionHelper(
     SpdySessionPool* pool,
     const SpdySessionKey& key,
     Error expected_status) {
   EXPECT_NE(expected_status, ERR_IO_PENDING);
   EXPECT_FALSE(HasSpdySession(pool, key));
-  scoped_refptr<SpdySession> spdy_session;
+  base::WeakPtr<SpdySession> spdy_session;
   scoped_ptr<ClientSocketHandle> handle(new ClientSocketHandle());
   handle->set_socket(new FakeSpdySessionClientSocket(
       expected_status == OK ? ERR_IO_PENDING : expected_status));
   EXPECT_EQ(
       expected_status,
       pool->CreateAvailableSessionFromSocket(
           key, handle.Pass(), BoundNetLog(), OK, &spdy_session,
           true /* is_secure */));
   EXPECT_EQ(expected_status == OK, spdy_session != NULL);
   EXPECT_EQ(expected_status == OK, HasSpdySession(pool, key));
   return spdy_session;
 }
 
 }  // namespace
 
-scoped_refptr<SpdySession> CreateFakeSpdySession(SpdySessionPool* pool,
+base::WeakPtr<SpdySession> CreateFakeSpdySession(SpdySessionPool* pool,
                                                  const SpdySessionKey& key) {
   return CreateFakeSpdySessionHelper(pool, key, OK);
 }
 
 void TryCreateFakeSpdySessionExpectingFailure(SpdySessionPool* pool,
                                               const SpdySessionKey& key,
                                               Error expected_error) {
   DCHECK_LT(expected_error, ERR_IO_PENDING);
   CreateFakeSpdySessionHelper(pool, key, expected_error);
 }
@@ skipping 603 matching lines @@
   (*headers)[GetSchemeKey()] = scheme.c_str();
   (*headers)[GetVersionKey()] = "HTTP/1.1";
   if (content_length) {
     std::string length_str = base::Int64ToString(*content_length);
     (*headers)["content-length"] = length_str;
   }
   return headers.Pass();
 }
 
 }  // namespace net