Update net/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

net/spdy/spdy_session_spdy3_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_session.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
@@ skipping 402 matching lines @@
 
   // Give the session a SPDY3 framer.
   session->buffered_spdy_framer_.reset(new BufferedSpdyFramer(SPDY3, false));
 
   // Create the associated stream and add to active streams.
   scoped_ptr<SpdyHeaderBlock> request_headers(new SpdyHeaderBlock);
   (*request_headers)[":scheme"] = "http";
   (*request_headers)[":host"] = "www.google.com";
   (*request_headers)[":path"] = "/";
 
-  scoped_ptr<SpdyStream> stream(
-      new SpdyStream(
-          SPDY_REQUEST_RESPONSE_STREAM,
-          session, std::string(), DEFAULT_PRIORITY,
-          kSpdyStreamInitialWindowSize,
-          kSpdyStreamInitialWindowSize,
-          session->net_log_));
+  scoped_ptr<SpdyStream> stream(new SpdyStream(SPDY_REQUEST_RESPONSE_STREAM,
+                                               session.get(),
+                                               std::string(),
+                                               DEFAULT_PRIORITY,
+                                               kSpdyStreamInitialWindowSize,
+                                               kSpdyStreamInitialWindowSize,
+                                               session->net_log_));
   stream->SendRequestHeaders(request_headers.Pass(), NO_MORE_DATA_TO_SEND);
   SpdyStream* stream_ptr = stream.get();
   session->InsertCreatedStream(stream.Pass());
   stream = session->ActivateCreatedStream(stream_ptr);
   session->InsertActivatedStream(stream.Pass());
 
   SpdyHeaderBlock headers;
   headers[":scheme"] = "http";
   headers[":host"] = "www.google.com";
   headers[":path"] = "/a.dat";
@@ skipping 576 matching lines @@
   HostPortPair test_host_port_pair(test_hosts[0].name, kTestPort);
 
   // Initialize session for the first host.
   scoped_refptr<TransportSocketParams> transport_params(
       new TransportSocketParams(test_host_port_pair,
                                 MEDIUM,
                                 false,
                                 false,
                                 OnHostResolutionCallback()));
   IPPoolingInitializedSession(test_host_port_pair.ToString(),
-                              transport_params, http_session, session);
+                              transport_params,
+                              http_session.get(),
+                              session.get());
 
   // TODO(rtenneti): MockClientSocket::GetPeerAddress return's 0 as the port
   // number. Fix it to return port 80 and then use GetPeerAddress to AddAlias.
   SpdySessionPoolPeer pool_peer(spdy_session_pool);
   pool_peer.AddAlias(test_hosts[0].addresses.front(), test_hosts[0].key);
 
   // Flush the SpdySession::OnReadComplete() task.
   base::MessageLoop::current()->RunUntilIdle();
 
   // The third host has no overlap with the first, so it can't pool IPs.
@@ skipping 16 matching lines @@
       spdy_session_pool->Get(test_hosts[2].key, BoundNetLog());
 
   // Verify that we have sessions for everything.
   EXPECT_TRUE(spdy_session_pool->HasSession(test_hosts[0].key));
   EXPECT_TRUE(spdy_session_pool->HasSession(test_hosts[1].key));
   EXPECT_TRUE(spdy_session_pool->HasSession(test_hosts[2].key));
 
   // Initialize session for host 2.
   session_deps.socket_factory->AddSocketDataProvider(&data);
   IPPoolingInitializedSession(test_hosts[2].key.host_port_pair().ToString(),
-                              transport_params, http_session, session2);
+                              transport_params,
+                              http_session.get(),
+                              session2.get());
 
   // Grab the session to host 1 and verify that it is the same session
   // we got with host 0, and that is a different than host 2's session.
   scoped_refptr<SpdySession> session1 =
       spdy_session_pool->Get(test_hosts[1].key, BoundNetLog());
   EXPECT_EQ(session.get(), session1.get());
   EXPECT_NE(session2.get(), session1.get());
 
   // Initialize session for host 1.
   session_deps.socket_factory->AddSocketDataProvider(&data);
   IPPoolingInitializedSession(test_hosts[2].key.host_port_pair().ToString(),
-                              transport_params, http_session, session2);
+                              transport_params,
+                              http_session.get(),
+                              session2.get());
 
   // Remove the aliases and observe that we still have a session for host1.
   pool_peer.RemoveAliases(test_hosts[0].key);
   pool_peer.RemoveAliases(test_hosts[1].key);
   EXPECT_TRUE(spdy_session_pool->HasSession(test_hosts[1].key));
 
   // Expire the host cache
   session_deps.host_resolver->GetHostCache()->clear();
   EXPECT_TRUE(spdy_session_pool->HasSession(test_hosts[1].key));
 
