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

net/websockets/websocket_job.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 <algorithm>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ skipping 93 matching lines @@
     case INITIALIZED:
       return false;
 
     case CONNECTING:
       return SendHandshakeRequest(data, len);
 
     case OPEN:
       {
         scoped_refptr<IOBufferWithSize> buffer = new IOBufferWithSize(len);
         memcpy(buffer->data(), data, len);
-        if (current_send_buffer_ || !send_buffer_queue_.empty()) {
+        if (current_send_buffer_.get() || !send_buffer_queue_.empty()) {
           send_buffer_queue_.push_back(buffer);
           return true;
         }
         current_send_buffer_ = new DrainableIOBuffer(buffer.get(), len);
         return SendDataInternal(current_send_buffer_->data(),
                                 current_send_buffer_->BytesRemaining());
       }
 
     case CLOSING:
     case CLOSED:
       return false;
   }
   return false;
 }
 
 void WebSocketJob::Close() {
   if (state_ == CLOSED)
     return;
 
   state_ = CLOSING;
-  if (current_send_buffer_) {
+  if (current_send_buffer_.get()) {
     // Will close in SendPending.
     return;
   }
   state_ = CLOSED;
   CloseInternal();
 }
 
 void WebSocketJob::RestartWithAuth(const AuthCredentials& credentials) {
   state_ = CONNECTING;
   socket_->RestartWithAuth(credentials);
 }
 
 void WebSocketJob::DetachDelegate() {
   state_ = CLOSED;
   WebSocketThrottle::GetInstance()->RemoveFromQueue(this);
   WebSocketThrottle::GetInstance()->WakeupSocketIfNecessary();
 
   scoped_refptr<WebSocketJob> protect(this);
   weak_ptr_factory_.InvalidateWeakPtrs();
   weak_ptr_factory_for_send_pending_.InvalidateWeakPtrs();
 
   delegate_ = NULL;
-  if (socket_)
+  if (socket_.get())
     socket_->DetachDelegate();
   socket_ = NULL;
   if (!callback_.is_null()) {
     waiting_ = false;
     callback_.Reset();
     Release();  // Balanced with OnStartOpenConnection().
   }
 }
 
 int WebSocketJob::OnStartOpenConnection(
@@ skipping 29 matching lines @@
   DCHECK_NE(INITIALIZED, state_);
   DCHECK_GT(amount_sent, 0);
   if (state_ == CLOSED)
     return;
   if (state_ == CONNECTING) {
     OnSentHandshakeRequest(socket, amount_sent);
     return;
   }
   if (delegate_) {
     DCHECK(state_ == OPEN || state_ == CLOSING);
-    if (!current_send_buffer_) {
-      VLOG(1) << "OnSentData current_send_buffer=NULL amount_sent="
-              << amount_sent;
+    if (!current_send_buffer_.get()) {
+      VLOG(1)
+          << "OnSentData current_send_buffer=NULL amount_sent=" << amount_sent;
       return;
     }
     current_send_buffer_->DidConsume(amount_sent);
     if (current_send_buffer_->BytesRemaining() > 0)
       return;
 
     // We need to report amount_sent of original buffer size, instead of
     // amount sent to |socket|.
     amount_sent = current_send_buffer_->size();
     DCHECK_GT(amount_sent, 0);
@@ skipping 74 matching lines @@
   }
 
   CompleteIO(result);
 }
 
 void WebSocketJob::OnSentSpdyHeaders() {
   DCHECK_NE(INITIALIZED, state_);
   if (state_ != CONNECTING)
     return;
   if (delegate_)
-    delegate_->OnSentData(socket_, handshake_request_->original_length());
+    delegate_->OnSentData(socket_.get(), handshake_request_->original_length());
   handshake_request_.reset();
 }
 
 int WebSocketJob::OnReceivedSpdyResponseHeader(
     const SpdyHeaderBlock& headers, int status) {
   DCHECK_NE(INITIALIZED, state_);
   if (state_ != CONNECTING)
     return status;
   if (status != OK)
     return status;
   // TODO(toyoshim): Fallback to non-spdy connection?
   handshake_response_->ParseResponseHeaderBlock(headers,
                                                 challenge_,
                                                 spdy_protocol_version_);
 
   SaveCookiesAndNotifyHeadersComplete();
   return OK;
 }
 
 void WebSocketJob::OnSentSpdyData(size_t bytes_sent) {
   DCHECK_NE(INITIALIZED, state_);
   DCHECK_NE(CONNECTING, state_);
   if (state_ == CLOSED)
     return;
   if (!spdy_websocket_stream_.get())
     return;
-  OnSentData(socket_, static_cast<int>(bytes_sent));
+  OnSentData(socket_.get(), static_cast<int>(bytes_sent));
 }
 
 void WebSocketJob::OnReceivedSpdyData(scoped_ptr<SpdyBuffer> buffer) {
   DCHECK_NE(INITIALIZED, state_);
   DCHECK_NE(CONNECTING, state_);
   if (state_ == CLOSED)
     return;
   if (!spdy_websocket_stream_.get())
     return;
   if (buffer) {
-    OnReceivedData(socket_, buffer->GetRemainingData(),
-                   buffer->GetRemainingSize());
+    OnReceivedData(
+        socket_.get(), buffer->GetRemainingData(), buffer->GetRemainingSize());
   } else {
-    OnReceivedData(socket_, NULL, 0);
+    OnReceivedData(socket_.get(), NULL, 0);
   }
 }
 
 void WebSocketJob::OnCloseSpdyStream() {
   spdy_websocket_stream_.reset();
-  OnClose(socket_);
+  OnClose(socket_.get());
 }
 
 bool WebSocketJob::SendHandshakeRequest(const char* data, int len) {
   DCHECK_EQ(state_, CONNECTING);
   if (started_to_send_handshake_request_)
     return false;
   if (!handshake_request_->ParseRequest(data, len))
     return false;
 
   // handshake message is completed.
   handshake_response_->set_protocol_version(
       handshake_request_->protocol_version());
   AddCookieHeaderAndSend();
   return true;
 }
 
 void WebSocketJob::AddCookieHeaderAndSend() {
   bool allow = true;
-  if (delegate_ && !delegate_->CanGetCookies(socket_, GetURLForCookies()))
+  if (delegate_ && !delegate_->CanGetCookies(socket_.get(), GetURLForCookies()))
     allow = false;
 
-  if (socket_ && delegate_ && state_ == CONNECTING) {
-    handshake_request_->RemoveHeaders(
-        kCookieHeaders, arraysize(kCookieHeaders));
+  if (socket_.get() && delegate_ && state_ == CONNECTING) {
+    handshake_request_->RemoveHeaders(kCookieHeaders,
+                                      arraysize(kCookieHeaders));
     if (allow && socket_->context()->cookie_store()) {
       // Add cookies, including HttpOnly cookies.
       CookieOptions cookie_options;
       cookie_options.set_include_httponly();
       socket_->context()->cookie_store()->GetCookiesWithOptionsAsync(
           GetURLForCookies(), cookie_options,
           base::Bind(&WebSocketJob::LoadCookieCallback,
                      weak_ptr_factory_.GetWeakPtr()));
     } else {
       DoSendData();
@@ skipping 103 matching lines @@
   received_data.insert(received_data.end(),
                        received_data_after_handshake_.begin(),
                        received_data_after_handshake_.end());
   received_data_after_handshake_.clear();
 
   state_ = OPEN;
 
   DCHECK(!received_data.empty());
   if (delegate_)
     delegate_->OnReceivedData(
-        socket_, &received_data.front(), received_data.size());
+        socket_.get(), &received_data.front(), received_data.size());
 
   WebSocketThrottle::GetInstance()->RemoveFromQueue(this);
   WebSocketThrottle::GetInstance()->WakeupSocketIfNecessary();
 }
 
 void WebSocketJob::SaveNextCookie() {
-  if (!socket_ || !delegate_ || state_ != CONNECTING)
+  if (!socket_.get() || !delegate_ || state_ != CONNECTING)
     return;
 
   callback_pending_ = false;
   save_next_cookie_running_ = true;
 
   if (socket_->context()->cookie_store()) {
     GURL url_for_cookies = GetURLForCookies();
 
     CookieOptions options;
     options.set_include_httponly();
 
     // Loop as long as SetCookieWithOptionsAsync completes synchronously. Since
     // CookieMonster's asynchronous operation APIs queue the callback to run it
     // on the thread where the API was called, there won't be race. I.e. unless
     // the callback is run synchronously, it won't be run in parallel with this
     // method.
     while (!callback_pending_ &&
            response_cookies_save_index_ < response_cookies_.size()) {
       std::string cookie = response_cookies_[response_cookies_save_index_];
       response_cookies_save_index_++;
 
-      if (!delegate_->CanSetCookie(socket_, url_for_cookies, cookie, &options))
+      if (!delegate_->CanSetCookie(
+              socket_.get(), url_for_cookies, cookie, &options))
         continue;
 
       callback_pending_ = true;
       socket_->context()->cookie_store()->SetCookieWithOptionsAsync(
           url_for_cookies, cookie, options,
           base::Bind(&WebSocketJob::OnCookieSaved,
                      weak_ptr_factory_.GetWeakPtr()));
     }
   }
 
@@ skipping 66 matching lines @@
   SSLInfo ssl_info;
   bool was_npn_negotiated;
   NextProto protocol_negotiated = kProtoUnknown;
   bool use_ssl = spdy_session->GetSSLInfo(
       &ssl_info, &was_npn_negotiated, &protocol_negotiated);
   if (socket_->is_secure() && !use_ssl)
     return OK;
 
   // Create SpdyWebSocketStream.
   spdy_protocol_version_ = spdy_session->GetProtocolVersion();
-  spdy_websocket_stream_.reset(new SpdyWebSocketStream(spdy_session, this));
+  spdy_websocket_stream_.reset(
+      new SpdyWebSocketStream(spdy_session.get(), this));
 
   int result = spdy_websocket_stream_->InitializeStream(
       socket_->url(), MEDIUM, *socket_->net_log());
   if (result == OK) {
-    OnConnected(socket_, kMaxPendingSendAllowed);
+    OnConnected(socket_.get(), kMaxPendingSendAllowed);
     return ERR_PROTOCOL_SWITCHED;
   }
   if (result != ERR_IO_PENDING) {
     spdy_websocket_stream_.reset();
     return OK;
   }
 
   return ERR_IO_PENDING;
 }
 
@@ skipping 44 matching lines @@
 }
 
 void WebSocketJob::CloseInternal() {
   if (spdy_websocket_stream_.get())
     spdy_websocket_stream_->Close();
   if (socket_.get())
     socket_->Close();
 }
 
 void WebSocketJob::SendPending() {
-  if (current_send_buffer_)
+  if (current_send_buffer_.get())
     return;
 
   // Current buffer has been sent. Try next if any.
   if (send_buffer_queue_.empty()) {
     // No more data to send.
     if (state_ == CLOSING)
       CloseInternal();
     return;
   }
 
   scoped_refptr<IOBufferWithSize> next_buffer = send_buffer_queue_.front();
   send_buffer_queue_.pop_front();
-  current_send_buffer_ = new DrainableIOBuffer(next_buffer,
-                                               next_buffer->size());
+  current_send_buffer_ =
+      new DrainableIOBuffer(next_buffer.get(), next_buffer->size());
   SendDataInternal(current_send_buffer_->data(),
                    current_send_buffer_->BytesRemaining());
 }
 
 }  // namespace net