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

Linux fixes

BUG=110610
TBR=darin

Review URL: https://chromiumcodereview.appspot.com/15782010

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@203573 0039d316-1c4b-4281-b951-d872f2087c98

8 files changed, 32 insertions, 25 deletions

diff --git a/jingle/glue/channel_socket_adapter.cc b/jingle/glue/channel_socket_adapter.cc
index 72b45a3..ad61ef7 100644
--- a/jingle/glue/channel_socket_adapter.cc
+++ b/jingle/glue/channel_socket_adapter.cc
@@ -143,7 +143,7 @@ void TransportChannelSocketAdapter::OnNewPacket(
   DCHECK_EQ(base::MessageLoop::current(), message_loop_);
   DCHECK_EQ(channel, channel_);
   if (!read_callback_.is_null()) {
-    DCHECK(read_buffer_);
+    DCHECK(read_buffer_.get());
     CHECK_LT(data_size, static_cast<size_t>(std::numeric_limits<int>::max()));
 
     if (read_buffer_size_ < static_cast<int>(data_size)) {
diff --git a/jingle/glue/channel_socket_adapter_unittest.cc b/jingle/glue/channel_socket_adapter_unittest.cc
index a71b372..53ace60 100644
--- a/jingle/glue/channel_socket_adapter_unittest.cc
+++ b/jingle/glue/channel_socket_adapter_unittest.cc
@@ -68,7 +68,7 @@ class TransportChannelSocketAdapterTest : public testing::Test {
 TEST_F(TransportChannelSocketAdapterTest, Read) {
   scoped_refptr<IOBuffer> buffer(new IOBuffer(kBufferSize));
 
-  int result = target_->Read(buffer, kBufferSize, callback_);
+  int result = target_->Read(buffer.get(), kBufferSize, callback_);
   ASSERT_EQ(net::ERR_IO_PENDING, result);
 
   channel_.SignalReadPacket(&channel_, kTestData, kTestDataSize, 0);
@@ -79,14 +79,14 @@ TEST_F(TransportChannelSocketAdapterTest, Read) {
 TEST_F(TransportChannelSocketAdapterTest, ReadClose) {
   scoped_refptr<IOBuffer> buffer(new IOBuffer(kBufferSize));
 
-  int result = target_->Read(buffer, kBufferSize, callback_);
+  int result = target_->Read(buffer.get(), kBufferSize, callback_);
   ASSERT_EQ(net::ERR_IO_PENDING, result);
 
   target_->Close(kTestError);
   EXPECT_EQ(kTestError, callback_result_);
 
   // All Read() calls after Close() should return the error.
-  EXPECT_EQ(kTestError, target_->Read(buffer, kBufferSize, callback_));
+  EXPECT_EQ(kTestError, target_->Read(buffer.get(), kBufferSize, callback_));
 }
 
 // Verify that Write sends the packet and returns correct result.
@@ -96,7 +96,7 @@ TEST_F(TransportChannelSocketAdapterTest, Write) {
   EXPECT_CALL(channel_, SendPacket(buffer->data(), kTestDataSize, 0))
       .WillOnce(Return(kTestDataSize));
 
-  int result = target_->Write(buffer, kTestDataSize, callback_);
+  int result = target_->Write(buffer.get(), kTestDataSize, callback_);
   EXPECT_EQ(kTestDataSize, result);
 }
 
@@ -112,7 +112,7 @@ TEST_F(TransportChannelSocketAdapterTest, WritePending) {
   EXPECT_CALL(channel_, GetError())
       .WillOnce(Return(EWOULDBLOCK));
 
-  int result = target_->Write(buffer, kTestDataSize, callback_);
+  int result = target_->Write(buffer.get(), kTestDataSize, callback_);
   ASSERT_EQ(net::OK, result);
 }
 
diff --git a/jingle/glue/fake_socket_factory.cc b/jingle/glue/fake_socket_factory.cc
index 325497a..1559c32 100644
--- a/jingle/glue/fake_socket_factory.cc
+++ b/jingle/glue/fake_socket_factory.cc
@@ -171,7 +171,7 @@ talk_base::AsyncPacketSocket* FakeSocketFactory::CreateUdpSocket(
   CHECK_EQ(min_port, 0);
   CHECK_EQ(max_port, 0);
   return new FakeUDPPacketSocket(
-      socket_manager_, net::IPEndPoint(address_, ++last_allocated_port_));
+      socket_manager_.get(), net::IPEndPoint(address_, ++last_allocated_port_));
 }
 
 talk_base::AsyncPacketSocket* FakeSocketFactory::CreateServerTcpSocket(
diff --git a/jingle/glue/fake_ssl_client_socket.cc b/jingle/glue/fake_ssl_client_socket.cc
index 4817ce9..bf6d12a 100644
--- a/jingle/glue/fake_ssl_client_socket.cc
+++ b/jingle/glue/fake_ssl_client_socket.cc
@@ -200,7 +200,8 @@ void FakeSSLClientSocket::ProcessConnectDone() {
 
 int FakeSSLClientSocket::DoSendClientHello() {
   int status = transport_socket_->Write(
-      write_buf_, write_buf_->BytesRemaining(),
+      write_buf_.get(),
+      write_buf_->BytesRemaining(),
       base::Bind(&FakeSSLClientSocket::OnSendClientHelloDone,
                  base::Unretained(this)));
   if (status < net::OK) {
@@ -234,7 +235,8 @@ void FakeSSLClientSocket::ProcessSendClientHelloDone(size_t written) {
 
 int FakeSSLClientSocket::DoVerifyServerHello() {
   int status = transport_socket_->Read(
-      read_buf_, read_buf_->BytesRemaining(),
+      read_buf_.get(),
+      read_buf_->BytesRemaining(),
       base::Bind(&FakeSSLClientSocket::OnVerifyServerHelloDone,
                  base::Unretained(this)));
   if (status < net::OK) {
diff --git a/jingle/glue/fake_ssl_client_socket_unittest.cc b/jingle/glue/fake_ssl_client_socket_unittest.cc
index 6b87a17..b49bf0d 100644
--- a/jingle/glue/fake_ssl_client_socket_unittest.cc
+++ b/jingle/glue/fake_ssl_client_socket_unittest.cc
@@ -164,14 +164,15 @@ class FakeSSLClientSocketTest : public testing::Test {
         scoped_refptr<net::IOBuffer> read_buf(
             new net::IOBuffer(read_buf_len));
         int read_status = fake_ssl_client_socket.Read(
-            read_buf, read_buf_len, test_completion_callback.callback());
+            read_buf.get(), read_buf_len, test_completion_callback.callback());
         ExpectStatus(mode, read_len, read_status, &test_completion_callback);
 
         scoped_refptr<net::IOBuffer> write_buf(
             new net::StringIOBuffer(kWriteTestData));
-        int write_status = fake_ssl_client_socket.Write(
-            write_buf, arraysize(kWriteTestData),
-            test_completion_callback.callback());
+        int write_status =
+            fake_ssl_client_socket.Write(write_buf.get(),
+                                         arraysize(kWriteTestData),
+                                         test_completion_callback.callback());
         ExpectStatus(mode, arraysize(kWriteTestData), write_status,
                      &test_completion_callback);
       } else {
diff --git a/jingle/glue/proxy_resolving_client_socket.cc b/jingle/glue/proxy_resolving_client_socket.cc
index ce922f3..23ad12d 100644
--- a/jingle/glue/proxy_resolving_client_socket.cc
+++ b/jingle/glue/proxy_resolving_client_socket.cc
@@ -42,7 +42,7 @@ ProxyResolvingClientSocket::ProxyResolvingClientSocket(
                   request_context_getter->GetURLRequestContext()->net_log(),
                   net::NetLog::SOURCE_SOCKET)),
           weak_factory_(this) {
-  DCHECK(request_context_getter);
+  DCHECK(request_context_getter.get());
   net::URLRequestContext* request_context =
       request_context_getter->GetURLRequestContext();
   DCHECK(request_context);
diff --git a/jingle/glue/pseudotcp_adapter.cc b/jingle/glue/pseudotcp_adapter.cc
index a2da2ae..484ed2e 100644
--- a/jingle/glue/pseudotcp_adapter.cc
+++ b/jingle/glue/pseudotcp_adapter.cc
@@ -360,9 +360,10 @@ cricket::IPseudoTcpNotify::WriteResult PseudoTcpAdapter::Core::TcpWritePacket(
   // send exactly as many bytes as we requested, or fail.
   int result;
   if (socket_.get()) {
-    result = socket_->Write(write_buffer, len,
-                            base::Bind(&PseudoTcpAdapter::Core::OnWritten,
-                                       base::Unretained(this)));
+    result = socket_->Write(
+        write_buffer.get(),
+        len,
+        base::Bind(&PseudoTcpAdapter::Core::OnWritten, base::Unretained(this)));
   } else {
     result = net::ERR_CONNECTION_CLOSED;
   }
@@ -379,14 +380,15 @@ cricket::IPseudoTcpNotify::WriteResult PseudoTcpAdapter::Core::TcpWritePacket(
 }
 
 void PseudoTcpAdapter::Core::DoReadFromSocket() {
-  if (!socket_read_buffer_)
+  if (!socket_read_buffer_.get())
     socket_read_buffer_ = new net::IOBuffer(kReadBufferSize);
 
   int result = 1;
   while (socket_.get() && result > 0) {
-    result = socket_->Read(socket_read_buffer_, kReadBufferSize,
-                           base::Bind(&PseudoTcpAdapter::Core::OnRead,
-                                      base::Unretained(this)));
+    result = socket_->Read(
+        socket_read_buffer_.get(),
+        kReadBufferSize,
+        base::Bind(&PseudoTcpAdapter::Core::OnRead, base::Unretained(this)));
     if (result != net::ERR_IO_PENDING)
       HandleReadResults(result);
   }
diff --git a/jingle/glue/pseudotcp_adapter_unittest.cc b/jingle/glue/pseudotcp_adapter_unittest.cc
index f7bcf4e..08e59fc 100644
--- a/jingle/glue/pseudotcp_adapter_unittest.cc
+++ b/jingle/glue/pseudotcp_adapter_unittest.cc
@@ -231,7 +231,8 @@ class TCPChannelTester : public base::RefCountedThreadSafe<TCPChannelTester> {
       int bytes_to_write = std::min(output_buffer_->BytesRemaining(),
                                     kMessageSize);
       result = client_socket_->Write(
-          output_buffer_, bytes_to_write,
+          output_buffer_.get(),
+          bytes_to_write,
           base::Bind(&TCPChannelTester::OnWritten, base::Unretained(this)));
       HandleWriteResult(result);
     }
@@ -257,9 +258,10 @@ class TCPChannelTester : public base::RefCountedThreadSafe<TCPChannelTester> {
     while (result > 0) {
       input_buffer_->set_offset(input_buffer_->capacity() - kMessageSize);
 
-      result = host_socket_->Read(input_buffer_, kMessageSize,
-                                  base::Bind(&TCPChannelTester::OnRead,
-                                             base::Unretained(this)));
+      result = host_socket_->Read(
+          input_buffer_.get(),
+          kMessageSize,
+          base::Bind(&TCPChannelTester::OnRead, base::Unretained(this)));
       HandleReadResult(result);
     };
   }