Move BindToCurrentLoop from media/base/ to base/

content/browser/renderer_host/media/video_capture_texture_wrapper.cc

 // Copyright 2015 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 "content/browser/renderer_host/media/video_capture_texture_wrapper.h"
 
 #include "base/bind.h"
+#include "base/bind_to_current_loop.h"
 #include "content/browser/compositor/image_transport_factory.h"
 #include "content/browser/gpu/browser_gpu_channel_host_factory.h"
 #include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/browser/renderer_host/media/video_capture_controller.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "content/common/gpu/client/gpu_channel_host.h"
 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/common/gpu/gpu_process_launch_causes.h"
 #include "content/public/browser/browser_thread.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
-#include "media/base/bind_to_current_loop.h"
 #include "media/base/video_capture_types.h"
 #include "media/base/video_frame.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/libyuv/include/libyuv.h"
 
 namespace content {
 
 namespace {
 
 // VideoCaptureController has at most 3 capture frames in flight.
@@ skipping 283 matching lines @@
   scoped_ptr<gpu::MailboxHolder> mailbox_holder(new gpu::MailboxHolder(
       gl_helper_->ProduceMailboxHolderFromTexture(texture_id)));
   DCHECK(!mailbox_holder->mailbox.IsZero());
   DCHECK(mailbox_holder->mailbox.Verify());
   DCHECK(mailbox_holder->texture_target);
   DCHECK(mailbox_holder->sync_point);
 
   scoped_refptr<media::VideoFrame> video_frame =
       media::VideoFrame::WrapNativeTexture(
           mailbox_holder.Pass(),
-          media::BindToCurrentLoop(
+          base::BindToCurrentLoop(
               base::Bind(&VideoCaptureTextureWrapper::TextureWrapperDelegate::
                              ReleaseCallback,
                          this, image_id, texture_id, gpu_memory_buffer)),
           frame_size,
           gfx::Rect(frame_size),
           frame_size,
           base::TimeDelta(),
           true /* allow_overlay */);
 
   BrowserThread::PostTask(
@@ skipping 48 matching lines @@
     gpu_memory_buffers_.push(gpu_memory_buffer);
   }
 
   // In threaded compositing mode, we have to create our own context for Capture
   // to avoid using the GPU command queue from multiple threads. Context
   // creation must happen on UI thread; then the context needs to be bound to
   // the appropriate thread, which is done in CreateGlHelper().
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&CreateContextOnUIThread,
-                 media::BindToCurrentLoop(
+                 base::BindToCurrentLoop(
                      base::Bind(&VideoCaptureTextureWrapper::
                                     TextureWrapperDelegate::CreateGlHelper,
                                 this))));
 }
 
 void VideoCaptureTextureWrapper::TextureWrapperDelegate::CreateGlHelper(
     scoped_refptr<ContextProviderCommandBuffer> capture_thread_context) {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
 
   if (!capture_thread_context.get()) {
     DLOG(ERROR) << "No offscreen GL Context!";
     return;
   }
   // This may not happen in IO Thread. The destructor resets the context lost
   // callback, so base::Unretained is safe; otherwise it'd be a circular ref
   // counted dependency.
-  capture_thread_context->SetLostContextCallback(media::BindToCurrentLoop(
+  capture_thread_context->SetLostContextCallback(base::BindToCurrentLoop(
       base::Bind(
           &VideoCaptureTextureWrapper::TextureWrapperDelegate::
               LostContextCallback,
           base::Unretained(this))));
   if (!capture_thread_context->BindToCurrentThread()) {
     capture_thread_context = NULL;
     DLOG(ERROR) << "Couldn't bind the Capture Context to the Capture Thread.";
     return;
   }
   DCHECK(capture_thread_context);
@@ skipping 33 matching lines @@
 void VideoCaptureTextureWrapper::TextureWrapperDelegate::OnError(
     const std::string& message) {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
   DLOG(ERROR) << message;
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&VideoCaptureController::DoErrorOnIOThread, controller_));
 }
 
 }  // namespace content