Remove implicit conversions from scoped_refptr to T* in ppapi/

ppapi/proxy/video_decoder_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/video_decoder_resource.h"
 
 #include "base/bind.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/common/mailbox.h"
@@ skipping 89 matching lines @@
 
 int32_t VideoDecoderResource::Initialize(
     PP_Resource graphics_context,
     PP_VideoProfile profile,
     PP_HardwareAcceleration acceleration,
     scoped_refptr<TrackedCallback> callback) {
   if (initialized_)
     return PP_ERROR_FAILED;
   if (profile < 0 || profile > PP_VIDEOPROFILE_MAX)
     return PP_ERROR_BADARGUMENT;
-  if (initialize_callback_)
+  if (initialize_callback_.get())
     return PP_ERROR_INPROGRESS;
   if (!graphics_context)
     return PP_ERROR_BADRESOURCE;
 
   HostResource host_resource;
   if (!testing_) {
     // Create a new Graphics3D resource that can create texture resources to
     // share with the plugin. We can't use the plugin's Graphics3D, since we
     // create textures on a proxy thread, and would interfere with the plugin.
     thunk::EnterResourceCreationNoLock enter_create(pp_instance());
@@ skipping 25 matching lines @@
 
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t VideoDecoderResource::Decode(uint32_t decode_id,
                                      uint32_t size,
                                      const void* buffer,
                                      scoped_refptr<TrackedCallback> callback) {
   if (decoder_last_error_)
     return decoder_last_error_;
-  if (flush_callback_ || reset_callback_)
+  if (flush_callback_.get() || reset_callback_.get())
     return PP_ERROR_FAILED;
-  if (decode_callback_)
+  if (decode_callback_.get())
     return PP_ERROR_INPROGRESS;
   if (size > kMaximumBitstreamBufferSize)
     return PP_ERROR_NOMEMORY;
 
   // If we allow the plugin to call Decode again, we must have somewhere to
   // copy their buffer.
   DCHECK(!available_shm_buffers_.empty() ||
          shm_buffers_.size() < kMaximumPendingDecodes);
 
   // Count up, wrapping back to 0 before overflowing.
@@ skipping 78 matching lines @@
   // buffer is available.
   decode_callback_ = callback;
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t VideoDecoderResource::GetPicture(
     PP_VideoPicture* picture,
     scoped_refptr<TrackedCallback> callback) {
   if (decoder_last_error_)
     return decoder_last_error_;
-  if (reset_callback_)
+  if (reset_callback_.get())
     return PP_ERROR_FAILED;
-  if (get_picture_callback_)
+  if (get_picture_callback_.get())
     return PP_ERROR_INPROGRESS;
 
   // If the next picture is ready, return it synchronously.
   if (!received_pictures_.empty()) {
     WriteNextPicture(picture);
     return PP_OK;
   }
 
   get_picture_callback_ = callback;
   get_picture_ = picture;
   return PP_OK_COMPLETIONPENDING;
 }
 
 void VideoDecoderResource::RecyclePicture(const PP_VideoPicture* picture) {
   if (decoder_last_error_)
     return;
 
   Post(RENDERER, PpapiHostMsg_VideoDecoder_RecyclePicture(picture->texture_id));
 }
 
 int32_t VideoDecoderResource::Flush(scoped_refptr<TrackedCallback> callback) {
   if (decoder_last_error_)
     return decoder_last_error_;
-  if (reset_callback_)
+  if (reset_callback_.get())
     return PP_ERROR_FAILED;
-  if (flush_callback_)
+  if (flush_callback_.get())
     return PP_ERROR_INPROGRESS;
   flush_callback_ = callback;
 
   Call<PpapiPluginMsg_VideoDecoder_FlushReply>(
       RENDERER,
       PpapiHostMsg_VideoDecoder_Flush(),
       base::Bind(&VideoDecoderResource::OnPluginMsgFlushComplete, this));
 
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t VideoDecoderResource::Reset(scoped_refptr<TrackedCallback> callback) {
   if (decoder_last_error_)
     return decoder_last_error_;
-  if (flush_callback_)
+  if (flush_callback_.get())
     return PP_ERROR_FAILED;
-  if (reset_callback_)
+  if (reset_callback_.get())
     return PP_ERROR_INPROGRESS;
   reset_callback_ = callback;
 
   // Cause any pending Decode or GetPicture callbacks to abort after we return,
   // to avoid reentering the plugin.
   if (TrackedCallback::IsPending(decode_callback_))
     decode_callback_->PostAbort();
   decode_callback_ = NULL;
   if (TrackedCallback::IsPending(get_picture_callback_))
     get_picture_callback_->PostAbort();
@@ skipping 135 matching lines @@
 void VideoDecoderResource::OnPluginMsgDecodeComplete(
     const ResourceMessageReplyParams& params,
     uint32_t shm_id) {
   if (shm_id >= shm_buffers_.size()) {
     NOTREACHED();
     return;
   }
   // Make the shm buffer available.
   available_shm_buffers_.push_back(shm_buffers_[shm_id]);
   // If the plugin is waiting, let it call Decode again.
-  if (decode_callback_) {
+  if (decode_callback_.get()) {
     scoped_refptr<TrackedCallback> callback;
     callback.swap(decode_callback_);
     callback->Run(PP_OK);
   }
 }
 
 void VideoDecoderResource::OnPluginMsgFlushComplete(
     const ResourceMessageReplyParams& params) {
   // All shm buffers should have been made available by now.
   DCHECK_EQ(shm_buffers_.size(), available_shm_buffers_.size());
 
-  if (get_picture_callback_) {
+  if (get_picture_callback_.get()) {
     scoped_refptr<TrackedCallback> callback;
     callback.swap(get_picture_callback_);
     callback->Abort();
   }
 
   scoped_refptr<TrackedCallback> callback;
   callback.swap(flush_callback_);
   callback->Run(params.result());
 }
 
@@ skipping 41 matching lines @@
     pp_picture->texture_target = it->second.texture_target;
     pp_picture->texture_size = it->second.size;
   } else {
     NOTREACHED();
   }
   received_pictures_.pop();
 }
 
 }  // namespace proxy
 }  // namespace ppapi