Remove implicit scoped_refptr 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 92 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_) {
+    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|.
@@ skipping 76 matching lines @@
   }
 
   CompleteIO(result);
 }
 
 void WebSocketJob::OnSentSpdyHeaders(int result) {
   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_);
 
   SaveCookiesAndNotifyHeaderComplete();
   return OK;
 }
 
 void WebSocketJob::OnSentSpdyData(int amount_sent) {
   DCHECK_NE(INITIALIZED, state_);
   DCHECK_NE(CONNECTING, state_);
   if (state_ == CLOSED)
     return;
   if (!spdy_websocket_stream_.get())
     return;
-  OnSentData(socket_, amount_sent);
+  OnSentData(socket_.get(), amount_sent);
 }
 
 void WebSocketJob::OnReceivedSpdyData(const char* data, int length) {
   DCHECK_NE(INITIALIZED, state_);
   DCHECK_NE(CONNECTING, state_);
   if (state_ == CLOSED)
     return;
   if (!spdy_websocket_stream_.get())
     return;
-  OnReceivedData(socket_, data, length);
+  OnReceivedData(socket_.get(), data, length);
 }
 
 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) {
+  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()));
@@ 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());
 
     handshake_response_.reset();
 
     WebSocketThrottle::GetInstance()->RemoveFromQueue(this);
     WebSocketThrottle::GetInstance()->WakeupSocketIfNecessary();
     return;
   }
 
   bool allow = true;
   CookieOptions options;
   GURL url = GetURLForCookies();
   std::string cookie = response_cookies_[response_cookies_save_index_];
-  if (delegate_ && !delegate_->CanSetCookie(socket_, url, cookie, &options))
+  if (
+      delegate_ && !delegate_->
+      CanSetCookie(socket_.get(), url, cookie, &options))
     allow = false;
 
-  if (socket_ && delegate_ && state_ == CONNECTING) {
+  if (socket_.get() && delegate_ && state_ == CONNECTING) {
     response_cookies_save_index_++;
     if (allow && socket_->context()->cookie_store()) {
       options.set_include_httponly();
       socket_->context()->cookie_store()->SetCookieWithOptionsAsync(
           url, cookie, options,
           base::Bind(&WebSocketJob::SaveCookieCallback,
                      weak_ptr_factory_.GetWeakPtr()));
     } else {
       SaveNextCookie();
     }
@@ skipping 45 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,
+  current_send_buffer_ = new DrainableIOBuffer(next_buffer.get(),
                                                next_buffer->size());
   SendDataInternal(current_send_buffer_->data(),
                    current_send_buffer_->BytesRemaining());
 }
 
 }  // namespace net