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

remoting/protocol/ssl_hmac_channel_authenticator.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/ssl_hmac_channel_authenticator.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "crypto/secure_util.h"
 #include "net/base/host_port_pair.h"
@@ skipping 47 matching lines @@
   DCHECK(CalledOnValidThread());
   DCHECK(socket->IsConnected());
 
   done_callback_ = done_callback;
 
   int result;
   if (is_ssl_server()) {
     scoped_refptr<net::X509Certificate> cert =
         net::X509Certificate::CreateFromBytes(
             local_cert_.data(), local_cert_.length());
-    if (!cert) {
+    if (!cert.get()) {
       LOG(ERROR) << "Failed to parse X509Certificate";
       NotifyError(net::ERR_FAILED);
       return;
     }
 
     net::SSLConfig ssl_config;
-    net::SSLServerSocket* server_socket = net::CreateSSLServerSocket(
-        socket.release(), cert, local_key_pair_->private_key(), ssl_config);
+    net::SSLServerSocket* server_socket =
+        net::CreateSSLServerSocket(socket.release(),
+                                   cert.get(),
+                                   local_key_pair_->private_key(),
+                                   ssl_config);
     socket_.reset(server_socket);
 
     result = server_socket->Handshake(base::Bind(
         &SslHmacChannelAuthenticator::OnConnected, base::Unretained(this)));
   } else {
     cert_verifier_.reset(net::CertVerifier::CreateDefault());
 
     net::SSLConfig::CertAndStatus cert_and_status;
     cert_and_status.cert_status = net::CERT_STATUS_AUTHORITY_INVALID;
     cert_and_status.der_cert = remote_cert_;
@@ skipping 59 matching lines @@
   bool callback_called = false;
   WriteAuthenticationBytes(&callback_called);
   if (!callback_called)
     ReadAuthenticationBytes();
 }
 
 void SslHmacChannelAuthenticator::WriteAuthenticationBytes(
     bool* callback_called) {
   while (true) {
     int result = socket_->Write(
-        auth_write_buf_, auth_write_buf_->BytesRemaining(),
+        auth_write_buf_.get(),
+        auth_write_buf_->BytesRemaining(),
         base::Bind(&SslHmacChannelAuthenticator::OnAuthBytesWritten,
                    base::Unretained(this)));
     if (result == net::ERR_IO_PENDING)
       break;
     if (!HandleAuthBytesWritten(result, callback_called))
       break;
   }
 }
 
 void SslHmacChannelAuthenticator::OnAuthBytesWritten(int result) {
@@ skipping 17 matching lines @@
   if (auth_write_buf_->BytesRemaining() > 0)
     return true;
 
   auth_write_buf_ = NULL;
   CheckDone(callback_called);
   return false;
 }
 
 void SslHmacChannelAuthenticator::ReadAuthenticationBytes() {
   while (true) {
-    int result = socket_->Read(
-        auth_read_buf_,
-        auth_read_buf_->RemainingCapacity(),
-        base::Bind(&SslHmacChannelAuthenticator::OnAuthBytesRead,
-                   base::Unretained(this)));
+    int result =
+        socket_->Read(auth_read_buf_.get(),
+                      auth_read_buf_->RemainingCapacity(),
+                      base::Bind(&SslHmacChannelAuthenticator::OnAuthBytesRead,
+                                 base::Unretained(this)));
     if (result == net::ERR_IO_PENDING)
       break;
     if (!HandleAuthBytesRead(result))
       break;
   }
 }
 
 void SslHmacChannelAuthenticator::OnAuthBytesRead(int result) {
   DCHECK(CalledOnValidThread());
 
@@ skipping 33 matching lines @@
       socket_.get(), is_ssl_server() ?
       kClientAuthSslExporterLabel : kHostAuthSslExporterLabel, auth_key_);
   if (auth_bytes.empty())
     return false;
 
   return crypto::SecureMemEqual(received_auth_bytes.data(),
                                 &(auth_bytes[0]), kAuthDigestLength);
 }
 
 void SslHmacChannelAuthenticator::CheckDone(bool* callback_called) {
-  if (auth_write_buf_ == NULL && auth_read_buf_ == NULL) {
+  if (auth_write_buf_.get() == NULL && auth_read_buf_.get() == NULL) {
     DCHECK(socket_.get() != NULL);
     if (callback_called)
       *callback_called = true;
     done_callback_.Run(net::OK, socket_.PassAs<net::StreamSocket>());
   }
 }
 
 void SslHmacChannelAuthenticator::NotifyError(int error) {
   done_callback_.Run(static_cast<net::Error>(error),
                      scoped_ptr<net::StreamSocket>(NULL));
 }
 
 }  // namespace protocol
 }  // namespace remoting