move //media/capture to //device/capture

content/browser/renderer_host/media/video_capture_controller.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 "content/browser/renderer_host/media/video_capture_controller.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 126 matching lines @@
       has_received_frames_(false),
       weak_ptr_factory_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 }
 
 base::WeakPtr<VideoCaptureController>
 VideoCaptureController::GetWeakPtrForIOThread() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
-std::unique_ptr<media::VideoCaptureDevice::Client>
+std::unique_ptr<device::VideoCaptureDevice::Client>
 VideoCaptureController::NewDeviceClient() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return base::WrapUnique(new VideoCaptureDeviceClient(
       this->GetWeakPtrForIOThread(), buffer_pool_));
 }
 
 void VideoCaptureController::AddClient(
     VideoCaptureControllerID id,
     VideoCaptureControllerEventHandler* event_handler,
     base::ProcessHandle render_process,
@@ skipping 190 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return video_capture_format_;
 }
 
 VideoCaptureController::~VideoCaptureController() {
   STLDeleteContainerPointers(controller_clients_.begin(),
                              controller_clients_.end());
 }
 
 void VideoCaptureController::DoIncomingCapturedVideoFrameOnIOThread(
-    std::unique_ptr<media::VideoCaptureDevice::Client::Buffer> buffer,
+    std::unique_ptr<device::VideoCaptureDevice::Client::Buffer> buffer,
     const scoped_refptr<VideoFrame>& frame) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   const int buffer_id = buffer->id();
   DCHECK_NE(buffer_id, VideoCaptureBufferPool::kInvalidId);
 
   int count = 0;
   if (state_ == VIDEO_CAPTURE_STATE_STARTED) {
     if (!frame->metadata()->HasKey(VideoFrameMetadata::FRAME_RATE)) {
       frame->metadata()->SetDouble(VideoFrameMetadata::FRAME_RATE,
                                    video_capture_format_.frame_rate);
@@ skipping 82 matching lines @@
 
     if (client->known_buffers.erase(buffer_id_to_drop)) {
       client->event_handler->OnBufferDestroyed(client->controller_id,
                                                buffer_id_to_drop);
     }
   }
 }
 
 void VideoCaptureController::DoNewBufferOnIOThread(
     ControllerClient* client,
-    media::VideoCaptureDevice::Client::Buffer* buffer,
+    device::VideoCaptureDevice::Client::Buffer* buffer,
     const scoped_refptr<media::VideoFrame>& frame) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   const int buffer_id = buffer->id();
 
   switch (frame->storage_type()) {
     case media::VideoFrame::STORAGE_GPU_MEMORY_BUFFERS: {
       std::vector<gfx::GpuMemoryBufferHandle> handles;
       const size_t num_planes = media::VideoFrame::NumPlanes(frame->format());
       for (size_t i = 0; i < num_planes; ++i) {
         gfx::GpuMemoryBufferHandle remote_handle;
@@ skipping 35 matching lines @@
     int session_id,
     const ControllerClients& clients) {
   for (auto* client : clients) {
     if (client->session_id == session_id)
       return client;
   }
   return NULL;
 }
 
 }  // namespace content