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

media/filters/gpu_video_decoder.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 "media/filters/gpu_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/cpu.h"
 #include "base/message_loop.h"
@@ skipping 154 matching lines @@
       gvd_loop_proxy_(message_loop),
       weak_factory_(this),
       vda_loop_proxy_(factories->GetMessageLoop()),
       factories_(factories),
       state_(kNormal),
       demuxer_read_in_progress_(false),
       decoder_texture_target_(0),
       next_picture_buffer_id_(0),
       next_bitstream_buffer_id_(0),
       available_pictures_(-1) {
-  DCHECK(factories_);
+  DCHECK(factories_.get());
 }
 
 void GpuVideoDecoder::Reset(const base::Closure& closure)  {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
 
   if (state_ == kDrainingDecoder && !factories_->IsAborted()) {
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::Reset, weak_this_, closure));
     // NOTE: if we're deferring Reset() until a Flush() completes, return
     // queued pictures to the VDA so they can be used to finish that Flush().
@@ skipping 71 matching lines @@
   const VideoDecoderConfig& config = stream->video_decoder_config();
   DCHECK(config.IsValidConfig());
   DCHECK(!config.is_encrypted());
 
   if (!IsCodedSizeSupported(config.coded_size())) {
     status_cb.Run(DECODER_ERROR_NOT_SUPPORTED);
     return;
   }
 
   client_proxy_ = new VDAClientProxy(this);
-  VideoDecodeAccelerator* vda =
-      factories_->CreateVideoDecodeAccelerator(config.profile(), client_proxy_);
+  VideoDecodeAccelerator* vda = factories_->CreateVideoDecodeAccelerator(
+      config.profile(), client_proxy_.get());
   if (!vda) {
     status_cb.Run(DECODER_ERROR_NOT_SUPPORTED);
     return;
   }
 
   demuxer_stream_ = stream;
   statistics_cb_ = statistics_cb;
   needs_bitstream_conversion_ = (config.codec() == kCodecH264);
 
   DVLOG(1) << "GpuVideoDecoder::Initialize() succeeded.";
   PostTaskAndReplyWithResult(
-      vda_loop_proxy_, FROM_HERE,
+      vda_loop_proxy_.get(),
+      FROM_HERE,
       base::Bind(&VideoDecodeAccelerator::AsWeakPtr, base::Unretained(vda)),
       base::Bind(&GpuVideoDecoder::SetVDA, weak_this_, status_cb, vda));
 }
 
 void GpuVideoDecoder::SetVDA(
     const PipelineStatusCB& status_cb,
     VideoDecodeAccelerator* vda,
     base::WeakPtr<VideoDecodeAccelerator> weak_vda) {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   DCHECK(!vda_.get());
@@ skipping 76 matching lines @@
 }
 
 bool GpuVideoDecoder::CanMoreDecodeWorkBeDone() {
   return bitstream_buffers_in_decoder_.size() < kMaxInFlightDecodes;
 }
 
 void GpuVideoDecoder::RequestBufferDecode(
     DemuxerStream::Status status,
     const scoped_refptr<DecoderBuffer>& buffer) {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
-  DCHECK_EQ(status != DemuxerStream::kOk, !buffer) << status;
+  DCHECK_EQ(status != DemuxerStream::kOk, !buffer.get()) << status;
 
   demuxer_read_in_progress_ = false;
 
   if (status == DemuxerStream::kAborted) {
     if (pending_read_cb_.is_null())
       return;
     base::ResetAndReturn(&pending_read_cb_).Run(kOk, NULL);
     return;
   }
 
@@ skipping 23 matching lines @@
     return;
 
   memcpy(shm_buffer->shm->memory(), buffer->GetData(), size);
   BitstreamBuffer bitstream_buffer(
       next_bitstream_buffer_id_, shm_buffer->shm->handle(), size);
   // Mask against 30 bits, to avoid (undefined) wraparound on signed integer.
   next_bitstream_buffer_id_ = (next_bitstream_buffer_id_ + 1) & 0x3FFFFFFF;
   bool inserted = bitstream_buffers_in_decoder_.insert(std::make_pair(
       bitstream_buffer.id(), BufferPair(shm_buffer, buffer))).second;
   DCHECK(inserted);
-  RecordBufferData(bitstream_buffer, *buffer);
+  RecordBufferData(bitstream_buffer, *buffer.get());
 
   vda_loop_proxy_->PostTask(FROM_HERE, base::Bind(
       &VideoDecodeAccelerator::Decode, weak_vda_, bitstream_buffer));
 
   if (CanMoreDecodeWorkBeDone()) {
     // Force post here to prevent reentrancy into DemuxerStream.
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::EnsureDemuxOrDecode, weak_this_));
   }
 }
@@ skipping 131 matching lines @@
 
 void GpuVideoDecoder::EnqueueFrameAndTriggerFrameDelivery(
     const scoped_refptr<VideoFrame>& frame) {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
 
   // During a pending vda->Reset(), we don't accumulate frames.  Drop it on the
   // floor and return.
   if (!pending_reset_cb_.is_null())
     return;
 
-  if (frame)
+  if (frame.get())
     ready_video_frames_.push_back(frame);
   else
     DCHECK(!ready_video_frames_.empty());
 
   if (pending_read_cb_.is_null())
     return;
 
   base::ResetAndReturn(&pending_read_cb_).Run(kOk, ready_video_frames_.front());
   ready_video_frames_.pop_front();
 }
@@ skipping 122 matching lines @@
 
   state_ = kError;
 
   if (!pending_read_cb_.is_null()) {
     base::ResetAndReturn(&pending_read_cb_).Run(kDecodeError, NULL);
     return;
   }
 }
 
 }  // namespace media