Move BindToCurrentLoop from media/base/ to base/

chromecast/browser/media/cma_message_filter_host.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/browser/media/cma_message_filter_host.h"
 
 #include <utility>
 
+#include "base/bind_to_current_loop.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/shared_memory.h"
 #include "base/sync_socket.h"
 #include "chromecast/browser/media/cma_message_loop.h"
 #include "chromecast/browser/media/media_pipeline_host.h"
 #include "chromecast/common/media/cma_messages.h"
 #include "chromecast/media/cdm/browser_cdm_cast.h"
 #include "chromecast/media/cma/backend/video_plane.h"
 #include "chromecast/media/cma/pipeline/av_pipeline_client.h"
 #include "chromecast/media/cma/pipeline/media_pipeline_client.h"
 #include "chromecast/media/cma/pipeline/video_pipeline_client.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
-#include "media/base/bind_to_current_loop.h"
 #include "ui/gfx/geometry/point_f.h"
 #include "ui/gfx/geometry/quad_f.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace chromecast {
 namespace media {
 
 #define FORWARD_CALL(arg_pipeline, arg_fn, ...) \
   task_runner_->PostTask( \
       FROM_HERE, \
@@ skipping 169 matching lines @@
 }
 
 
 // *** Handle incoming messages ***
 
 void CmaMessageFilterHost::CreateMedia(int media_id, LoadType load_type) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   scoped_ptr<MediaPipelineHost> media_pipeline_host(new MediaPipelineHost());
   MediaPipelineClient client;
-  client.time_update_cb = ::media::BindToCurrentLoop(base::Bind(
+  client.time_update_cb = base::BindToCurrentLoop(base::Bind(
       &CmaMessageFilterHost::OnTimeUpdate, weak_this_, media_id));
-  client.buffering_state_cb = ::media::BindToCurrentLoop(base::Bind(
+  client.buffering_state_cb = base::BindToCurrentLoop(base::Bind(
       &CmaMessageFilterHost::OnBufferingNotification, weak_this_, media_id));
-  client.error_cb = ::media::BindToCurrentLoop(
+  client.error_cb = base::BindToCurrentLoop(
       base::Bind(&CmaMessageFilterHost::OnPlaybackError,
                  weak_this_, media_id, media::kNoTrackId));
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&SetMediaPipeline,
                  process_id_, media_id, media_pipeline_host.get()));
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&MediaPipelineHost::Initialize,
                  base::Unretained(media_pipeline_host.get()),
@@ skipping 77 matching lines @@
        foreign_memory_handle, foreign_socket_handle));
     return;
   }
 
   // Note: the IPC message can be sent only once the pipe has been fully
   // configured. Part of this configuration is done in
   // |MediaPipelineHost::SetAvPipe|.
   // TODO(erickung): investigate possible memory leak here.
   // If the weak pointer in |av_pipe_set_cb| gets invalidated,
   // then |foreign_memory_handle| leaks.
-  base::Closure pipe_read_activity_cb = ::media::BindToCurrentLoop(
+  base::Closure pipe_read_activity_cb = base::BindToCurrentLoop(
       base::Bind(&CmaMessageFilterHost::OnPipeReadActivity, weak_this_,
                  media_id, track_id));
-  base::Closure av_pipe_set_cb = ::media::BindToCurrentLoop(
+  base::Closure av_pipe_set_cb = base::BindToCurrentLoop(
       base::Bind(&CmaMessageFilterHost::OnAvPipeSet, weak_this_,
                  media_id, track_id,
                  foreign_memory_handle, base::Passed(&foreign_socket)));
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&MediaPipelineHost::SetAvPipe,
                  base::Unretained(media_pipeline),
                  track_id,
                  base::Passed(&shared_memory),
                  pipe_read_activity_cb,
@@ skipping 19 matching lines @@
     int media_id, TrackId track_id, const ::media::AudioDecoderConfig& config) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   MediaPipelineHost* media_pipeline = LookupById(media_id);
   if (!media_pipeline) {
     Send(new CmaMsg_TrackStateChanged(
         media_id, track_id, ::media::PIPELINE_ERROR_ABORT));
     return;
   }
 
   AvPipelineClient client;
-  client.eos_cb = ::media::BindToCurrentLoop(base::Bind(
+  client.eos_cb = base::BindToCurrentLoop(base::Bind(
       &CmaMessageFilterHost::OnEos, weak_this_, media_id, track_id));
-  client.playback_error_cb = ::media::BindToCurrentLoop(base::Bind(
+  client.playback_error_cb = base::BindToCurrentLoop(base::Bind(
       &CmaMessageFilterHost::OnPlaybackError, weak_this_, media_id, track_id));
-  client.statistics_cb = ::media::BindToCurrentLoop(
+  client.statistics_cb = base::BindToCurrentLoop(
       base::Bind(&CmaMessageFilterHost::OnStatisticsUpdated, weak_this_,
                  media_id, track_id));
 
-  ::media::PipelineStatusCB pipeline_status_cb = ::media::BindToCurrentLoop(
+  ::media::PipelineStatusCB pipeline_status_cb = base::BindToCurrentLoop(
       base::Bind(&CmaMessageFilterHost::OnTrackStateChanged, weak_this_,
                  media_id, track_id));
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&MediaPipelineHost::AudioInitialize,
                  base::Unretained(media_pipeline),
                  track_id, client, config, pipeline_status_cb));
 }
 
 void CmaMessageFilterHost::VideoInitialize(
     int media_id, TrackId track_id, const ::media::VideoDecoderConfig& config) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   MediaPipelineHost* media_pipeline = LookupById(media_id);
   if (!media_pipeline) {
     Send(new CmaMsg_TrackStateChanged(
         media_id, track_id, ::media::PIPELINE_ERROR_ABORT));
     return;
   }
 
   VideoPipelineClient client;
-  client.av_pipeline_client.eos_cb = ::media::BindToCurrentLoop(
+  client.av_pipeline_client.eos_cb = base::BindToCurrentLoop(
       base::Bind(&CmaMessageFilterHost::OnEos, weak_this_,
                  media_id, track_id));
-  client.av_pipeline_client.playback_error_cb = ::media::BindToCurrentLoop(
+  client.av_pipeline_client.playback_error_cb = base::BindToCurrentLoop(
       base::Bind(&CmaMessageFilterHost::OnPlaybackError, weak_this_,
                  media_id, track_id));
-  client.av_pipeline_client.statistics_cb = ::media::BindToCurrentLoop(
+  client.av_pipeline_client.statistics_cb = base::BindToCurrentLoop(
       base::Bind(&CmaMessageFilterHost::OnStatisticsUpdated, weak_this_,
                  media_id, track_id));
-  client.natural_size_changed_cb = ::media::BindToCurrentLoop(
+  client.natural_size_changed_cb = base::BindToCurrentLoop(
       base::Bind(&CmaMessageFilterHost::OnNaturalSizeChanged, weak_this_,
                  media_id, track_id));
 
-  ::media::PipelineStatusCB pipeline_status_cb = ::media::BindToCurrentLoop(
+  ::media::PipelineStatusCB pipeline_status_cb = base::BindToCurrentLoop(
       base::Bind(&CmaMessageFilterHost::OnTrackStateChanged, weak_this_,
                  media_id, track_id));
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&MediaPipelineHost::VideoInitialize,
                  base::Unretained(media_pipeline),
                  track_id, client, config, pipeline_status_cb));
 }
 
 void CmaMessageFilterHost::StartPlayingFrom(
     int media_id, base::TimeDelta time) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   MediaPipelineHost* media_pipeline = LookupById(media_id);
   if (!media_pipeline)
     return;
   FORWARD_CALL(media_pipeline, StartPlayingFrom, time);
 }
 
 void CmaMessageFilterHost::Flush(int media_id) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   MediaPipelineHost* media_pipeline = LookupById(media_id);
   if (!media_pipeline) {
     Send(new CmaMsg_MediaStateChanged(
         media_id, ::media::PIPELINE_ERROR_ABORT));
     return;
   }
-  ::media::PipelineStatusCB pipeline_status_cb = ::media::BindToCurrentLoop(
+  ::media::PipelineStatusCB pipeline_status_cb = base::BindToCurrentLoop(
       base::Bind(&CmaMessageFilterHost::OnMediaStateChanged, weak_this_,
                  media_id));
   FORWARD_CALL(media_pipeline, Flush, pipeline_status_cb);
 }
 
 void CmaMessageFilterHost::Stop(int media_id) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   MediaPipelineHost* media_pipeline = LookupById(media_id);
   if (!media_pipeline)
     return;
@@ skipping 93 matching lines @@
 }
 
 void CmaMessageFilterHost::OnNaturalSizeChanged(
     int media_id, TrackId track_id, const gfx::Size& size) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   Send(new CmaMsg_NaturalSizeChanged(media_id, track_id, size));
 }
 
 }  // namespace media
 }  // namespace chromecast