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

net/websockets/websocket_job_spdy2_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/websockets/websocket_job.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 370 matching lines @@
     if (stream_type == STREAM_MOCK_SOCKET)
       socket_ = new MockSocketStream(url, websocket_.get());
 
     if (stream_type == STREAM_SOCKET || stream_type == STREAM_SPDY_WEBSOCKET) {
       if (stream_type == STREAM_SPDY_WEBSOCKET) {
         http_factory_.reset(new MockHttpTransactionFactory(data_.get()));
         context_->set_http_transaction_factory(http_factory_.get());
       }
 
       ssl_config_service_ = new MockSSLConfigService();
-      context_->set_ssl_config_service(ssl_config_service_);
+      context_->set_ssl_config_service(ssl_config_service_.get());
       proxy_service_.reset(ProxyService::CreateDirect());
       context_->set_proxy_service(proxy_service_.get());
       host_resolver_.reset(new MockHostResolver);
       context_->set_host_resolver(host_resolver_.get());
 
       socket_ = new SocketStream(url, websocket_.get());
       socket_factory_.reset(new MockClientSocketFactory);
       DCHECK(data_.get());
       socket_factory_->AddSocketDataProvider(data_.get());
       socket_->SetClientSocketFactory(socket_factory_.get());
     }
 
     websocket_->InitSocketStream(socket_.get());
     websocket_->set_context(context_.get());
     // MockHostResolver resolves all hosts to 127.0.0.1; however, when we create
     // a WebSocketJob purely to block another one in a throttling test, we don't
     // perform a real connect. In that case, the following address is used
     // instead.
     IPAddressNumber ip;
     ParseIPLiteralToNumber("127.0.0.1", &ip);
     websocket_->addresses_ = AddressList::CreateFromIPAddress(ip, 80);
   }
   void SkipToConnecting() {
     websocket_->state_ = WebSocketJob::CONNECTING;
-    WebSocketThrottle::GetInstance()->PutInQueue(websocket_);
+    WebSocketThrottle::GetInstance()->PutInQueue(websocket_.get());
   }
   WebSocketJob::State GetWebSocketJobState() {
     return websocket_->state_;
   }
   void CloseWebSocketJob() {
-    if (websocket_->socket_) {
+    if (websocket_->socket_.get()) {
       websocket_->socket_->DetachDelegate();
-      WebSocketThrottle::GetInstance()->RemoveFromQueue(websocket_);
+      WebSocketThrottle::GetInstance()->RemoveFromQueue(websocket_.get());
     }
     websocket_->state_ = WebSocketJob::CLOSED;
     websocket_->delegate_ = NULL;
     websocket_->socket_ = NULL;
   }
   SocketStream* GetSocket(SocketStreamJob* job) {
     return job->socket_.get();
   }
   const std::string& sent_data() const {
     DCHECK_EQ(STREAM_MOCK_SOCKET, stream_type_);
@@ skipping 172 matching lines @@
   EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState());
   websocket_->OnSentData(socket_.get(),
                          kHandshakeRequestWithoutCookieLength);
   EXPECT_EQ(kHandshakeRequestWithoutCookieLength, delegate.amount_sent());
 
   std::vector<std::string> lines;
   base::SplitString(kHandshakeResponseWithoutCookie, '\n', &lines);
   for (size_t i = 0; i < lines.size() - 2; i++) {
     std::string line = lines[i] + "\r\n";
     SCOPED_TRACE("Line: " + line);
-    websocket_->OnReceivedData(socket_,
-                               line.c_str(),
-                               line.size());
+    websocket_->OnReceivedData(socket_.get(), line.c_str(), line.size());
     base::MessageLoop::current()->RunUntilIdle();
     EXPECT_TRUE(delegate.received_data().empty());
     EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState());
   }
   websocket_->OnReceivedData(socket_.get(), "\r\n", 2);
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_FALSE(delegate.received_data().empty());
   EXPECT_EQ(kHandshakeResponseWithoutCookie, delegate.received_data());
   EXPECT_EQ(WebSocketJob::OPEN, GetWebSocketJobState());
   CloseWebSocketJob();
 }
 
 TEST_F(WebSocketJobSpdy2Test, DelayedCookies) {
   WebSocketJob::set_websocket_over_spdy_enabled(true);
   GURL url("ws://example.com/demo");
   GURL cookieUrl("http://example.com/demo");
   CookieOptions cookie_options;
   scoped_refptr<DelayedCookieMonster> cookie_store = new DelayedCookieMonster();
-  context_->set_cookie_store(cookie_store);
-  cookie_store->SetCookieWithOptionsAsync(
-      cookieUrl, "CR-test=1", cookie_options,
-      CookieMonster::SetCookiesCallback());
+  context_->set_cookie_store(cookie_store.get());
+  cookie_store->SetCookieWithOptionsAsync(cookieUrl,
+                                          "CR-test=1",
+                                          cookie_options,
+                                          CookieMonster::SetCookiesCallback());
   cookie_options.set_include_httponly();
   cookie_store->SetCookieWithOptionsAsync(
       cookieUrl, "CR-test-httponly=1", cookie_options,
       CookieMonster::SetCookiesCallback());
 
   MockSocketStreamDelegate delegate;
   InitWebSocketJob(url, &delegate, STREAM_MOCK_SOCKET);
   SkipToConnecting();
 
   bool sent = websocket_->SendData(kHandshakeRequestWithCookie,
                                    kHandshakeRequestWithCookieLength);
   EXPECT_TRUE(sent);
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(kHandshakeRequestWithFilteredCookie, sent_data());
   EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState());
-  websocket_->OnSentData(socket_,
+  websocket_->OnSentData(socket_.get(),
                          kHandshakeRequestWithFilteredCookieLength);
   EXPECT_EQ(kHandshakeRequestWithCookieLength,
             delegate.amount_sent());
 
   websocket_->OnReceivedData(socket_.get(),
                              kHandshakeResponseWithCookie,
                              kHandshakeResponseWithCookieLength);
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(kHandshakeResponseWithoutCookie, delegate.received_data());
   EXPECT_EQ(WebSocketJob::OPEN, GetWebSocketJobState());
@@ skipping 14 matching lines @@
   MockSocketStreamDelegate delegate;
   InitWebSocketJob(url, &delegate, STREAM_MOCK_SOCKET);
   SkipToConnecting();
 
   bool sent = websocket_->SendData(kHandshakeRequestWithCookie,
                                    kHandshakeRequestWithCookieLength);
   EXPECT_TRUE(sent);
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(kHandshakeRequestWithFilteredCookie, sent_data());
   EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState());
-  websocket_->OnSentData(socket_,
+  websocket_->OnSentData(socket_.get(),
                          kHandshakeRequestWithFilteredCookieLength);
   EXPECT_EQ(kHandshakeRequestWithCookieLength,
             delegate.amount_sent());
 
   websocket_->OnReceivedData(socket_.get(),
                              kHandshakeResponseWithCookie,
                              kHandshakeResponseWithCookieLength);
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(kHandshakeResponseWithoutCookie, delegate.received_data());
   EXPECT_EQ(WebSocketJob::OPEN, GetWebSocketJobState());
@@ skipping 23 matching lines @@
   delegate.set_allow_all_cookies(false);
   InitWebSocketJob(url, &delegate, STREAM_MOCK_SOCKET);
   SkipToConnecting();
 
   bool sent = websocket_->SendData(kHandshakeRequestWithCookie,
                                    kHandshakeRequestWithCookieLength);
   EXPECT_TRUE(sent);
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(kHandshakeRequestWithoutCookie, sent_data());
   EXPECT_EQ(WebSocketJob::CONNECTING, GetWebSocketJobState());
-  websocket_->OnSentData(socket_, kHandshakeRequestWithoutCookieLength);
-  EXPECT_EQ(kHandshakeRequestWithCookieLength,
-            delegate.amount_sent());
+  websocket_->OnSentData(socket_.get(), kHandshakeRequestWithoutCookieLength);
+  EXPECT_EQ(kHandshakeRequestWithCookieLength, delegate.amount_sent());
 
   websocket_->OnReceivedData(socket_.get(),
                              kHandshakeResponseWithCookie,
                              kHandshakeResponseWithCookieLength);
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(kHandshakeResponseWithoutCookie, delegate.received_data());
   EXPECT_EQ(WebSocketJob::OPEN, GetWebSocketJobState());
 
   EXPECT_EQ(2U, cookie_store_->entries().size());
   EXPECT_EQ(cookieUrl, cookie_store_->entries()[0].url);
@@ skipping 107 matching lines @@
   }
 
   websocket_->Connect();
 
   if (throttling == THROTTLING_ON) {
     EXPECT_EQ(OK, WaitForResult());
     EXPECT_TRUE(websocket_->IsWaiting());
 
     // Remove the former WebSocket object from throttling queue to unblock the
     // latter.
-    WebSocketThrottle::GetInstance()->RemoveFromQueue(block_websocket);
+    WebSocketThrottle::GetInstance()->RemoveFromQueue(block_websocket.get());
     block_websocket->state_ = WebSocketJob::CLOSED;
     block_websocket = NULL;
     WebSocketThrottle::GetInstance()->WakeupSocketIfNecessary();
   }
 
   EXPECT_EQ(OK, WaitForResult());
   EXPECT_TRUE(data_->at_read_eof());
   EXPECT_TRUE(data_->at_write_eof());
   EXPECT_EQ(WebSocketJob::CLOSED, GetWebSocketJobState());
 }
@@ skipping 95 matching lines @@
   }
 
   websocket_->Connect();
 
   if (throttling == THROTTLING_ON) {
     EXPECT_EQ(OK, WaitForResult());
     EXPECT_TRUE(websocket_->IsWaiting());
 
     // Remove the former WebSocket object from throttling queue to unblock the
     // latter.
-    WebSocketThrottle::GetInstance()->RemoveFromQueue(block_websocket);
+    WebSocketThrottle::GetInstance()->RemoveFromQueue(block_websocket.get());
     block_websocket->state_ = WebSocketJob::CLOSED;
     block_websocket = NULL;
     WebSocketThrottle::GetInstance()->WakeupSocketIfNecessary();
   }
 
   EXPECT_EQ(OK, WaitForResult());
   EXPECT_TRUE(data_->at_read_eof());
   EXPECT_TRUE(data_->at_write_eof());
   EXPECT_EQ(WebSocketJob::CLOSED, GetWebSocketJobState());
 }
@@ skipping 95 matching lines @@
 }
 
 TEST_F(WebSocketJobSpdy2Test, ThrottlingSpdySpdyEnabled) {
   WebSocketJob::set_websocket_over_spdy_enabled(true);
   TestConnectBySpdy(SPDY_ON, THROTTLING_ON);
 }
 
 // TODO(toyoshim): Add tests to verify throttling, SPDY stream limitation.
 // TODO(toyoshim,yutak): Add tests to verify closing handshake.
 }  // namespace net