Move BindToCurrentLoop from media/base/ to base/

chromecast/media/cma/filters/cma_renderer.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/filters/cma_renderer.h"
 
 #include "base/bind.h"
+#include "base/bind_to_current_loop.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "chromecast/media/cma/base/balanced_media_task_runner_factory.h"
 #include "chromecast/media/cma/base/cma_logging.h"
 #include "chromecast/media/cma/filters/demuxer_stream_adapter.h"
 #include "chromecast/media/cma/pipeline/audio_pipeline.h"
 #include "chromecast/media/cma/pipeline/av_pipeline_client.h"
 #include "chromecast/media/cma/pipeline/media_pipeline.h"
 #include "chromecast/media/cma/pipeline/media_pipeline_client.h"
 #include "chromecast/media/cma/pipeline/video_pipeline.h"
 #include "chromecast/media/cma/pipeline/video_pipeline_client.h"
-#include "media/base/bind_to_current_loop.h"
 #include "media/base/demuxer_stream_provider.h"
 #include "media/base/pipeline_status.h"
 #include "media/base/time_delta_interpolator.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_renderer_sink.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace chromecast {
 namespace media {
 
@@ skipping 68 matching lines @@
   demuxer_stream_provider_ = demuxer_stream_provider;
   statistics_cb_ = statistics_cb;
   buffering_state_cb_ = buffering_state_cb;
   ended_cb_ = ended_cb;
   error_cb_ = error_cb;
   // TODO(erickung): wire up waiting_for_decryption_key_cb.
   waiting_for_decryption_key_cb_ = waiting_for_decryption_key_cb;
 
   MediaPipelineClient media_pipeline_client;
   media_pipeline_client.error_cb = error_cb_;
-  media_pipeline_client.buffering_state_cb = ::media::BindToCurrentLoop(
+  media_pipeline_client.buffering_state_cb = base::BindToCurrentLoop(
       base::Bind(&CmaRenderer::OnBufferingNotification, weak_this_));
-  media_pipeline_client.time_update_cb = ::media::BindToCurrentLoop(
+  media_pipeline_client.time_update_cb = base::BindToCurrentLoop(
       base::Bind(&CmaRenderer::OnPlaybackTimeUpdated, weak_this_));
   media_pipeline_->SetClient(media_pipeline_client);
 
   init_cb_ = init_cb;
   InitializeAudioPipeline();
 }
 
 void CmaRenderer::Flush(const base::Closure& flush_cb) {
   CMALOG(kLogControl) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
   BeginStateTransition();
 
   DCHECK(flush_cb_.is_null());
   flush_cb_ = flush_cb;
 
   if (state_ == kError) {
     OnError(::media::PIPELINE_ERROR_ABORT);
     return;
   }
 
   DCHECK_EQ(state_, kPlaying) << state_;
   media_pipeline_->Flush(
-      ::media::BindToCurrentLoop(
+      base::BindToCurrentLoop(
           base::Bind(&CmaRenderer::OnFlushDone, weak_this_)));
 
   {
     base::AutoLock auto_lock(time_interpolator_lock_);
     time_interpolator_->StopInterpolating();
   }
 }
 
 void CmaRenderer::StartPlayingFrom(base::TimeDelta time) {
   CMALOG(kLogControl) << __FUNCTION__ << ": " << time.InMilliseconds();
@@ skipping 81 matching lines @@
 #endif
   cdm_attached_cb.Run(true);
 }
 
 void CmaRenderer::InitializeAudioPipeline() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(state_, kUninitialized) << state_;
   DCHECK(!init_cb_.is_null());
 
   ::media::PipelineStatusCB audio_initialization_done_cb =
-      ::media::BindToCurrentLoop(
+      base::BindToCurrentLoop(
           base::Bind(&CmaRenderer::OnAudioPipelineInitializeDone, weak_this_));
 
   ::media::DemuxerStream* stream =
       demuxer_stream_provider_->GetStream(::media::DemuxerStream::AUDIO);
   if (!stream) {
     audio_initialization_done_cb.Run(::media::PIPELINE_OK);
     return;
   }
 
   // Receive events from the audio pipeline.
   AvPipelineClient av_pipeline_client;
-  av_pipeline_client.eos_cb = ::media::BindToCurrentLoop(
+  av_pipeline_client.eos_cb = base::BindToCurrentLoop(
       base::Bind(&CmaRenderer::OnEosReached, weak_this_, true));
-  av_pipeline_client.playback_error_cb = ::media::BindToCurrentLoop(
+  av_pipeline_client.playback_error_cb = base::BindToCurrentLoop(
       base::Bind(&CmaRenderer::OnError, weak_this_));
-  av_pipeline_client.statistics_cb = ::media::BindToCurrentLoop(
+  av_pipeline_client.statistics_cb = base::BindToCurrentLoop(
       base::Bind(&CmaRenderer::OnStatisticsUpdated, weak_this_));
   audio_pipeline_->SetClient(av_pipeline_client);
 
   scoped_ptr<CodedFrameProvider> frame_provider(
       new DemuxerStreamAdapter(
           base::MessageLoopProxy::current(),
           media_task_runner_factory_,
           stream));
 
   const ::media::AudioDecoderConfig& config = stream->audio_decoder_config();
@@ skipping 23 matching lines @@
 
   InitializeVideoPipeline();
 }
 
 void CmaRenderer::InitializeVideoPipeline() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(state_, kUninitialized) << state_;
   DCHECK(!init_cb_.is_null());
 
   ::media::PipelineStatusCB video_initialization_done_cb =
-      ::media::BindToCurrentLoop(
+      base::BindToCurrentLoop(
           base::Bind(&CmaRenderer::OnVideoPipelineInitializeDone, weak_this_));
 
   ::media::DemuxerStream* stream =
       demuxer_stream_provider_->GetStream(::media::DemuxerStream::VIDEO);
   if (!stream) {
     video_initialization_done_cb.Run(::media::PIPELINE_OK);
     return;
   }
 
   // Receive events from the video pipeline.
   VideoPipelineClient client;
-  client.av_pipeline_client.eos_cb = ::media::BindToCurrentLoop(
+  client.av_pipeline_client.eos_cb = base::BindToCurrentLoop(
       base::Bind(&CmaRenderer::OnEosReached, weak_this_, false));
-  client.av_pipeline_client.playback_error_cb = ::media::BindToCurrentLoop(
+  client.av_pipeline_client.playback_error_cb = base::BindToCurrentLoop(
       base::Bind(&CmaRenderer::OnError, weak_this_));
-  client.av_pipeline_client.statistics_cb = ::media::BindToCurrentLoop(
+  client.av_pipeline_client.statistics_cb = base::BindToCurrentLoop(
       base::Bind(&CmaRenderer::OnStatisticsUpdated, weak_this_));
-  client.natural_size_changed_cb = ::media::BindToCurrentLoop(
+  client.natural_size_changed_cb = base::BindToCurrentLoop(
       base::Bind(&CmaRenderer::OnNaturalSizeChanged, weak_this_));
   video_pipeline_->SetClient(client);
 
   scoped_ptr<CodedFrameProvider> frame_provider(
       new DemuxerStreamAdapter(
           base::MessageLoopProxy::current(),
           media_task_runner_factory_,
           stream));
 
   const ::media::VideoDecoderConfig& config = stream->video_decoder_config();
@@ skipping 140 matching lines @@
   is_pending_transition_ = true;
 }
 
 void CmaRenderer::CompleteStateTransition(State new_state) {
   state_ = new_state;
   is_pending_transition_ = false;
 }
 
 }  // namespace media
 }  // namespace chromecast