[SPDY] Use WeakPtr<SpdySession> everywhere but SpdySessionPool

net/spdy/spdy_http_stream_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_http_stream.h"
 
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
@@ skipping 103 matching lines @@
     ServerBoundCertService* server_bound_cert_service,
     const std::string& cert,
     const std::string& proof);
 
   SpdyTestUtil spdy_util_;
   CapturingNetLog net_log_;
   SpdySessionDependencies session_deps_;
   scoped_ptr<OrderedSocketData> data_;
   scoped_ptr<DeterministicSocketData> deterministic_data_;
   scoped_refptr<HttpNetworkSession> http_session_;
-  scoped_refptr<SpdySession> session_;
+  base::WeakPtr<SpdySession> session_;
 
  private:
   MockECSignatureCreatorFactory ec_signature_creator_factory_;
 };
 
 INSTANTIATE_TEST_CASE_P(
     NextProto,
     SpdyHttpStreamTest,
     testing::Values(kProtoSPDY2, kProtoSPDY3, kProtoSPDY31, kProtoSPDY4a2));
 
 // SpdyHttpStream::GetUploadProgress() should still work even before the
 // stream is initialized.
 TEST_P(SpdyHttpStreamTest, GetUploadProgressBeforeInitialization) {
   MockRead reads[] = {
     MockRead(ASYNC, 0, 0)  // EOF
   };
 
   HostPortPair host_port_pair("www.google.com", 80);
   SpdySessionKey key(host_port_pair, ProxyServer::Direct(),
                      kPrivacyModeDisabled);
   InitSession(reads, arraysize(reads), NULL, 0, key);
 
-  SpdyHttpStream stream(session_.get(), false);
+  SpdyHttpStream stream(session_, false);
   UploadProgress progress = stream.GetUploadProgress();
   EXPECT_EQ(0u, progress.size());
   EXPECT_EQ(0u, progress.position());
 }
 
 TEST_P(SpdyHttpStreamTest, SendRequest) {
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
   MockWrite writes[] = {
     CreateMockWrite(*req.get(), 1),
   };
   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   MockRead reads[] = {
     CreateMockRead(*resp, 2),
     MockRead(SYNCHRONOUS, 0, 3)  // EOF
   };
 
   HostPortPair host_port_pair("www.google.com", 80);
   SpdySessionKey key(host_port_pair, ProxyServer::Direct(),
                      kPrivacyModeDisabled);
   InitSession(reads, arraysize(reads), writes, arraysize(writes), key);
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   TestCompletionCallback callback;
   HttpResponseInfo response;
   HttpRequestHeaders headers;
   BoundNetLog net_log;
-  scoped_ptr<SpdyHttpStream> http_stream(
-      new SpdyHttpStream(session_.get(), true));
+  scoped_ptr<SpdyHttpStream> http_stream(new SpdyHttpStream(session_, true));
   // Make sure getting load timing information the stream early does not crash.
   LoadTimingInfo load_timing_info;
   EXPECT_FALSE(http_stream->GetLoadTimingInfo(&load_timing_info));
 
   ASSERT_EQ(
       OK,
       http_stream->InitializeStream(&request, DEFAULT_PRIORITY,
                                     net_log, CompletionCallback()));
   EXPECT_FALSE(http_stream->GetLoadTimingInfo(&load_timing_info));
 
@@ skipping 55 matching lines @@
   InitSessionDeterministic(reads, arraysize(reads),
                            writes, arraysize(writes),
                            key);
 
   HttpRequestInfo request1;
   request1.method = "GET";
   request1.url = GURL("http://www.google.com/");
   TestCompletionCallback callback1;
   HttpResponseInfo response1;
   HttpRequestHeaders headers1;
-  scoped_ptr<SpdyHttpStream> http_stream1(
-      new SpdyHttpStream(session_.get(), true));
+  scoped_ptr<SpdyHttpStream> http_stream1(new SpdyHttpStream(session_, true));
 
   HttpRequestInfo request2;
   request2.method = "GET";
   request2.url = GURL("http://www.google.com/");
   TestCompletionCallback callback2;
   HttpResponseInfo response2;
   HttpRequestHeaders headers2;
-  scoped_ptr<SpdyHttpStream> http_stream2(
-      new SpdyHttpStream(session_.get(), true));
+  scoped_ptr<SpdyHttpStream> http_stream2(new SpdyHttpStream(session_, true));
 
   // First write.
   ASSERT_EQ(OK,
             http_stream1->InitializeStream(&request1, DEFAULT_PRIORITY,
                                            BoundNetLog(),
                                            CompletionCallback()));
   EXPECT_EQ(ERR_IO_PENDING, http_stream1->SendRequest(headers1, &response1,
                                                       callback1.callback()));
   EXPECT_TRUE(HasSpdySession(http_session_->spdy_session_pool(), key));
 
@@ skipping 72 matching lines @@
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
   request.upload_data_stream = &upload_stream;
 
   ASSERT_EQ(OK, upload_stream.Init(CompletionCallback()));
 
   TestCompletionCallback callback;
   HttpResponseInfo response;
   HttpRequestHeaders headers;
   BoundNetLog net_log;
-  SpdyHttpStream http_stream(session_.get(), true);
+  SpdyHttpStream http_stream(session_, true);
   ASSERT_EQ(
       OK,
       http_stream.InitializeStream(&request, DEFAULT_PRIORITY,
                                    net_log, CompletionCallback()));
 
   EXPECT_EQ(ERR_IO_PENDING, http_stream.SendRequest(
       headers, &response, callback.callback()));
   EXPECT_TRUE(HasSpdySession(http_session_->spdy_session_pool(), key));
 
   // This results in writing the post body and reading the response headers.
@@ skipping 48 matching lines @@
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
   request.upload_data_stream = &upload_stream;
 
   ASSERT_EQ(OK, upload_stream.Init(CompletionCallback()));
   upload_stream.AppendChunk(kUploadData, kUploadDataSize, false);
 
   BoundNetLog net_log;
-  scoped_ptr<SpdyHttpStream> http_stream(
-      new SpdyHttpStream(session_.get(), true));
+  scoped_ptr<SpdyHttpStream> http_stream(new SpdyHttpStream(session_, true));
   ASSERT_EQ(OK, http_stream->InitializeStream(&request, DEFAULT_PRIORITY,
                                               net_log, CompletionCallback()));
 
   TestCompletionCallback callback;
   HttpRequestHeaders headers;
   HttpResponseInfo response;
   // This will attempt to Write() the initial request and headers, which will
   // complete asynchronously.
   EXPECT_EQ(ERR_IO_PENDING, http_stream->SendRequest(headers, &response,
                                                      callback.callback()));
@@ skipping 67 matching lines @@
                      kPrivacyModeDisabled);
   InitSession(reads, arraysize(reads), writes, arraysize(writes), key);
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL(full_url);
   TestCompletionCallback callback;
   HttpResponseInfo response;
   HttpRequestHeaders headers;
   BoundNetLog net_log;
