Remove implicit scoped_refptr operator T*

net/ftp/ftp_network_transaction.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/ftp/ftp_network_transaction.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/metrics/histogram.h"
@@ skipping 318 matching lines @@
 }
 
 void FtpNetworkTransaction::ResetStateForRestart() {
   command_sent_ = COMMAND_NONE;
   user_callback_.Reset();
   response_ = FtpResponseInfo();
   read_ctrl_buf_ = new IOBuffer(kCtrlBufLen);
   ctrl_response_buffer_.reset(new FtpCtrlResponseBuffer());
   read_data_buf_ = NULL;
   read_data_buf_len_ = 0;
-  if (write_buf_)
+  if (write_buf_.get())
     write_buf_->SetOffset(0);
   last_error_ = OK;
   data_connection_port_ = 0;
   ctrl_socket_.reset();
   data_socket_.reset();
   next_state_ = STATE_NONE;
 }
 
 void FtpNetworkTransaction::DoCallback(int rv) {
   DCHECK(rv != ERR_IO_PENDING);
@@ skipping 83 matching lines @@
 }
 
 // Used to prepare and send FTP command.
 int FtpNetworkTransaction::SendFtpCommand(const std::string& command,
                                           Command cmd) {
   // If we send a new command when we still have unprocessed responses
   // for previous commands, the response receiving code will have no way to know
   // which responses are for which command.
   DCHECK(!ctrl_response_buffer_->ResponseAvailable());
 
-  DCHECK(!write_command_buf_);
-  DCHECK(!write_buf_);
+  DCHECK(!write_command_buf_.get());
+  DCHECK(!write_buf_.get());
 
   if (!IsValidFTPCommandString(command)) {
     // Callers should validate the command themselves and return a more specific
     // error code.
     NOTREACHED();
     return Stop(ERR_UNEXPECTED);
   }
 
   command_sent_ = cmd;
 
   write_command_buf_ = new IOBufferWithSize(command.length() + 2);
-  write_buf_ = new DrainableIOBuffer(write_command_buf_,
+  write_buf_ = new DrainableIOBuffer(write_command_buf_.get(),
                                      write_command_buf_->size());
   memcpy(write_command_buf_->data(), command.data(), command.length());
   memcpy(write_command_buf_->data() + command.length(), kCRLF, 2);
 
   next_state_ = STATE_CTRL_WRITE;
   return OK;
 }
 
 std::string FtpNetworkTransaction::GetRequestPathForFtpCommand(
     bool is_directory) const {
@@ skipping 189 matching lines @@
     if (result == OK) {
       response_.socket_address = HostPortPair::FromIPEndPoint(ip_endpoint);
       next_state_ = STATE_CTRL_READ;
     }
   }
   return result;
 }
 
 int FtpNetworkTransaction::DoCtrlRead() {
   next_state_ = STATE_CTRL_READ_COMPLETE;
-  return ctrl_socket_->Read(read_ctrl_buf_, kCtrlBufLen, io_callback_);
+  return ctrl_socket_->Read(read_ctrl_buf_.get(), kCtrlBufLen, io_callback_);
 }
 
 int FtpNetworkTransaction::DoCtrlReadComplete(int result) {
   if (result == 0) {
     // Some servers (for example Pure-FTPd) apparently close the control
     // connection when anonymous login is not permitted. For more details
     // see http://crbug.com/25023.
     if (command_sent_ == COMMAND_USER &&
         credentials_.username() == ASCIIToUTF16("anonymous")) {
       response_.needs_auth = true;
@@ skipping 10 matching lines @@
     next_state_ = STATE_CTRL_READ;
     return OK;
   }
 
   return ProcessCtrlResponse();
 }
 
 int FtpNetworkTransaction::DoCtrlWrite() {
   next_state_ = STATE_CTRL_WRITE_COMPLETE;
 
-  return ctrl_socket_->Write(write_buf_,
+  return ctrl_socket_->Write(write_buf_.get(),
                              write_buf_->BytesRemaining(),
                              io_callback_);
 }
 
 int FtpNetworkTransaction::DoCtrlWriteComplete(int result) {
   if (result < 0)
     return result;
 
   write_buf_->DidConsume(result);
   if (write_buf_->BytesRemaining() == 0) {
@@ skipping 531 matching lines @@
       next_state_ = STATE_CTRL_READ;
       return OK;
     }
 
     // We are no longer connected to the server, so just finish the transaction.
     return Stop(OK);
   }
 
   next_state_ = STATE_DATA_READ_COMPLETE;
   read_data_buf_->data()[0] = 0;
-  return data_socket_->Read(read_data_buf_, read_data_buf_len_, io_callback_);
+  return data_socket_->
+      Read(read_data_buf_.get(), read_data_buf_len_, io_callback_);
 }
 
 int FtpNetworkTransaction::DoDataReadComplete(int result) {
   return result;
 }
 
 // We're using a histogram as a group of counters, with one bucket for each
 // enumeration value.  We're only interested in the values of the counters.
 // Ignore the shape, average, and standard deviation of the histograms because
 // they are meaningless.
@@ skipping 75 matching lines @@
   if (!had_error_type[type]) {
     had_error_type[type] = true;
     UMA_HISTOGRAM_ENUMERATION("Net.FtpDataConnectionErrorHappened",
         type, NUM_OF_NET_ERROR_TYPES);
   }
   UMA_HISTOGRAM_ENUMERATION("Net.FtpDataConnectionErrorCount",
       type, NUM_OF_NET_ERROR_TYPES);
 }
 
 }  // namespace net