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

ppapi/proxy/websocket_resource.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 "ppapi/proxy/websocket_resource.h"
 
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 71 matching lines @@
   if (TrackedCallback::IsPending(connect_callback_))
     return PP_ERROR_INPROGRESS;
 
   // Connect() can be called at most once.
   if (state_ != PP_WEBSOCKETREADYSTATE_INVALID)
     return PP_ERROR_INPROGRESS;
   state_ = PP_WEBSOCKETREADYSTATE_CLOSED;
 
   // Get the URL.
   url_ = StringVar::FromPPVar(url);
-  if (!url_)
+  if (!url_.get())
     return PP_ERROR_BADARGUMENT;
 
   // Get the protocols.
   std::set<std::string> protocol_set;
   std::vector<std::string> protocol_strings;
   protocol_strings.reserve(protocol_count);
   for (uint32_t i = 0; i < protocol_count; ++i) {
     scoped_refptr<StringVar> protocol(StringVar::FromPPVar(protocols[i]));
 
     // Check invalid and empty entries.
-    if (!protocol || !protocol->value().length())
+    if (!protocol.get() || !protocol->value().length())
       return PP_ERROR_BADARGUMENT;
 
     // Check duplicated protocol entries.
     if (protocol_set.find(protocol->value()) != protocol_set.end())
       return PP_ERROR_BADARGUMENT;
     protocol_set.insert(protocol->value());
 
     protocol_strings.push_back(protocol->value());
   }
 
@@ skipping 36 matching lines @@
       // RFC 6455 limits applications to use reserved connection close code in
       // section 7.4.2.. The WebSocket API (http://www.w3.org/TR/websockets/)
       // defines this out of range error as InvalidAccessError in JavaScript.
       return PP_ERROR_NOACCESS;
 
     // |reason| must be ignored if it is PP_VARTYPE_UNDEFINED or |code| is
     // PP_WEBSOCKETSTATUSCODE_NOT_SPECIFIED.
     if (reason.type != PP_VARTYPE_UNDEFINED) {
       // Validate |reason|.
       reason_string_var = StringVar::FromPPVar(reason);
-      if (!reason_string_var ||
+      if (!reason_string_var.get() ||
           reason_string_var->value().size() > kMaxReasonSizeInBytes)
         return PP_ERROR_BADARGUMENT;
       reason_string = reason_string_var->value();
     }
   }
 
   // Check state.
   if (state_ == PP_WEBSOCKETREADYSTATE_CLOSING)
     return PP_ERROR_INPROGRESS;
   if (state_ == PP_WEBSOCKETREADYSTATE_CLOSED)
@@ skipping 68 matching lines @@
   if (state_ == PP_WEBSOCKETREADYSTATE_INVALID ||
       state_ == PP_WEBSOCKETREADYSTATE_CONNECTING)
     return PP_ERROR_BADARGUMENT;
 
   if (state_ == PP_WEBSOCKETREADYSTATE_CLOSING ||
       state_ == PP_WEBSOCKETREADYSTATE_CLOSED) {
     // Handle buffered_amount_after_close_.
     uint64_t payload_size = 0;
     if (message.type == PP_VARTYPE_STRING) {
       scoped_refptr<StringVar> message_string = StringVar::FromPPVar(message);
-      if (message_string)
+      if (message_string.get())
         payload_size += message_string->value().length();
     } else if (message.type == PP_VARTYPE_ARRAY_BUFFER) {
       scoped_refptr<ArrayBufferVar> message_array_buffer =
           ArrayBufferVar::FromPPVar(message);
-      if (message_array_buffer)
+      if (message_array_buffer.get())
         payload_size += message_array_buffer->ByteLength();
     } else {
       // TODO(toyoshim): Support Blob.
       return PP_ERROR_NOTSUPPORTED;
     }
 
     buffered_amount_after_close_ =
         SaturateAdd(buffered_amount_after_close_, GetFrameSize(payload_size));
 
     return PP_ERROR_FAILED;
   }
 
   // Send the message.
   if (message.type == PP_VARTYPE_STRING) {
     // Convert message to std::string, then send it.
     scoped_refptr<StringVar> message_string = StringVar::FromPPVar(message);
-    if (!message_string)
+    if (!message_string.get())
       return PP_ERROR_BADARGUMENT;
     Post(RENDERER, PpapiHostMsg_WebSocket_SendText(message_string->value()));
   } else if (message.type == PP_VARTYPE_ARRAY_BUFFER) {
     // Convert message to std::vector<uint8_t>, then send it.
     scoped_refptr<ArrayBufferVar> message_arraybuffer =
         ArrayBufferVar::FromPPVar(message);
-    if (!message_arraybuffer)
+    if (!message_arraybuffer.get())
       return PP_ERROR_BADARGUMENT;
     uint8_t* message_data = static_cast<uint8_t*>(message_arraybuffer->Map());
     uint32 message_length = message_arraybuffer->ByteLength();
     std::vector<uint8_t> message_vector(message_data,
                                         message_data + message_length);
     Post(RENDERER, PpapiHostMsg_WebSocket_SendBinary(message_vector));
   } else {
     // TODO(toyoshim): Support Blob.
     return PP_ERROR_NOTSUPPORTED;
   }
   return PP_OK;
 }
 
 uint64_t WebSocketResource::GetBufferedAmount() {
   return SaturateAdd(buffered_amount_, buffered_amount_after_close_);
 }
 
 uint16_t WebSocketResource::GetCloseCode() {
   return close_code_;
 }
 
 PP_Var WebSocketResource::GetCloseReason() {
-  if (!close_reason_)
+  if (!close_reason_.get())
     return empty_string_->GetPPVar();
   return close_reason_->GetPPVar();
 }
 
 PP_Bool WebSocketResource::GetCloseWasClean() {
   return close_was_clean_;
 }
 
 PP_Var WebSocketResource::GetExtensions() {
   return StringVar::StringToPPVar(std::string());
 }
 
 PP_Var WebSocketResource::GetProtocol() {
-  if (!protocol_)
+  if (!protocol_.get())
     return empty_string_->GetPPVar();
   return protocol_->GetPPVar();
 }
 
 PP_WebSocketReadyState WebSocketResource::GetReadyState() {
   return state_;
 }
 
 PP_Var WebSocketResource::GetURL() {
-  if (!url_)
+  if (!url_.get())
     return empty_string_->GetPPVar();
   return url_->GetPPVar();
 }
 
 void WebSocketResource::OnReplyReceived(
     const ResourceMessageReplyParams& params,
     const IPC::Message& msg) {
   if (params.sequence()) {
     PluginResource::OnReplyReceived(params, msg);
     return;
@@ skipping 138 matching lines @@
     return PP_OK;
 
   *receive_callback_var_ = received_messages_.front()->GetPPVar();
   received_messages_.pop();
   receive_callback_var_ = NULL;
   return PP_OK;
 }
 
 }  // namespace proxy
 }  // namespace ppapi