Move BindToCurrentLoop from media/base/ to base/

media/filters/chunk_demuxer.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/chunk_demuxer.h"
 
 #include <algorithm>
 #include <limits>
 #include <list>
 
 #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 "base/stl_util.h"
 #include "media/base/audio_decoder_config.h"
-#include "media/base/bind_to_current_loop.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/video_decoder_config.h"
 #include "media/filters/frame_processor.h"
 #include "media/filters/stream_parser_factory.h"
 
 using base::TimeDelta;
 
 namespace media {
 
 static TimeDelta EndTimestamp(const StreamParser::BufferQueue& queue) {
@@ skipping 957 matching lines @@
   base::AutoLock auto_lock(lock_);
   stream_->UnmarkEndOfStream();
 }
 
 // DemuxerStream methods.
 void ChunkDemuxerStream::Read(const ReadCB& read_cb) {
   base::AutoLock auto_lock(lock_);
   DCHECK_NE(state_, UNINITIALIZED);
   DCHECK(read_cb_.is_null());
 
-  read_cb_ = BindToCurrentLoop(read_cb);
+  read_cb_ = base::BindToCurrentLoop(read_cb);
   CompletePendingReadIfPossible_Locked();
 }
 
 DemuxerStream::Type ChunkDemuxerStream::type() const { return type_; }
 
 DemuxerStream::Liveness ChunkDemuxerStream::liveness() const {
   base::AutoLock auto_lock(lock_);
   return liveness_;
 }
 
@@ skipping 120 matching lines @@
 
 void ChunkDemuxer::Initialize(
     DemuxerHost* host,
     const PipelineStatusCB& cb,
     bool enable_text_tracks) {
   DVLOG(1) << "Init()";
 
   base::AutoLock auto_lock(lock_);
 
   // The |init_cb_| must only be run after this method returns, so always post.
-  init_cb_ = BindToCurrentLoop(cb);
+  init_cb_ = base::BindToCurrentLoop(cb);
   if (state_ == SHUTDOWN) {
     base::ResetAndReturn(&init_cb_).Run(DEMUXER_ERROR_COULD_NOT_OPEN);
     return;
   }
   DCHECK_EQ(state_, WAITING_FOR_INIT);
   host_ = host;
   enable_text_ = enable_text_tracks;
 
   ChangeState_Locked(INITIALIZING);
 
   base::ResetAndReturn(&open_cb_).Run();
 }
 
 void ChunkDemuxer::Stop() {
   DVLOG(1) << "Stop()";
   Shutdown();
 }
 
 void ChunkDemuxer::Seek(TimeDelta time, const PipelineStatusCB& cb) {
   DVLOG(1) << "Seek(" << time.InSecondsF() << ")";
   DCHECK(time >= TimeDelta());
 
   base::AutoLock auto_lock(lock_);
   DCHECK(seek_cb_.is_null());
 
-  seek_cb_ = BindToCurrentLoop(cb);
+  seek_cb_ = base::BindToCurrentLoop(cb);
   if (state_ != INITIALIZED && state_ != ENDED) {
     base::ResetAndReturn(&seek_cb_).Run(PIPELINE_ERROR_INVALID_STATE);
     return;
   }
 
   if (cancel_next_seek_) {
     cancel_next_seek_ = false;
     base::ResetAndReturn(&seek_cb_).Run(PIPELINE_OK);
     return;
   }
@@ skipping 667 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (SourceStateMap::iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media