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

remoting/protocol/connection_tester.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 "remoting/protocol/connection_tester.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ skipping 56 matching lines @@
 
 void StreamConnectionTester::DoWrite() {
   int result = 1;
   while (result > 0) {
     if (output_buffer_->BytesRemaining() == 0)
       break;
 
     int bytes_to_write = std::min(output_buffer_->BytesRemaining(),
                                   message_size_);
     result = client_socket_->Write(
-        output_buffer_, bytes_to_write,
+        output_buffer_.get(),
+        bytes_to_write,
         base::Bind(&StreamConnectionTester::OnWritten, base::Unretained(this)));
     HandleWriteResult(result);
   }
 }
 
 void StreamConnectionTester::OnWritten(int result) {
   HandleWriteResult(result);
   DoWrite();
 }
 
 void StreamConnectionTester::HandleWriteResult(int result) {
   if (result <= 0 && result != net::ERR_IO_PENDING) {
     LOG(ERROR) << "Received error " << result << " when trying to write";
     write_errors_++;
     Done();
   } else if (result > 0) {
     output_buffer_->DidConsume(result);
   }
 }
 
 void StreamConnectionTester::DoRead() {
   int result = 1;
   while (result > 0) {
     input_buffer_->SetCapacity(input_buffer_->offset() + message_size_);
     result = host_socket_->Read(
-        input_buffer_, message_size_,
+        input_buffer_.get(),
+        message_size_,
         base::Bind(&StreamConnectionTester::OnRead, base::Unretained(this)));
     HandleReadResult(result);
   };
 }
 
 void StreamConnectionTester::OnRead(int result) {
   HandleReadResult(result);
   if (!done_)
     DoRead();  // Don't try to read again when we are done reading.
 }
@@ skipping 64 matching lines @@
 
   scoped_refptr<net::IOBuffer> packet(new net::IOBuffer(message_size_));
   for (int i = 0; i < message_size_; ++i) {
     packet->data()[i] = static_cast<char>(i);
   }
   sent_packets_[packets_sent_] = packet;
   // Put index of this packet in the beginning of the packet body.
   memcpy(packet->data(), &packets_sent_, sizeof(packets_sent_));
 
   int result = client_socket_->Write(
-      packet, message_size_,
+      packet.get(),
+      message_size_,
       base::Bind(&DatagramConnectionTester::OnWritten, base::Unretained(this)));
   HandleWriteResult(result);
 }
 
 void DatagramConnectionTester::OnWritten(int result) {
   HandleWriteResult(result);
 }
 
 void DatagramConnectionTester::HandleWriteResult(int result) {
   if (result <= 0 && result != net::ERR_IO_PENDING) {
@@ skipping 10 matching lines @@
   }
 }
 
 void DatagramConnectionTester::DoRead() {
   int result = 1;
   while (result > 0) {
     int kReadSize = message_size_ * 2;
     read_buffer_ = new net::IOBuffer(kReadSize);
 
     result = host_socket_->Read(
-        read_buffer_, kReadSize,
+        read_buffer_.get(),
+        kReadSize,
         base::Bind(&DatagramConnectionTester::OnRead, base::Unretained(this)));
     HandleReadResult(result);
   };
 }
 
 void DatagramConnectionTester::OnRead(int result) {
   HandleReadResult(result);
   DoRead();
 }
 
@@ skipping 18 matching lines @@
         if (memcmp(read_buffer_->data(), sent_packets_[packet_id]->data(),
                    message_size_) != 0)
           bad_packets_received_++;
       }
     }
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting