Remove a scoped_refptr<>::swap overload

media/filters/ffmpeg_audio_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/ffmpeg_audio_decoder.h"
 
 #include <stdint.h>
 
 #include "base/callback_helpers.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 27 matching lines @@
   // When use_system_ffmpeg==1, libav's AVFrame doesn't have channels field.
   return av_get_channel_layout_nb_channels(frame->channel_layout);
 #else
   return frame->channels;
 #endif
 }
 
 // Called by FFmpeg's allocation routine to free a buffer. |opaque| is the
 // AudioBuffer allocated, so unref it.
 static void ReleaseAudioBufferImpl(void* opaque, uint8_t* data) {
-  scoped_refptr<AudioBuffer> buffer;
-  buffer.swap(reinterpret_cast<AudioBuffer**>(&opaque));
+  if (opaque)
+    static_cast<AudioBuffer*>(opaque)->Release();
 }
 
 // Called by FFmpeg's allocation routine to allocate a buffer. Uses
 // AVCodecContext.opaque to get the object reference in order to call
 // GetAudioBuffer() to do the actual allocation.
 static int GetAudioBuffer(struct AVCodecContext* s, AVFrame* frame, int flags) {
   DCHECK(s->codec->capabilities & CODEC_CAP_DR1);
   DCHECK_EQ(s->codec_type, AVMEDIA_TYPE_AUDIO);
 
   // Since this routine is called by FFmpeg when a buffer is required for audio
@@ skipping 57 matching lines @@
         av_malloc(number_of_planes * sizeof(*frame->extended_data)));
     int i = 0;
     for (; i < AV_NUM_DATA_POINTERS; ++i)
       frame->extended_data[i] = frame->data[i] = buffer->channel_data()[i];
     for (; i < number_of_planes; ++i)
       frame->extended_data[i] = buffer->channel_data()[i];
   }
 
   // Now create an AVBufferRef for the data just allocated. It will own the
   // reference to the AudioBuffer object.
-  void* opaque = NULL;
-  buffer.swap(reinterpret_cast<AudioBuffer**>(&opaque));
+  AudioBuffer* opaque = buffer.get();
+  opaque->AddRef();

[xhwang, 2017/03/03 18:36:08]

This is hard to read (not saying it's worse than before :) )...

Is there any plan to improve the API on this kind of use case?

[dcheng, 2017/03/03 18:45:19]

Eh... this seems Good Enough (tm) for the use case where we have to leak a ref
to C. I'm not really sure what else we could use here: I guess we could have
LeakRef() on scoped_refptr, but if we don't need it, it might be best to avoid.

   frame->buf[0] = av_buffer_create(
       frame->data[0], buffer_size_in_bytes, ReleaseAudioBufferImpl, opaque, 0);
   return 0;
 }
 
 FFmpegAudioDecoder::FFmpegAudioDecoder(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     const scoped_refptr<MediaLog>& media_log)
     : task_runner_(task_runner),
       state_(kUninitialized),
@@ skipping 296 matching lines @@
   // Opus codec delay is handled by ffmpeg.
   const int codec_delay =
       config_.codec() == kCodecOpus ? 0 : config_.codec_delay();
   discard_helper_.reset(
       new AudioDiscardHelper(config_.samples_per_second(), codec_delay,
                              config_.codec() == kCodecVorbis));
   discard_helper_->Reset(codec_delay);
 }
 
 }  // namespace media