-  scoped_ptr<SpdyHttpStream> http_stream(
-      new SpdyHttpStream(session_.get(), true));
+  scoped_ptr<SpdyHttpStream> http_stream(new SpdyHttpStream(session_, true));
   ASSERT_EQ(OK,
             http_stream->InitializeStream(
                 &request, DEFAULT_PRIORITY, net_log, CompletionCallback()));
 
   EXPECT_EQ(ERR_IO_PENDING, http_stream->SendRequest(headers, &response,
                                                      callback.callback()));
 
   EXPECT_EQ(base_url, http_stream->stream()->GetUrlFromHeaders().spec());
 
   // This triggers the MockWrite and read 2
@@ skipping 122 matching lines @@
   http_session_ = SpdySessionDependencies::SpdyCreateSessionDeterministic(
       &session_deps_);
   session_ = CreateSecureSpdySession(http_session_, key, BoundNetLog());
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL(kUrl1);
   HttpResponseInfo response;
   HttpRequestHeaders headers;
   BoundNetLog net_log;
-  scoped_ptr<SpdyHttpStream> http_stream(
-      new SpdyHttpStream(session_.get(), true));
+  scoped_ptr<SpdyHttpStream> http_stream(new SpdyHttpStream(session_, true));
   ASSERT_EQ(
       OK,
       http_stream->InitializeStream(&request, DEFAULT_PRIORITY,
                                     net_log, CompletionCallback()));
 
   //  EXPECT_FALSE(session_->NeedsCredentials(request.url));
   //  GURL new_origin(kUrl2);
   //  EXPECT_TRUE(session_->NeedsCredentials(new_origin));
 
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING, http_stream->SendRequest(headers, &response,
                                                      callback.callback()));
   EXPECT_TRUE(HasSpdySession(http_session_->spdy_session_pool(), key));
 
   data.RunFor(2);
   callback.WaitForResult();
 
   // Start up second request for resource on a new origin.
