Use enum instead of string in MessageLoopFactory::GetMessageLoop*

media/filters/gpu_video_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/gpu_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
@@ skipping 26 matching lines @@
 GpuVideoDecoder::BufferPair::~BufferPair() {}
 
 GpuVideoDecoder::BufferData::BufferData(
     int32 bbid, base::TimeDelta ts, const gfx::Size& ns)
     : bitstream_buffer_id(bbid), timestamp(ts), natural_size(ns) {
 }
 
 GpuVideoDecoder::BufferData::~BufferData() {}
 
 GpuVideoDecoder::GpuVideoDecoder(
-    MessageLoop* message_loop,
-    MessageLoop* vda_loop,
+    const MessageLoopFactoryCB& message_loop_factory_cb,
+    const scoped_refptr<base::MessageLoopProxy>& vda_loop_proxy,
     const scoped_refptr<Factories>& factories)
-    : gvd_loop_proxy_(message_loop->message_loop_proxy()),
-      vda_loop_proxy_(vda_loop->message_loop_proxy()),
+    : message_loop_factory_cb_(message_loop_factory_cb),
+      gvd_loop_proxy_(NULL),
+      vda_loop_proxy_(vda_loop_proxy),
       factories_(factories),
       state_(kNormal),
       demuxer_read_in_progress_(false),
       decoder_texture_target_(0),
       next_picture_buffer_id_(0),
       next_bitstream_buffer_id_(0),
       shutting_down_(false),
       error_occured_(false) {
-  DCHECK(gvd_loop_proxy_ && factories_);
+  DCHECK(!message_loop_factory_cb_.is_null());
+  DCHECK(factories_);
 }
 
 void GpuVideoDecoder::Reset(const base::Closure& closure)  {
   if (!gvd_loop_proxy_->BelongsToCurrentThread() ||
       state_ == kDrainingDecoder) {
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::Reset, this, closure));
     return;
   }
 
@@ skipping 35 matching lines @@
     closure.Run();
     return;
   }
   DestroyVDA();
   closure.Run();
 }
 
 void GpuVideoDecoder::Initialize(const scoped_refptr<DemuxerStream>& stream,
                                  const PipelineStatusCB& orig_status_cb,
                                  const StatisticsCB& statistics_cb) {
-  if (!gvd_loop_proxy_->BelongsToCurrentThread()) {
+  if (!gvd_loop_proxy_) {
+    gvd_loop_proxy_ = base::ResetAndReturn(&message_loop_factory_cb_).Run();
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::Initialize,
         this, stream, orig_status_cb, statistics_cb));
     return;
   }
 
+  DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   PipelineStatusCB status_cb = CreateUMAReportingPipelineCB(
       "Media.GpuVideoDecoderInitializeStatus", orig_status_cb);
 
   DCHECK(!demuxer_stream_);
   if (!stream) {
     status_cb.Run(PIPELINE_ERROR_DECODE);
     return;
   }
 
   const VideoDecoderConfig& config = stream->video_decoder_config();
@@ skipping 425 matching lines @@
 
   error_occured_ = true;
 
   if (!pending_read_cb_.is_null()) {
     base::ResetAndReturn(&pending_read_cb_).Run(kDecodeError, NULL);
     return;
   }
 }
 
 }  // namespace media