Replaced DCHECKs to use MessageLoop::current() for FFmpegDemuxer and DecoderBase.

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/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "media/base/filter_host.h"
 #include "media/filters/ffmpeg_common.h"
@@ skipping 92 matching lines @@
 void* FFmpegDemuxerStream::QueryInterface(const char* id) {
   DCHECK(id);
   AVStreamProvider* interface_ptr = NULL;
   if (0 == strcmp(id, AVStreamProvider::interface_id())) {
     interface_ptr = this;
   }
   return interface_ptr;
 }
 
 bool FFmpegDemuxerStream::HasPendingReads() {
-  DCHECK_EQ(PlatformThread::CurrentId(), demuxer_->thread_id_);
+  DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
   DCHECK(!stopped_ || read_queue_.empty())
       << "Read queue should have been emptied if demuxing stream is stopped";
   return !read_queue_.empty();
 }
 
 base::TimeDelta FFmpegDemuxerStream::EnqueuePacket(AVPacket* packet) {
-  DCHECK_EQ(PlatformThread::CurrentId(), demuxer_->thread_id_);
+  DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
   base::TimeDelta timestamp = ConvertTimestamp(packet->pts);
   base::TimeDelta duration = ConvertTimestamp(packet->duration);
   if (stopped_) {
     NOTREACHED() << "Attempted to enqueue packet on a stopped stream";
     return timestamp;
   }
 
   // Enqueue the callback and attempt to satisfy a read immediately.
   scoped_refptr<Buffer> buffer =
       new AVPacketBuffer(packet, timestamp, duration);
   if (!buffer) {
     NOTREACHED() << "Unable to allocate AVPacketBuffer";
     return timestamp;
   }
   buffer_queue_.push_back(buffer);
   FulfillPendingRead();
   return timestamp;
 }
 
 void FFmpegDemuxerStream::FlushBuffers() {
-  DCHECK_EQ(PlatformThread::CurrentId(), demuxer_->thread_id_);
+  DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
   buffer_queue_.clear();
   discontinuous_ = true;
 }
 
 void FFmpegDemuxerStream::Stop() {
-  DCHECK_EQ(PlatformThread::CurrentId(), demuxer_->thread_id_);
+  DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
   buffer_queue_.clear();
   STLDeleteElements(&read_queue_);
   stopped_ = true;
 }
 
 const MediaFormat& FFmpegDemuxerStream::media_format() {
   return media_format_;
 }
 
 void FFmpegDemuxerStream::Read(Callback1<Buffer*>::Type* read_callback) {
   DCHECK(read_callback);
   demuxer_->message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(this, &FFmpegDemuxerStream::ReadTask, read_callback));
 }
 
 void FFmpegDemuxerStream::ReadTask(Callback1<Buffer*>::Type* read_callback) {
-  DCHECK_EQ(PlatformThread::CurrentId(), demuxer_->thread_id_);
+  DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
 
   // Don't accept any additional reads if we've been told to stop.
   //
   // TODO(scherkus): it would be cleaner if we replied with an error message.
   if (stopped_) {
     delete read_callback;
     return;
   }
 
   // Enqueue the callback and attempt to satisfy it immediately.
   read_queue_.push_back(read_callback);
   FulfillPendingRead();
 
   // There are still pending reads, demux some more.
   if (HasPendingReads()) {
     demuxer_->PostDemuxTask();
   }
 }
 
 void FFmpegDemuxerStream::FulfillPendingRead() {
-  DCHECK_EQ(PlatformThread::CurrentId(), demuxer_->thread_id_);
+  DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
   if (buffer_queue_.empty() || read_queue_.empty()) {
     return;
   }
 
   // Dequeue a buffer and pending read pair.
   scoped_refptr<Buffer> buffer = buffer_queue_.front();
   scoped_ptr<Callback1<Buffer*>::Type> read_callback(read_queue_.front());
   buffer_queue_.pop_front();
   read_queue_.pop_front();
 
@@ skipping 12 matching lines @@
 base::TimeDelta FFmpegDemuxerStream::ConvertTimestamp(int64 timestamp) {
   AVRational time_base = { 1, base::Time::kMicrosecondsPerSecond };
   int64 microseconds = av_rescale_q(timestamp, stream_->time_base, time_base);
   return base::TimeDelta::FromMicroseconds(microseconds);
 }
 
 //
 // FFmpegDemuxer
 //
 FFmpegDemuxer::FFmpegDemuxer()
-    : format_context_(NULL),
-      thread_id_(NULL) {
+    : format_context_(NULL) {
 }
 
 FFmpegDemuxer::~FFmpegDemuxer() {
   // In this destructor, we clean up resources held by FFmpeg. It is ugly to
   // close the codec contexts here because the corresponding codecs are opened
   // in the decoder filters. By reaching this point, all filters should have
   // stopped, so this is the only safe place to do the global clean up.
   // TODO(hclam): close the codecs in the corresponding decoders.
   AutoLock auto_lock(FFmpegLock::get()->lock());
   if (!format_context_)
@@ skipping 51 matching lines @@
   return streams_.size();
 }
 
 scoped_refptr<DemuxerStream> FFmpegDemuxer::GetStream(int stream) {
   DCHECK(stream >= 0);
   DCHECK(stream < static_cast<int>(streams_.size()));
   return streams_[stream].get();
 }
 
 void FFmpegDemuxer::InititalizeTask(DataSource* data_source) {
+  DCHECK_EQ(MessageLoop::current(), message_loop());
+
   // In order to get FFmpeg to use |data_source| for file IO we must transfer
   // ownership via FFmpegGlue.  We'll add |data_source| to FFmpegGlue and pass
   // the resulting key to FFmpeg.  FFmpeg will pass the key to FFmpegGlue which
   // will take care of attaching |data_source| to an FFmpeg context.  After
   // we finish initializing the FFmpeg context we can remove |data_source| from
   // FFmpegGlue.
   //
   // Refer to media/filters/ffmpeg_glue.h for details.
 
-  // Grab the thread id for debugging.
-  DCHECK(!thread_id_);
-  thread_id_ = PlatformThread::CurrentId();
-
   // Add our data source and get our unique key.
   std::string key = FFmpegGlue::get()->AddDataSource(data_source);
 
   // Open FFmpeg AVFormatContext.
   DCHECK(!format_context_);
   AVFormatContext* context = NULL;
   int result = av_open_input_file(&context, key.c_str(), NULL, 0, NULL);
 
   // Remove our data source.
   FFmpegGlue::get()->RemoveDataSource(data_source);
@@ skipping 38 matching lines @@
     host()->Error(DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
     return;
   }
 
   // Good to go: set the duration and notify we're done initializing.
   host()->SetDuration(max_duration);
   host()->InitializationComplete();
 }
 
 void FFmpegDemuxer::SeekTask(base::TimeDelta time) {
-  DCHECK_EQ(PlatformThread::CurrentId(), thread_id_);
+  DCHECK_EQ(MessageLoop::current(), message_loop());
 
   // Tell streams to flush buffers due to seeking.
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     (*iter)->FlushBuffers();
   }
 
   // Seek backwards if requested timestamp is behind FFmpeg's current time.
   int flags = 0;
   if (time <= current_timestamp_) {
     flags |= AVSEEK_FLAG_BACKWARD;
   }
 
   if (av_seek_frame(format_context_, -1, time.InMicroseconds(),
                     flags) < 0) {
     // TODO(scherkus): signal error.
     NOTIMPLEMENTED();
   }
 }
 
 void FFmpegDemuxer::DemuxTask() {
-  DCHECK_EQ(PlatformThread::CurrentId(), thread_id_);
+  DCHECK_EQ(MessageLoop::current(), message_loop());
 
   // Make sure we have work to do before demuxing.
   if (!StreamsHavePendingReads()) {
     return;
   }
 
   // Allocate and read an AVPacket from the media.
   scoped_ptr<AVPacket> packet(new AVPacket());
   int result = av_read_frame(format_context_, packet.get());
   if (result < 0) {
@@ skipping 36 matching lines @@
   }
 
   // Create a loop by posting another task.  This allows seek and message loop
   // quit tasks to get processed.
   if (StreamsHavePendingReads()) {
     PostDemuxTask();
   }
 }
 
 void FFmpegDemuxer::StopTask() {
-  DCHECK_EQ(PlatformThread::CurrentId(), thread_id_);
+  DCHECK_EQ(MessageLoop::current(), message_loop());
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     (*iter)->Stop();
   }
 }
 
 bool FFmpegDemuxer::StreamsHavePendingReads() {
-  DCHECK_EQ(PlatformThread::CurrentId(), thread_id_);
+  DCHECK_EQ(MessageLoop::current(), message_loop());
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     if ((*iter)->HasPendingReads()) {
       return true;
     }
   }
   return false;
 }
 
 void FFmpegDemuxer::StreamHasEnded() {
-  DCHECK_EQ(PlatformThread::CurrentId(), thread_id_);
+  DCHECK_EQ(MessageLoop::current(), message_loop());
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     AVPacket* packet = new AVPacket();
     memset(packet, 0, sizeof(*packet));
     (*iter)->EnqueuePacket(packet);
   }
 }
 
 }  // namespace media