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

content/browser/renderer_host/media/video_capture_manager.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_manager.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 11 matching lines @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "content/browser/media/capture/desktop_capture_device_uma_types.h"
 #include "content/browser/media/capture/web_contents_video_capture_device.h"
 #include "content/browser/media/media_internals.h"
 #include "content/browser/renderer_host/media/video_capture_controller.h"
 #include "content/browser/renderer_host/media/video_capture_controller_event_handler.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/desktop_media_id.h"
 #include "content/public/common/media_stream_request.h"
+#include "device/capture/video/video_capture_device.h"
+#include "device/capture/video/video_capture_device_factory.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/media_switches.h"
-#include "media/capture/video/video_capture_device.h"
-#include "media/capture/video/video_capture_device_factory.h"
 
 #if defined(ENABLE_SCREEN_CAPTURE)
 #include "content/browser/media/capture/desktop_capture_device.h"
 #if defined(USE_AURA)
 #include "content/browser/media/capture/desktop_capture_device_aura.h"
 #endif
 #endif
 
 #if defined(OS_MACOSX)
 #include "media/base/mac/avfoundation_glue.h"
@@ skipping 89 matching lines @@
               std::unique_ptr<VideoCaptureController> controller,
               const media::VideoCaptureParams& params);
   ~DeviceEntry();
 
   const int serial_id;
   const MediaStreamType stream_type;
   const std::string id;
   const media::VideoCaptureParams parameters;
 
   VideoCaptureController* video_capture_controller() const;
-  media::VideoCaptureDevice* video_capture_device() const;
+  device::VideoCaptureDevice* video_capture_device() const;
 
   void SetVideoCaptureDevice(std::unique_ptr<VideoCaptureDevice> device);
   std::unique_ptr<VideoCaptureDevice> ReleaseVideoCaptureDevice();
 
  private:
   const std::unique_ptr<VideoCaptureController> video_capture_controller_;
 
   std::unique_ptr<VideoCaptureDevice> video_capture_device_;
 
   base::ThreadChecker thread_checker_;
 };
 
-// Bundles a media::VideoCaptureDeviceDescriptor with corresponding supported
+// Bundles a device::VideoCaptureDeviceDescriptor with corresponding supported
 // video formats.
 struct VideoCaptureManager::DeviceInfo {
   DeviceInfo();
-  DeviceInfo(media::VideoCaptureDeviceDescriptor descriptor);
+  DeviceInfo(device::VideoCaptureDeviceDescriptor descriptor);
   DeviceInfo(const DeviceInfo& other);
   ~DeviceInfo();
   DeviceInfo& operator=(const DeviceInfo& other);
 
-  media::VideoCaptureDeviceDescriptor descriptor;
+  device::VideoCaptureDeviceDescriptor descriptor;
   media::VideoCaptureFormats supported_formats;
 };
 
 // Class used for queuing request for starting a device.
 class VideoCaptureManager::CaptureDeviceStartRequest {
  public:
   CaptureDeviceStartRequest(int serial_id,
                             media::VideoCaptureSessionId session_id,
                             const media::VideoCaptureParams& params);
   int serial_id() const { return serial_id_; }
@@ skipping 21 matching lines @@
     const media::VideoCaptureParams& params)
     : serial_id(g_device_start_id++),
       stream_type(stream_type),
       id(id),
       parameters(params),
       video_capture_controller_(std::move(controller)) {}
 
 VideoCaptureManager::DeviceEntry::~DeviceEntry() {
   DCHECK(thread_checker_.CalledOnValidThread());
   // DCHECK that this DeviceEntry does not still own a
-  // media::VideoCaptureDevice. media::VideoCaptureDevice must be deleted on
+  // device::VideoCaptureDevice. media::VideoCaptureDevice must be deleted on
   // the device thread.
   DCHECK(video_capture_device_ == nullptr);
 }
 
 void VideoCaptureManager::DeviceEntry::SetVideoCaptureDevice(
     std::unique_ptr<VideoCaptureDevice> device) {
   DCHECK(thread_checker_.CalledOnValidThread());
   video_capture_device_.swap(device);
 }
 
-std::unique_ptr<media::VideoCaptureDevice>
+std::unique_ptr<device::VideoCaptureDevice>
 VideoCaptureManager::DeviceEntry::ReleaseVideoCaptureDevice() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return std::move(video_capture_device_);
 }
 
 VideoCaptureController*
 VideoCaptureManager::DeviceEntry::video_capture_controller() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return video_capture_controller_.get();
 }
 
-media::VideoCaptureDevice*
+device::VideoCaptureDevice*
 VideoCaptureManager::DeviceEntry::video_capture_device() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return video_capture_device_.get();
 }
 
 VideoCaptureManager::DeviceInfo::DeviceInfo() = default;
 
 VideoCaptureManager::DeviceInfo::DeviceInfo(
-    media::VideoCaptureDeviceDescriptor descriptor)
+    device::VideoCaptureDeviceDescriptor descriptor)
     : descriptor(descriptor) {}
 
 VideoCaptureManager::DeviceInfo::DeviceInfo(
     const VideoCaptureManager::DeviceInfo& other) = default;
 
 VideoCaptureManager::DeviceInfo::~DeviceInfo() = default;
 
 VideoCaptureManager::DeviceInfo& VideoCaptureManager::DeviceInfo::operator=(
     const VideoCaptureManager::DeviceInfo& other) = default;
 
 VideoCaptureManager::CaptureDeviceStartRequest::CaptureDeviceStartRequest(
     int serial_id,
     media::VideoCaptureSessionId session_id,
     const media::VideoCaptureParams& params)
     : serial_id_(serial_id),
       session_id_(session_id),
       params_(params),
       abort_start_(false) {
 }
 
 VideoCaptureManager::VideoCaptureManager(
-    std::unique_ptr<media::VideoCaptureDeviceFactory> factory)
+    std::unique_ptr<device::VideoCaptureDeviceFactory> factory)
     : listener_(nullptr),
       new_capture_session_id_(1),
       video_capture_device_factory_(std::move(factory)) {}
 
 VideoCaptureManager::~VideoCaptureManager() {
   DCHECK(devices_.empty());
   DCHECK(device_start_queue_.empty());
 }
 
 void VideoCaptureManager::Register(
@@ skipping 38 matching lines @@
       devices_enumerated_callback = base::Bind(
           &VideoCaptureManager::ConsolidateDevicesInfoOnDeviceThread, this,
           media::BindToCurrentLoop(
               base::Bind(&VideoCaptureManager::OnDevicesInfoEnumerated, this,
                          stream_type, base::Owned(new base::ElapsedTimer()))),
           stream_type, devices_info_cache_);
   // OK to use base::Unretained() since we own the VCDFactory and |this| is
   // bound in |devices_enumerated_callback|.
   device_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&media::VideoCaptureDeviceFactory::EnumerateDeviceDescriptors,
+      base::Bind(&device::VideoCaptureDeviceFactory::EnumerateDeviceDescriptors,
                  base::Unretained(video_capture_device_factory_.get()),
                  devices_enumerated_callback));
 }
 
 int VideoCaptureManager::Open(const StreamDeviceInfo& device_info) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(listener_);
 
   // Generate a new id for the session being opened.
   const media::VideoCaptureSessionId capture_session_id =