-  scoped_ptr<SpdyHttpStream> http_stream2(
-      new SpdyHttpStream(session_.get(), true));
+  scoped_ptr<SpdyHttpStream> http_stream2(new SpdyHttpStream(session_, true));
   request.url = GURL(kUrl2);
   ASSERT_EQ(
       OK,
       http_stream2->InitializeStream(&request, DEFAULT_PRIORITY,
                                      net_log, CompletionCallback()));
   EXPECT_EQ(ERR_IO_PENDING, http_stream2->SendRequest(headers, &response,
                                                       callback.callback()));
   data.RunFor(2);
   callback.WaitForResult();
 
@@ skipping 41 matching lines @@
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
   request.upload_data_stream = &upload_stream;
 
   ASSERT_EQ(OK, upload_stream.Init(CompletionCallback()));
   upload_stream.AppendChunk(kUploadData, kUploadDataSize, true);
 
   BoundNetLog net_log;
-  scoped_ptr<SpdyHttpStream> http_stream(
-      new SpdyHttpStream(session_.get(), true));
+  scoped_ptr<SpdyHttpStream> http_stream(new SpdyHttpStream(session_, true));
   ASSERT_EQ(OK, http_stream->InitializeStream(&request, DEFAULT_PRIORITY,
                                               net_log, CompletionCallback()));
 
   HttpRequestHeaders headers;
   HttpResponseInfo response;
   // This will attempt to Write() the initial request and headers, which will
   // complete asynchronously.
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING, http_stream->SendRequest(headers, &response,
                                                      callback.callback()));
@@ skipping 105 matching lines @@
   InitSessionDeterministic(reads, arraysize(reads),
                            writes, arraysize(writes),
                            key);
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL(kUrl1);
   HttpResponseInfo response;
   HttpRequestHeaders headers;
   BoundNetLog net_log;
-  scoped_ptr<SpdyHttpStream> http_stream(
-      new SpdyHttpStream(session_.get(), true));
+  scoped_ptr<SpdyHttpStream> http_stream(new SpdyHttpStream(session_, true));
   ASSERT_EQ(
       OK,
       http_stream->InitializeStream(&request, DEFAULT_PRIORITY,
                                     net_log, CompletionCallback()));
 
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING, http_stream->SendRequest(headers, &response,
                                                      callback.callback()));
   EXPECT_TRUE(HasSpdySession(http_session_->spdy_session_pool(), key));
 
   deterministic_data_->RunFor(2);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   // Start up second request for resource on a new origin.
-  scoped_ptr<SpdyHttpStream> http_stream2(
-      new SpdyHttpStream(session_.get(), true));
+  scoped_ptr<SpdyHttpStream> http_stream2(new SpdyHttpStream(session_, true));
   request.url = GURL(kUrl2);
   ASSERT_EQ(
       OK,
       http_stream2->InitializeStream(&request, DEFAULT_PRIORITY,
                                      net_log, CompletionCallback()));
   EXPECT_EQ(ERR_IO_PENDING, http_stream2->SendRequest(headers, &response,
                                                       callback.callback()));
   deterministic_data_->RunFor(1);
   EXPECT_EQ(OK, callback.WaitForResult());
 
   EXPECT_EQ(ERR_IO_PENDING, http_stream2->ReadResponseHeaders(
       callback.callback()));
   deterministic_data_->RunFor(1);
   EXPECT_EQ(OK, callback.WaitForResult());
   ASSERT_TRUE(response.headers.get() != NULL);
   ASSERT_EQ(200, response.headers->response_code());
   deterministic_data_->RunFor(1);
   sequenced_worker_pool->Shutdown();
 }
 
 #endif  // !defined(USE_OPENSSL)
 
 // TODO(willchan): Write a longer test for SpdyStream that exercises all
 // methods.
 
 }  // namespace net