Use enum instead of string in MessageLoopFactory::GetMessageLoop*

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 "base/bind.h"
 #include "base/callback_helpers.h"
+#include "base/location.h"
+#include "base/message_loop_proxy.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/data_buffer.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/demuxer.h"
 #include "media/base/pipeline.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/filters/ffmpeg_glue.h"
 
 namespace media {
 
 // Returns true if the decode result was end of stream.
 static inline bool IsEndOfStream(int result, int decoded_size, Buffer* input) {
   // Three conditions to meet to declare end of stream for this decoder:
   // 1. FFmpeg didn't read anything.
   // 2. FFmpeg didn't output anything.
   // 3. An end of stream buffer is received.
   return result == 0 && decoded_size == 0 && input->IsEndOfStream();
 }
 
-FFmpegAudioDecoder::FFmpegAudioDecoder(
-    const base::Callback<MessageLoop*()>& message_loop_cb)
+FFmpegAudioDecoder::FFmpegAudioDecoder(const MessageLoopCB& message_loop_cb)
     : message_loop_factory_cb_(message_loop_cb),
       message_loop_(NULL),
       codec_context_(NULL),
       bits_per_channel_(0),
       channel_layout_(CHANNEL_LAYOUT_NONE),
       samples_per_second_(0),
       bytes_per_frame_(0),
       output_timestamp_base_(kNoTimestamp()),
       total_frames_decoded_(0),
       last_input_timestamp_(kNoTimestamp()),
       output_bytes_to_drop_(0),
       av_frame_(NULL) {
 }
 
 void FFmpegAudioDecoder::Initialize(
     const scoped_refptr<DemuxerStream>& stream,
     const PipelineStatusCB& status_cb,
     const StatisticsCB& statistics_cb) {
   // Ensure FFmpeg has been initialized
   FFmpegGlue::GetInstance();
 
   if (!message_loop_) {
-    message_loop_ = message_loop_factory_cb_.Run();
-    message_loop_factory_cb_.Reset();
+    message_loop_ = base::ResetAndReturn(&message_loop_factory_cb_).Run();
   } else {
     // TODO(scherkus): initialization currently happens more than once in
     // PipelineIntegrationTest.BasicPlayback.
     LOG(ERROR) << "Initialize has already been called.";
   }
   message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&FFmpegAudioDecoder::DoInitialize, this,
                  stream, status_cb, statistics_cb));
 }
@@ skipping 83 matching lines @@
 void FFmpegAudioDecoder::DoReset(const base::Closure& closure) {
   avcodec_flush_buffers(codec_context_);
   output_timestamp_base_ = kNoTimestamp();
   total_frames_decoded_ = 0;
   last_input_timestamp_ = kNoTimestamp();
   output_bytes_to_drop_ = 0;
   closure.Run();
 }
 
 void FFmpegAudioDecoder::DoRead(const ReadCB& read_cb) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(!read_cb.is_null());
   CHECK(read_cb_.is_null()) << "Overlapping decodes are not supported.";
 
   read_cb_ = read_cb;
   ReadFromDemuxerStream();
 }
 
 void FFmpegAudioDecoder::DoDecodeBuffer(
     DemuxerStream::Status status,
     const scoped_refptr<DecoderBuffer>& input) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
+  DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(!read_cb_.is_null());
 
   if (status != DemuxerStream::kOk) {
     DCHECK(!input);
     // TODO(acolwell): Add support for reinitializing the decoder when
     // |status| == kConfigChanged. For now we just trigger a decode error.
     AudioDecoder::Status decoder_status =
         (status == DemuxerStream::kAborted) ? kAborted : kDecodeError;
     base::ResetAndReturn(&read_cb_).Run(decoder_status, NULL);
     return;
@@ skipping 148 matching lines @@
       &FFmpegAudioDecoder::DoDecodeBuffer, this, status, buffer));
 }
 
 base::TimeDelta FFmpegAudioDecoder::GetNextOutputTimestamp() const {
   DCHECK(output_timestamp_base_ != kNoTimestamp());
   double decoded_us = (total_frames_decoded_ / samples_per_second_) *
       base::Time::kMicrosecondsPerSecond;
   return output_timestamp_base_ + base::TimeDelta::FromMicroseconds(decoded_us);
 }
 }  // namespace media