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

chrome/test/chromedriver/net/websocket.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 "chrome/test/chromedriver/net/websocket.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 110 matching lines @@
 
 void WebSocket::ContinueWritingIfNecessary() {
   if (!write_buffer_->BytesRemaining()) {
     if (pending_write_.empty())
       return;
     write_buffer_ = new net::DrainableIOBuffer(
         new net::StringIOBuffer(pending_write_),
         pending_write_.length());
     pending_write_.clear();
   }
-  int code = socket_->Write(
-      write_buffer_,
-      write_buffer_->BytesRemaining(),
-      base::Bind(&WebSocket::OnWrite, base::Unretained(this)));
+  int code =
+      socket_->Write(write_buffer_.get(),
+                     write_buffer_->BytesRemaining(),
+                     base::Bind(&WebSocket::OnWrite, base::Unretained(this)));
   if (code != net::ERR_IO_PENDING)
     OnWrite(code);
 }
 
 void WebSocket::Read() {
-  int code = socket_->Read(
-      read_buffer_,
-      read_buffer_->size(),
-      base::Bind(&WebSocket::OnRead, base::Unretained(this)));
+  int code =
+      socket_->Read(read_buffer_.get(),
+                    read_buffer_->size(),
+                    base::Bind(&WebSocket::OnRead, base::Unretained(this)));
   if (code != net::ERR_IO_PENDING)
     OnRead(code);
 }
 
 void WebSocket::OnRead(int code) {
   if (code <= 0) {
     Close(code ? code : net::ERR_FAILED);
     return;
   }
 
@@ skipping 35 matching lines @@
   InvokeConnectCallback(net::OK);
   if (!leftover_message.empty())
     OnReadDuringOpen(leftover_message.c_str(), leftover_message.length());
 }
 
 void WebSocket::OnReadDuringOpen(const char* data, int len) {
   ScopedVector<net::WebSocketFrameChunk> frame_chunks;
   CHECK(parser_.Decode(data, len, &frame_chunks));
   for (size_t i = 0; i < frame_chunks.size(); ++i) {
     scoped_refptr<net::IOBufferWithSize> buffer = frame_chunks[i]->data;
-    if (buffer)
+    if (buffer.get())
       next_message_ += std::string(buffer->data(), buffer->size());
     if (frame_chunks[i]->final_chunk) {
       listener_->OnMessageReceived(next_message_);
       next_message_.clear();
     }
   }
 }
 
 void WebSocket::InvokeConnectCallback(int code) {
   net::CompletionCallback temp = connect_callback_;
   connect_callback_.Reset();
   CHECK(!temp.is_null());
   temp.Run(code);
 }
 
 void WebSocket::Close(int code) {
   socket_->Disconnect();
   if (!connect_callback_.is_null())
     InvokeConnectCallback(code);
   if (state_ == OPEN)
     listener_->OnClose();
 
   state_ = CLOSED;
 }