Chromecast: MessageLoopProxy cleanup --> SingleThreadTaskRunner.

chromecast/media/cma/backend/media_pipeline_device_fake.cc

 // Copyright 2014 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 "chromecast/media/cma/backend/media_pipeline_device_fake.h"
 
 #include <list>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
+#include "base/thread_task_runner_handle.h"
 #include "chromecast/media/cma/backend/audio_pipeline_device.h"
 #include "chromecast/media/cma/backend/media_clock_device.h"
 #include "chromecast/media/cma/backend/media_component_device.h"
 #include "chromecast/media/cma/backend/video_pipeline_device.h"
 #include "chromecast/media/cma/base/decoder_buffer_base.h"
 #include "chromecast/public/media/decoder_config.h"
 #include "media/base/buffers.h"
 
 namespace chromecast {
 namespace media {
@@ skipping 211 matching lines @@
     decoded_byte_count_ = 0;
     frames_.clear();
     pending_buffer_ = scoped_refptr<DecoderBufferBase>();
     frame_pushed_cb_.Reset();
     return true;
   }
 
   if (state_ == kStateRunning) {
     if (!scheduled_rendering_task_) {
       scheduled_rendering_task_ = true;
-      base::MessageLoopProxy::current()->PostTask(
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
           base::Bind(&MediaComponentDeviceFake::RenderTask, weak_this_));
     }
     return true;
   }
 
   return true;
 }
 
 bool MediaComponentDeviceFake::SetStartPts(base::TimeDelta time) {
@@ skipping 42 matching lines @@
 
 void MediaComponentDeviceFake::RenderTask() {
   scheduled_rendering_task_ = false;
 
   if (state_ != kStateRunning)
     return;
 
   base::TimeDelta media_time = media_clock_device_->GetTime();
   if (media_time == ::media::kNoTimestamp()) {
     scheduled_rendering_task_ = true;
-    base::MessageLoopProxy::current()->PostDelayedTask(
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&MediaComponentDeviceFake::RenderTask, weak_this_),
         base::TimeDelta::FromMilliseconds(50));
     return;
   }
 
   while (!frames_.empty() && frames_.front().pts <= media_time) {
     rendering_time_ = frames_.front().pts;
     decoded_frame_count_++;
     decoded_byte_count_ += frames_.front().size;
     frames_.pop_front();
     if (pending_buffer_.get()) {
       FakeDecoderBuffer fake_buffer;
       fake_buffer.size = pending_buffer_->data_size();
       fake_buffer.pts = pending_buffer_->timestamp();
       frames_.push_back(fake_buffer);
       pending_buffer_ = scoped_refptr<DecoderBufferBase>();
       base::ResetAndReturn(&frame_pushed_cb_).Run(kFrameSuccess);
     }
   }
 
   if (frames_.empty() && is_eos_) {
     if (!client_.eos_cb.is_null())
       client_.eos_cb.Run();
     return;
   }
 
   scheduled_rendering_task_ = true;
-  base::MessageLoopProxy::current()->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&MediaComponentDeviceFake::RenderTask, weak_this_),
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+      FROM_HERE, base::Bind(&MediaComponentDeviceFake::RenderTask, weak_this_),
       base::TimeDelta::FromMilliseconds(50));
 }
 
 bool MediaComponentDeviceFake::GetStatistics(Statistics* stats) const {
   if (state_ != kStateRunning)
     return false;
 
   // Note: what is returned here is not the number of samples but the number of
   // frames. The value is different for audio.
   stats->decoded_bytes = decoded_byte_count_;
@@ skipping 222 matching lines @@
 VideoPipelineDevice* MediaPipelineDeviceFake::GetVideoPipelineDevice() const {
   return video_pipeline_device_.get();
 }
 
 MediaClockDevice* MediaPipelineDeviceFake::GetMediaClockDevice() const {
   return media_clock_device_.get();
 }
 
 }  // namespace media
 }  // namespace chromecast