Take advantage of the new Pass() machinery on scoped_ptr{,_malloc}.

media/filters/ffmpeg_demuxer.cc

 // Copyright (c) 2011 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 "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "media/base/data_buffer.h"
 #include "media/base/limits.h"
 #include "media/base/media_switches.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/filters/bitstream_converter.h"
 #include "media/filters/ffmpeg_demuxer.h"
 #include "media/filters/ffmpeg_glue.h"
 #include "media/filters/ffmpeg_h264_bitstream_converter.h"
 
 namespace media {
 
 //
 // AVPacketBuffer
 //
 class AVPacketBuffer : public Buffer {
  public:
-  AVPacketBuffer(AVPacket* packet, const base::TimeDelta& timestamp,
+  AVPacketBuffer(scoped_ptr_malloc<AVPacket, ScopedPtrAVFreePacket> packet,
+                 const base::TimeDelta& timestamp,
                  const base::TimeDelta& duration)
-      : packet_(packet) {
+      : packet_(packet.Pass()) {
     SetTimestamp(timestamp);
     SetDuration(duration);
   }
 
   virtual ~AVPacketBuffer() {
   }
 
   // Buffer implementation.
   virtual const uint8* GetData() const {
     return reinterpret_cast<const uint8*>(packet_->data);
@@ skipping 49 matching lines @@
 }
 
 bool FFmpegDemuxerStream::HasPendingReads() {
   DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
   base::AutoLock auto_lock(lock_);
   DCHECK(!stopped_ || read_queue_.empty())
       << "Read queue should have been emptied if demuxing stream is stopped";
   return !read_queue_.empty();
 }
 
-void FFmpegDemuxerStream::EnqueuePacket(AVPacket* packet) {
+void FFmpegDemuxerStream::EnqueuePacket(
+    scoped_ptr_malloc<AVPacket, ScopedPtrAVFreePacket> packet) {
   DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
   base::TimeDelta timestamp =
       ConvertStreamTimestamp(stream_->time_base, packet->pts);
   base::TimeDelta duration =
       ConvertStreamTimestamp(stream_->time_base, packet->duration);
 
   base::AutoLock auto_lock(lock_);
   if (stopped_) {
     NOTREACHED() << "Attempted to enqueue packet on a stopped stream";
     return;
   }
 
   // Convert if the packet if there is bitstream filter.
   if (packet->data && bitstream_converter_.get() &&
-      !bitstream_converter_->ConvertPacket(packet)) {
+      !bitstream_converter_->ConvertPacket(packet.get())) {
     LOG(ERROR) << "Format converstion failed.";
   }
 
   // Enqueue the callback and attempt to satisfy a read immediately.
   scoped_refptr<Buffer> buffer(
-      new AVPacketBuffer(packet, timestamp, duration));
+      new AVPacketBuffer(packet.Pass(), timestamp, duration));
   if (!buffer) {
     NOTREACHED() << "Unable to allocate AVPacketBuffer";
     return;
   }
   buffer_queue_.push_back(buffer);
   FulfillPendingRead();
   return;
 }
 
 void FFmpegDemuxerStream::FlushBuffers() {
@@ skipping 531 matching lines @@
     FFmpegDemuxerStream* demuxer_stream = streams_[packet->stream_index];
 
     // If a packet is returned by FFmpeg's av_parser_parse2()
     // the packet will reference an inner memory of FFmpeg.
     // In this case, the packet's "destruct" member is NULL,
     // and it MUST be duplicated. This fixes issue with MP3 and possibly
     // other codecs.  It is safe to call this function even if the packet does
     // not refer to inner memory from FFmpeg.
     av_dup_packet(packet.get());
 
-    // The stream takes ownership of the AVPacket.
-    demuxer_stream->EnqueuePacket(packet.release());
+    demuxer_stream->EnqueuePacket(packet.Pass());
   }
 
   // Create a loop by posting another task.  This allows seek and message loop
   // quit tasks to get processed.
   if (StreamsHavePendingReads()) {
     PostDemuxTask();
   }
 }
 
 void FFmpegDemuxer::StopTask(const base::Closure& callback) {
@@ skipping 30 matching lines @@
   }
   return false;
 }
 
 void FFmpegDemuxer::StreamHasEnded() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     if (!*iter)
       continue;
-    AVPacket* packet = new AVPacket();
-    memset(packet, 0, sizeof(*packet));
-    (*iter)->EnqueuePacket(packet);
+    scoped_ptr_malloc<AVPacket, ScopedPtrAVFreePacket> packet(new AVPacket());
+    memset(packet.get(), 0, sizeof(*packet.get()));
+    (*iter)->EnqueuePacket(packet.Pass());
   }
 }
 
 void FFmpegDemuxer::OnReadCompleted(size_t size) {
   SignalReadCompleted(size);
 }
 
 size_t FFmpegDemuxer::WaitForRead() {
   read_event_.Wait();
   return last_read_bytes_;
 }
 
 void FFmpegDemuxer::SignalReadCompleted(size_t size) {
   last_read_bytes_ = size;
   read_event_.Signal();
 }
 
 }  // namespace media