Update net/ to use scoped_refptr<T>::get() rather than implicit "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 321 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(net_log_));
   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;
   state_after_data_connect_complete_ = STATE_CTRL_WRITE_SIZE;
 }
 
 void FtpNetworkTransaction::ResetDataConnectionAfterError(State next_state) {
@@ skipping 99 matching lines @@
 
 // Used to prepare and send FTP command.
 int FtpNetworkTransaction::SendFtpCommand(const std::string& command,
                                           const std::string& command_for_log,
                                           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);
 
   net_log_.AddEvent(NetLog::TYPE_FTP_COMMAND_SENT,
                     NetLog::StringCallback("command", &command_for_log));
 
   next_state_ = STATE_CTRL_WRITE;
   return OK;
 }
@@ skipping 204 matching lines @@
         // all future protocols should just use EPSV.
         use_epsv_ = false;
       }
     }
   }
   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_,
-                             write_buf_->BytesRemaining(),
-                             io_callback_);
+  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) {
     // Clear the write buffer.
     write_buf_ = NULL;
@@ skipping 532 matching lines @@
   RecordDataConnectionError(result);
 
   if (result != OK)
     return Stop(result);
 
   next_state_ = state_after_data_connect_complete_;
   return OK;
 }
 
 int FtpNetworkTransaction::DoDataRead() {
-  DCHECK(read_data_buf_);
+  DCHECK(read_data_buf_.get());
   DCHECK_GT(read_data_buf_len_, 0);
 
   if (data_socket_ == NULL || !data_socket_->IsConnected()) {
     // If we don't destroy the data socket completely, some servers will wait
     // for us (http://crbug.com/21127). The half-closed TCP connection needs
     // to be closed on our side too.
     data_socket_.reset();
 
     if (ctrl_socket_->IsConnected()) {
       // Wait for the server's response, we should get it before sending QUIT.
       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