Chromecast: MessageLoopProxy cleanup --> SingleThreadTaskRunner.

chromecast/media/cma/pipeline/media_pipeline_impl.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/pipeline/media_pipeline_impl.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "chromecast/media/cdm/browser_cdm_cast.h"
 #include "chromecast/media/cma/backend/media_clock_device.h"
 #include "chromecast/media/cma/backend/media_pipeline_device.h"
 #include "chromecast/media/cma/base/buffering_controller.h"
 #include "chromecast/media/cma/base/buffering_state.h"
 #include "chromecast/media/cma/base/cma_logging.h"
 #include "chromecast/media/cma/base/coded_frame_provider.h"
 #include "chromecast/media/cma/pipeline/audio_pipeline_impl.h"
 #include "chromecast/media/cma/pipeline/video_pipeline_impl.h"
@@ skipping 149 matching lines @@
   if (!clock_device_->SetState(MediaClockDevice::kStateRunning)) {
     OnError(::media::PIPELINE_ERROR_ABORT);
     return;
   }
 
   // Enable time updates.
   enable_time_update_ = true;
   statistics_rolling_counter_ = 0;
   if (!pending_time_update_task_) {
     pending_time_update_task_ = true;
-    base::MessageLoopProxy::current()->PostTask(
-        FROM_HERE,
-        base::Bind(&MediaPipelineImpl::UpdateMediaTime, weak_this_));
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(&MediaPipelineImpl::UpdateMediaTime, weak_this_));
   }
 
   // Setup the audio and video pipeline for the new timeline.
   if (has_audio_) {
     scoped_refptr<BufferingState> buffering_state;
     if (buffering_controller_)
       buffering_state = buffering_controller_->AddStream("audio");
     if (!audio_pipeline_->StartPlayingFrom(time, buffering_state)) {
       OnError(::media::PIPELINE_ERROR_ABORT);
       return;
@@ skipping 124 matching lines @@
   if (statistics_rolling_counter_ == 0) {
     audio_pipeline_->UpdateStatistics();
     video_pipeline_->UpdateStatistics();
   }
   statistics_rolling_counter_ =
       (statistics_rolling_counter_ + 1) % kStatisticsUpdatePeriod;
 
   base::TimeDelta media_time(clock_device_->GetTime());
   if (media_time == ::media::kNoTimestamp()) {
     pending_time_update_task_ = true;
-    base::MessageLoopProxy::current()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&MediaPipelineImpl::UpdateMediaTime, weak_this_),
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+        FROM_HERE, base::Bind(&MediaPipelineImpl::UpdateMediaTime, weak_this_),
         kTimeUpdateInterval);
     return;
   }
   base::TimeTicks stc = base::TimeTicks::Now();
 
   base::TimeDelta max_rendering_time = media_time;
   if (buffering_controller_) {
     buffering_controller_->SetMediaTime(media_time);
 
     // Receiving the same time twice in a row means playback isn't moving,
     // so don't interpolate ahead.
     if (media_time != last_media_time_) {
       max_rendering_time = buffering_controller_->GetMaxRenderingTime();
       if (max_rendering_time == ::media::kNoTimestamp())
         max_rendering_time = media_time;
 
       // Cap interpolation time to avoid interpolating too far ahead.
       max_rendering_time =
           std::min(max_rendering_time, media_time + 2 * kTimeUpdateInterval);
     }
   }
 
   last_media_time_ = media_time;
   if (!client_.time_update_cb.is_null())
     client_.time_update_cb.Run(media_time, max_rendering_time, stc);
 
   pending_time_update_task_ = true;
-  base::MessageLoopProxy::current()->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&MediaPipelineImpl::UpdateMediaTime, weak_this_),
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+      FROM_HERE, base::Bind(&MediaPipelineImpl::UpdateMediaTime, weak_this_),
       kTimeUpdateInterval);
 }
 
 void MediaPipelineImpl::OnError(::media::PipelineStatus error) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(error, ::media::PIPELINE_OK) << "PIPELINE_OK is not an error!";
   if (!client_.error_cb.is_null())
     client_.error_cb.Run(error);
 }
 
 }  // namespace media
 }  // namespace chromecast