@@ skipping 185 matching lines @@
     int serial_id,
     std::unique_ptr<VideoCaptureDevice> device) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(serial_id == device_start_queue_.begin()->serial_id());
   DVLOG(3) << "OnDeviceStarted";
   if (device_start_queue_.front().abort_start()) {
     // |device| can be null if creation failed in
     // DoStartDeviceCaptureOnDeviceThread.
     // The device is no longer wanted. Stop the device again.
     DVLOG(3) << "OnDeviceStarted but start request have been aborted.";
-    media::VideoCaptureDevice* device_ptr = device.get();
+    device::VideoCaptureDevice* device_ptr = device.get();
     base::Closure closure =
         base::Bind(&VideoCaptureManager::DoStopDeviceOnDeviceThread, this,
                    base::Passed(&device));
     if (device_ptr && !device_task_runner_->PostTask(FROM_HERE, closure)) {
       // PostTask failed. The device must be stopped anyway.
       device_ptr->StopAndDeAllocate();
     }
   } else {
     DeviceEntry* const entry = GetDeviceEntryBySerialId(serial_id);
     DCHECK(entry);
     DCHECK(!entry->video_capture_device());
     entry->SetVideoCaptureDevice(std::move(device));
 
     if (entry->stream_type == MEDIA_DESKTOP_VIDEO_CAPTURE) {
       const media::VideoCaptureSessionId session_id =
           device_start_queue_.front().session_id();
       DCHECK(session_id != kFakeSessionId);
       MaybePostDesktopCaptureWindowId(session_id);
     }
   }
 
   device_start_queue_.pop_front();
   HandleQueuedStartRequest();
 }
 
-std::unique_ptr<media::VideoCaptureDevice>
+std::unique_ptr<device::VideoCaptureDevice>
 VideoCaptureManager::DoStartDeviceCaptureOnDeviceThread(
     const VideoCaptureDeviceDescriptor& descriptor,
     const media::VideoCaptureParams& params,
     std::unique_ptr<VideoCaptureDevice::Client> device_client) {
   SCOPED_UMA_HISTOGRAM_TIMER("Media.VideoCaptureManager.StartDeviceTime");
   DCHECK(IsOnDeviceThread());
 
   std::unique_ptr<VideoCaptureDevice> video_capture_device;
   video_capture_device =
       video_capture_device_factory_->CreateDevice(descriptor);
 
   if (!video_capture_device) {
     device_client->OnError(FROM_HERE, "Could not create capture device");
     return nullptr;
   }
 
   video_capture_device->AllocateAndStart(params, std::move(device_client));
   return video_capture_device;
 }
 
-std::unique_ptr<media::VideoCaptureDevice>
+std::unique_ptr<device::VideoCaptureDevice>
 VideoCaptureManager::DoStartTabCaptureOnDeviceThread(
     const std::string& id,
     const media::VideoCaptureParams& params,
     std::unique_ptr<VideoCaptureDevice::Client> device_client) {
   SCOPED_UMA_HISTOGRAM_TIMER("Media.VideoCaptureManager.StartDeviceTime");
   DCHECK(IsOnDeviceThread());
 
   std::unique_ptr<VideoCaptureDevice> video_capture_device;
   video_capture_device.reset(WebContentsVideoCaptureDevice::Create(id));
 
   if (!video_capture_device) {
     device_client->OnError(FROM_HERE, "Could not create capture device");
     return nullptr;
   }
 
   video_capture_device->AllocateAndStart(params, std::move(device_client));
   return video_capture_device;
 }
 
-std::unique_ptr<media::VideoCaptureDevice>
+std::unique_ptr<device::VideoCaptureDevice>
 VideoCaptureManager::DoStartDesktopCaptureOnDeviceThread(
     const std::string& id,
     const media::VideoCaptureParams& params,
     std::unique_ptr<VideoCaptureDevice::Client> device_client) {
   SCOPED_UMA_HISTOGRAM_TIMER("Media.VideoCaptureManager.StartDeviceTime");
   DCHECK(IsOnDeviceThread());
 
   std::unique_ptr<VideoCaptureDevice> video_capture_device;
 #if defined(ENABLE_SCREEN_CAPTURE)
   DesktopMediaID desktop_id = DesktopMediaID::Parse(id);
@@ skipping 141 matching lines @@
     return;
 
   controller->ResumeClient(client_id, client_handler);
 }
 
 void VideoCaptureManager::RequestRefreshFrameForClient(
     VideoCaptureController* controller) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (DeviceEntry* entry = GetDeviceEntryByController(controller)) {
-    if (media::VideoCaptureDevice* device = entry->video_capture_device()) {
+    if (device::VideoCaptureDevice* device = entry->video_capture_device()) {
       device_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&VideoCaptureDevice::RequestRefreshFrame,
                      // Unretained is safe to use here because |device| would be
                      // null if it was scheduled for shutdown and destruction,
                      // and because this task is guaranteed to run before the
                      // task that destroys the |device|.
                      base::Unretained(device)));
     }
   }