@@ skipping 1933 matching lines @@
   EXPECT_FALSE(stream->HasUrl());
   EXPECT_FALSE(stream->send_stalled_by_flow_control());
 
   scoped_ptr<SpdyHeaderBlock> headers(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
   EXPECT_EQ(ERR_IO_PENDING,
             stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrl());
   EXPECT_EQ(kStreamUrl, stream->GetUrl().spec());
 
-  stall_fn.Run(session, stream);
+  stall_fn.Run(session.get(), stream);
 
   data.RunFor(2);
 
   EXPECT_TRUE(stream->send_stalled_by_flow_control());
 
-  unstall_function.Run(session, stream, kBodyDataSize);
+  unstall_function.Run(session.get(), stream, kBodyDataSize);
 
   EXPECT_FALSE(stream->send_stalled_by_flow_control());
 
   data.RunFor(3);
 
   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
 
   EXPECT_TRUE(delegate.send_headers_completed());
   EXPECT_EQ("200", delegate.GetResponseHeaderValue(":status"));
   EXPECT_EQ("HTTP/1.1", delegate.GetResponseHeaderValue(":version"));
@@ skipping 126 matching lines @@
   ASSERT_TRUE(stream2.get() != NULL);
 
   test::StreamDelegateWithBody delegate2(stream2, kBodyDataStringPiece);
   stream2->SetDelegate(&delegate2);
 
   EXPECT_FALSE(stream2->HasUrl());
 
   EXPECT_FALSE(stream1->send_stalled_by_flow_control());
   EXPECT_FALSE(stream2->send_stalled_by_flow_control());
 
-  StallSessionSend(session);
+  StallSessionSend(session.get());
 
   scoped_ptr<SpdyHeaderBlock> headers1(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
   EXPECT_EQ(ERR_IO_PENDING,
             stream1->SendRequestHeaders(headers1.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream1->HasUrl());
   EXPECT_EQ(kStreamUrl, stream1->GetUrl().spec());
 
   data.RunFor(2);
   EXPECT_EQ(1u, stream1->stream_id());
   EXPECT_TRUE(stream1->send_stalled_by_flow_control());
 
   scoped_ptr<SpdyHeaderBlock> headers2(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
   EXPECT_EQ(ERR_IO_PENDING,
             stream2->SendRequestHeaders(headers2.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream2->HasUrl());
   EXPECT_EQ(kStreamUrl, stream2->GetUrl().spec());
 
   data.RunFor(1);
   EXPECT_EQ(3u, stream2->stream_id());
   EXPECT_TRUE(stream2->send_stalled_by_flow_control());
 
   // This should unstall only stream2.
-  UnstallSessionSend(session, kBodyDataSize);
+  UnstallSessionSend(session.get(), kBodyDataSize);
 
   EXPECT_TRUE(stream1->send_stalled_by_flow_control());
   EXPECT_FALSE(stream2->send_stalled_by_flow_control());
 
   data.RunFor(1);
 
   EXPECT_TRUE(stream1->send_stalled_by_flow_control());
   EXPECT_FALSE(stream2->send_stalled_by_flow_control());
 
   // This should then unstall stream1.
-  UnstallSessionSend(session, kBodyDataSize);
+  UnstallSessionSend(session.get(), kBodyDataSize);
 
   EXPECT_FALSE(stream1->send_stalled_by_flow_control());
   EXPECT_FALSE(stream2->send_stalled_by_flow_control());
 
   data.RunFor(4);
 
   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate1.WaitForClose());
   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate2.WaitForClose());
 
   EXPECT_TRUE(delegate1.send_headers_completed());
@@ skipping 110 matching lines @@
 
   test::StreamDelegateWithBody delegate3(stream3, kBodyDataStringPiece);
   stream3->SetDelegate(&delegate3);
 
   EXPECT_FALSE(stream3->HasUrl());
 
   EXPECT_FALSE(stream1->send_stalled_by_flow_control());
   EXPECT_FALSE(stream2->send_stalled_by_flow_control());
   EXPECT_FALSE(stream3->send_stalled_by_flow_control());
 
-  StallSessionSend(session);
+  StallSessionSend(session.get());
 
   scoped_ptr<SpdyHeaderBlock> headers1(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
   EXPECT_EQ(ERR_IO_PENDING,
             stream1->SendRequestHeaders(headers1.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream1->HasUrl());
   EXPECT_EQ(kStreamUrl, stream1->GetUrl().spec());
 
   data.RunFor(2);
   EXPECT_EQ(1u, stream1->stream_id());
@@ skipping 28 matching lines @@
   // Close stream1 preemptively.
   session->CloseActiveStream(stream_id1, ERR_CONNECTION_CLOSED);
   EXPECT_EQ(NULL, stream1.get());
 
   EXPECT_FALSE(session->IsStreamActive(stream_id1));
   EXPECT_TRUE(session->IsStreamActive(stream_id2));
   EXPECT_TRUE(session->IsStreamActive(stream_id3));
 
   // Unstall stream2, which should then close stream3.
   delegate2.set_stream_to_close(stream3);
-  UnstallSessionSend(session, kBodyDataSize);
+  UnstallSessionSend(session.get(), kBodyDataSize);
 
   data.RunFor(1);
   EXPECT_EQ(NULL, stream3.get());
 
   EXPECT_FALSE(stream2->send_stalled_by_flow_control());
   EXPECT_FALSE(session->IsStreamActive(stream_id1));
   EXPECT_TRUE(session->IsStreamActive(stream_id2));
   EXPECT_FALSE(session->IsStreamActive(stream_id3));
 
   data.RunFor(2);
@@ skipping 77 matching lines @@
   ASSERT_TRUE(stream2.get() != NULL);
 
   test::StreamDelegateWithBody delegate2(stream2, kBodyDataStringPiece);
   stream2->SetDelegate(&delegate2);
 
   EXPECT_FALSE(stream2->HasUrl());
 
   EXPECT_FALSE(stream1->send_stalled_by_flow_control());
   EXPECT_FALSE(stream2->send_stalled_by_flow_control());
 
-  StallSessionSend(session);
+  StallSessionSend(session.get());
 
   scoped_ptr<SpdyHeaderBlock> headers1(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
   EXPECT_EQ(ERR_IO_PENDING,
             stream1->SendRequestHeaders(headers1.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream1->HasUrl());
   EXPECT_EQ(kStreamUrl, stream1->GetUrl().spec());
 
   data.RunFor(2);
   EXPECT_EQ(1u, stream1->stream_id());
   EXPECT_TRUE(stream1->send_stalled_by_flow_control());
 
   scoped_ptr<SpdyHeaderBlock> headers2(
       spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kBodyDataSize));
   EXPECT_EQ(ERR_IO_PENDING,
             stream2->SendRequestHeaders(headers2.Pass(), MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream2->HasUrl());
   EXPECT_EQ(kStreamUrl, stream2->GetUrl().spec());
 
   data.RunFor(1);
   EXPECT_EQ(3u, stream2->stream_id());
   EXPECT_TRUE(stream2->send_stalled_by_flow_control());
 
   EXPECT_TRUE(spdy_session_pool_->HasSession(key_));
 
   // Unstall stream1.
-  UnstallSessionSend(session, kBodyDataSize);
+  UnstallSessionSend(session.get(), kBodyDataSize);
 
   // Close the session (since we can't do it from within the delegate
   // method, since it's in the stream's loop).
   session->CloseSessionOnError(ERR_CONNECTION_CLOSED, true, "Closing session");
   session = NULL;
 
   EXPECT_FALSE(spdy_session_pool_->HasSession(key_));
 
   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate1.WaitForClose());
   EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate2.WaitForClose());
@@ skipping 331 matching lines @@
   spdy_session_pool_->Remove(session_privacy_enabled);
   EXPECT_FALSE(spdy_session_pool_->HasSession(key_privacy_enabled));
   EXPECT_TRUE(spdy_session_pool_->HasSession(key_privacy_disabled));
 
   spdy_session_pool_->Remove(session_privacy_disabled);
   EXPECT_FALSE(spdy_session_pool_->HasSession(key_privacy_enabled));
   EXPECT_FALSE(spdy_session_pool_->HasSession(key_privacy_disabled));
 }
 
 }  // namespace net