Demuxer stream now uses a callback instead of Assignable template. Cleaning ...

media/filters/ffmpeg_demuxer.cc

 // Copyright (c) 2009 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/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "media/base/filter_host.h"
 #include "media/filters/ffmpeg_common.h"
 #include "media/filters/ffmpeg_demuxer.h"
@@ skipping 70 matching lines @@
 
   // Calculate the time base and duration in microseconds.
   int64 time_base_us = static_cast<int64>(av_q2d(stream->time_base) *
       base::Time::kMicrosecondsPerSecond);
   int64 duration_us = static_cast<int64>(time_base_us * stream->duration);
   time_base_ = base::TimeDelta::FromMicroseconds(time_base_us);
   duration_ = base::TimeDelta::FromMicroseconds(duration_us);
 }
 
 FFmpegDemuxerStream::~FFmpegDemuxerStream() {
-  // Since |input_queue_| and |output_queue_| use scoped_refptr everything
-  // should get released.
+  // Since |buffer_queue_| uses scoped_refptr everything will get released.
+  while (!read_queue_.empty()) {
+    delete read_queue_.front();
+    read_queue_.pop_front();
+  }
 }
 
 // static
 const char* FFmpegDemuxerStream::interface_id() {
   return interface_id::kFFmpegDemuxerStream;
 }
 
 void* FFmpegDemuxerStream::QueryInterface(const char* id) {
   DCHECK(id);
   FFmpegDemuxerStream* interface_ptr = NULL;
   if (0 == strcmp(id, interface_id())) {
     interface_ptr = this;
   }
   return interface_ptr;
 }
 
 bool FFmpegDemuxerStream::HasPendingReads() {
   AutoLock auto_lock(lock_);
-  return !output_queue_.empty();
+  return !read_queue_.empty();
 }
 
 void FFmpegDemuxerStream::EnqueuePacket(AVPacket* packet) {
   base::TimeDelta timestamp = time_base_ * packet->pts;
   base::TimeDelta duration = time_base_ * packet->duration;
   Buffer* buffer = new AVPacketBuffer(packet, timestamp, duration);
   DCHECK(buffer);
   {
     AutoLock auto_lock(lock_);
-    input_queue_.push_back(buffer);
+    buffer_queue_.push_back(buffer);
   }
   FulfillPendingReads();
 }
 
 const MediaFormat& FFmpegDemuxerStream::media_format() {
   return media_format_;
 }
 
-void FFmpegDemuxerStream::Read(Assignable<Buffer>* buffer) {
-  DCHECK(buffer);
+void FFmpegDemuxerStream::Read(Callback1<Buffer*>::Type* read_callback) {
+  DCHECK(read_callback);
   {
     AutoLock auto_lock(lock_);
-    output_queue_.push_back(scoped_refptr< Assignable<Buffer> >(buffer));
+    read_queue_.push_back(read_callback);
   }
   if (FulfillPendingReads()) {
     demuxer_->ScheduleDemux();
   }
 }
 
 bool FFmpegDemuxerStream::FulfillPendingReads() {
   bool pending_reads = false;
   while (true) {
-    scoped_refptr<Buffer> buffer_in;
-    scoped_refptr< Assignable<Buffer> > buffer_out;
+    scoped_refptr<Buffer> buffer;
+    scoped_ptr<Callback1<Buffer*>::Type> read_callback;
     {
       AutoLock auto_lock(lock_);
-      pending_reads = !output_queue_.empty();
-      if (input_queue_.empty() || output_queue_.empty()) {
+      pending_reads = !read_queue_.empty();
+      if (buffer_queue_.empty() || read_queue_.empty()) {
         break;
       }
-      buffer_in = input_queue_.front();
-      buffer_out = output_queue_.front();
-      input_queue_.pop_front();
-      output_queue_.pop_front();
+      buffer = buffer_queue_.front();
+      read_callback.reset(read_queue_.front());
+      buffer_queue_.pop_front();
+      read_queue_.pop_front();
     }
-    buffer_out->SetBuffer(buffer_in);
-    buffer_out->OnAssignment();
+    read_callback->Run(buffer);
   }
   return pending_reads;
 }
 
 
 //
 // FFmpegDemuxer
 //
 FFmpegDemuxer::FFmpegDemuxer()
     : demuxing_(false),
@@ skipping 115 matching lines @@
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     if ((*iter)->HasPendingReads()) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace media