Remove implicit conversions from scoped_refptr to T* in media/

media/filters/vpx_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/vpx_video_decoder.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 249 matching lines @@
   if (!vpx_codec_)
     return false;
 
   // We use our own buffers for VP9 so that there is no need to copy data after
   // decoding.
   if (config.codec() == kCodecVP9) {
     memory_pool_ = new MemoryPool();
     if (vpx_codec_set_frame_buffer_functions(vpx_codec_,
                                              &MemoryPool::GetVP9FrameBuffer,
                                              &MemoryPool::ReleaseVP9FrameBuffer,
-                                             memory_pool_)) {
+                                             memory_pool_.get())) {

[ddorwin, 2014/08/25 21:26:40]

This parameter is "Callback's private data".
I didn't verify that the member outlives this use.

[dcheng, 2014/08/25 21:33:25]

It's worth noting this was already using the implicit conversion operator
before. Making this explicit doesn't make it any less memory-safe--the code in
question must be keeping it alive some other way, or this is an error (since the
callback parameter is a void*).

[Tom Finegan, 2014/08/26 00:26:11]

caveat: I did not write or review this part of VpxVideoDecoder, but...

Libvpx is the one using that void* for the static methods in VpxVideoDecoder's
MemoryPool class. VpxVideoDecoder is holding the reference for libvpx because
libvpx doesn't know anything about scoped_refptrs. VpxVideoDecoder is nulling it
out in CloseDecoder()(thus releasing the reference), but only after libvpx has
been shut down. This should be safe because after that point libvpx will no
longer be alive to call GetVP9FrameBuffer() or ReleaseVP9FrameBuffer().

Assuming that's what you're asking, anyway.

       LOG(ERROR) << "Failed to configure external buffers.";
       return false;
     }
   }
 
   if (config.format() == VideoFrame::YV12A) {
     vpx_codec_alpha_ = InitializeVpxContext(vpx_codec_alpha_, config);
     if (!vpx_codec_alpha_)
       return false;
   }
@@ skipping 45 matching lines @@
   state_ = kNormal;
   task_runner_->PostTask(FROM_HERE, closure);
 }
 
 void VpxVideoDecoder::DecodeBuffer(const scoped_refptr<DecoderBuffer>& buffer) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_NE(state_, kUninitialized);
   DCHECK_NE(state_, kDecodeFinished);
   DCHECK_NE(state_, kError);
   DCHECK(!decode_cb_.is_null());
-  DCHECK(buffer);
+  DCHECK(buffer.get());
 
   // Transition to kDecodeFinished on the first end of stream buffer.
   if (state_ == kNormal && buffer->end_of_stream()) {
     state_ = kDecodeFinished;
     base::ResetAndReturn(&decode_cb_).Run(kOk);
     return;
   }
 
   scoped_refptr<VideoFrame> video_frame;
   if (!VpxDecode(buffer, &video_frame)) {
     state_ = kError;
     base::ResetAndReturn(&decode_cb_).Run(kDecodeError);
     return;
   }
 
   base::ResetAndReturn(&decode_cb_).Run(kOk);
 
-  if (video_frame)
+  if (video_frame.get())
     output_cb_.Run(video_frame);
 }
 
 bool VpxVideoDecoder::VpxDecode(const scoped_refptr<DecoderBuffer>& buffer,
                                 scoped_refptr<VideoFrame>* video_frame) {
   DCHECK(video_frame);
   DCHECK(!buffer->end_of_stream());
 
   // Pass |buffer| to libvpx.
   int64 timestamp = buffer->timestamp().InMicroseconds();
@@ skipping 77 matching lines @@
   if (vpx_image->fmt == VPX_IMG_FMT_I444) {
     CHECK(!vpx_codec_alpha_);
     codec_format = VideoFrame::YV24;
     uv_rows = vpx_image->d_h;
   } else if (vpx_codec_alpha_) {
     codec_format = VideoFrame::YV12A;
   }
 
   gfx::Size size(vpx_image->d_w, vpx_image->d_h);
 
-  if (!vpx_codec_alpha_ && memory_pool_) {
+  if (!vpx_codec_alpha_ && memory_pool_.get()) {
     *video_frame = VideoFrame::WrapExternalYuvData(
         codec_format,
         size, gfx::Rect(size), config_.natural_size(),
         vpx_image->stride[VPX_PLANE_Y],
         vpx_image->stride[VPX_PLANE_U],
         vpx_image->stride[VPX_PLANE_V],
         vpx_image->planes[VPX_PLANE_Y],
         vpx_image->planes[VPX_PLANE_U],
         vpx_image->planes[VPX_PLANE_V],
         kNoTimestamp(),
@@ skipping 27 matching lines @@
         vpx_image->stride[VPX_PLANE_Y], vpx_image->d_h, video_frame->get());
     return;
   }
   CopyAPlane(vpx_image_alpha->planes[VPX_PLANE_Y],
              vpx_image->stride[VPX_PLANE_Y],
              vpx_image->d_h,
              video_frame->get());
 }
 
 }  // namespace media