@@ skipping 175 matching lines @@
       timer->Elapsed());
   if (!listener_) {
     // Listener has been removed.
     return;
   }
   devices_info_cache_ = new_devices_info_cache;
 
   // Walk the |devices_info_cache_| and transform from
   // VideoCaptureDeviceDescriptor to StreamDeviceInfo for return purposes.
   StreamDeviceInfoArray devices;
-  std::vector<std::tuple<media::VideoCaptureDeviceDescriptor,
+  std::vector<std::tuple<device::VideoCaptureDeviceDescriptor,
                          media::VideoCaptureFormats>>
       descriptors_and_formats;
   for (const auto& it : devices_info_cache_) {
     devices.emplace_back(stream_type, it.descriptor.GetNameAndModel(),
                          it.descriptor.device_id);
     descriptors_and_formats.emplace_back(it.descriptor, it.supported_formats);
     MediaInternals::GetInstance()->UpdateVideoCaptureDeviceCapabilities(
         descriptors_and_formats);
   }
   listener_->DevicesEnumerated(stream_type, devices);
@@ skipping 54 matching lines @@
     // TODO(mcasas): use a helper function https://crbug.com/624854.
     DeviceEntries::iterator device_it =
         std::find_if(devices_.begin(), devices_.end(),
                      [entry](const std::unique_ptr<DeviceEntry>& device_entry) {
                        return device_entry.get() == entry;
                      });
     devices_.erase(device_it);
   }
 }
 
-media::VideoCaptureDevice*
+device::VideoCaptureDevice*
 VideoCaptureManager::GetVideoCaptureDeviceBySessionId(int session_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   SessionMap::const_iterator session_it = sessions_.find(session_id);
   if (session_it == sessions_.end())
     return nullptr;
 
   DeviceEntry* const device_info =
       GetDeviceEntryByTypeAndId(session_it->second.type, session_it->second.id);
   return device_info ? device_info->video_capture_device() : nullptr;
 }
@@ skipping 68 matching lines @@
   std::unique_ptr<VideoCaptureController> video_capture_controller(
       new VideoCaptureController(max_buffers));
   DeviceEntry* new_device =
       new DeviceEntry(device_info.type, device_info.id,
                       std::move(video_capture_controller), params);
   devices_.emplace_back(new_device);
   return new_device;
 }
 
 void VideoCaptureManager::SetDesktopCaptureWindowIdOnDeviceThread(
-    media::VideoCaptureDevice* device,
+    device::VideoCaptureDevice* device,
     gfx::NativeViewId window_id) {
   DCHECK(IsOnDeviceThread());
 #if defined(ENABLE_SCREEN_CAPTURE)
   DesktopCaptureDevice* desktop_device =
       static_cast<DesktopCaptureDevice*>(device);
   desktop_device->SetNotificationWindowId(window_id);
   VLOG(2) << "Screen capture notification window passed on device thread.";
 #endif
 }
 
@@ skipping 74 matching lines @@
     if (!device_in_queue) {
       // Session ID is only valid for Screen capture. So we can fake it to
       // resume video capture devices here.
       QueueStartDevice(kFakeSessionId, entry.get(), entry->parameters);
     }
   }
 }
 #endif  // defined(OS_ANDROID)
 
 }  // namespace content