Move BindToCurrentLoop from media/base/ to base/

media/filters/fake_video_decoder.cc

 // Copyright 2013 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/fake_video_decoder.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 "media/base/bind_to_current_loop.h"
 #include "media/base/test_helpers.h"
 
 namespace media {
 
 FakeVideoDecoder::FakeVideoDecoder(int decoding_delay,
                                    int max_parallel_decoding_requests,
                                    const BytesDecodedCB& bytes_decoded_cb)
     : decoding_delay_(decoding_delay),
       max_parallel_decoding_requests_(max_parallel_decoding_requests),
       bytes_decoded_cb_(bytes_decoded_cb),
@@ skipping 29 matching lines @@
                                   bool low_delay,
                                   const PipelineStatusCB& status_cb,
                                   const OutputCB& output_cb) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(config.IsValidConfig());
   DCHECK(held_decode_callbacks_.empty())
       << "No reinitialization during pending decode.";
   DCHECK(reset_cb_.IsNull()) << "No reinitialization during pending reset.";
 
   current_config_ = config;
-  init_cb_.SetCallback(BindToCurrentLoop(status_cb));
+  init_cb_.SetCallback(base::BindToCurrentLoop(status_cb));
 
-  // Don't need BindToCurrentLoop() because |output_cb_| is only called from
-  // RunDecodeCallback() which is posted from Decode().
+  // Don't need base::BindToCurrentLoop() because |output_cb_| is only called
+  // from RunDecodeCallback() which is posted from Decode().
   output_cb_ = output_cb;
 
   if (!decoded_frames_.empty()) {
     DVLOG(1) << "Decoded frames dropped during reinitialization.";
     decoded_frames_.clear();
   }
 
   if (fail_to_initialize_) {
     state_ = STATE_ERROR;
     init_cb_.RunOrHold(DECODER_ERROR_NOT_SUPPORTED);
@@ skipping 10 matching lines @@
   DCHECK_LE(decoded_frames_.size(),
             decoding_delay_ + held_decode_callbacks_.size());
   DCHECK_LT(static_cast<int>(held_decode_callbacks_.size()),
             max_parallel_decoding_requests_);
   DCHECK_NE(state_, STATE_END_OF_STREAM);
 
   int buffer_size = buffer->end_of_stream() ? 0 : buffer->data_size();
   DecodeCB wrapped_decode_cb = base::Bind(&FakeVideoDecoder::OnFrameDecoded,
                                           weak_factory_.GetWeakPtr(),
                                           buffer_size,
-                                          BindToCurrentLoop(decode_cb));
+                                          base::BindToCurrentLoop(decode_cb));
 
   if (state_ == STATE_ERROR) {
     wrapped_decode_cb.Run(kDecodeError);
     return;
   }
 
   if (buffer->end_of_stream()) {
     state_ = STATE_END_OF_STREAM;
   } else {
     DCHECK(VerifyFakeVideoBufferForTest(buffer, current_config_));
     scoped_refptr<VideoFrame> video_frame = VideoFrame::CreateColorFrame(
         current_config_.coded_size(), 0, 0, 0, buffer->timestamp());
     decoded_frames_.push_back(video_frame);
   }
 
   RunOrHoldDecode(wrapped_decode_cb);
 }
 
 void FakeVideoDecoder::Reset(const base::Closure& closure) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(reset_cb_.IsNull());
 
-  reset_cb_.SetCallback(BindToCurrentLoop(closure));
+  reset_cb_.SetCallback(base::BindToCurrentLoop(closure));
   decoded_frames_.clear();
 
   // Defer the reset if a decode is pending.
   if (!held_decode_callbacks_.empty())
     return;
 
   DoReset();
 }
 
 void FakeVideoDecoder::HoldNextInit() {
@@ skipping 125 matching lines @@
 
 void FakeVideoDecoder::DoReset() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(held_decode_callbacks_.empty());
   DCHECK(!reset_cb_.IsNull());
 
   reset_cb_.RunOrHold();
 }
 
 }  // namespace media