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

device/capture/video/mac/video_capture_device_mac.mm

 // 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/capture/video/mac/video_capture_device_mac.h"
+#include "device/capture/video/mac/video_capture_device_mac.h"
 
 #include <IOKit/IOCFPlugIn.h>
 #include <IOKit/usb/IOUSBLib.h>
 #include <IOKit/usb/USBSpec.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/mac/scoped_ioobject.h"
 #include "base/mac/scoped_ioplugininterface.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
+#import "device/capture/video/mac/video_capture_device_avfoundation_mac.h"
 #import "media/base/mac/avfoundation_glue.h"
 #include "media/base/timestamp_constants.h"
-#import "media/capture/video/mac/video_capture_device_avfoundation_mac.h"
 #include "ui/gfx/geometry/size.h"
 
 @implementation DeviceNameAndTransportType
 
 - (id)initWithName:(NSString*)deviceName transportType:(int32_t)transportType {
   if (self = [super init]) {
     deviceName_.reset([deviceName copy]);
     transportType_ = transportType;
   }
   return self;
 }
 
 - (NSString*)deviceName {
   return deviceName_;
 }
 
 - (int32_t)transportType {
   return transportType_;
 }
 
 @end  // @implementation DeviceNameAndTransportType
 
-namespace media {
+namespace device {
 
 // Mac specific limits for minimum and maximum frame rate.
 const float kMinFrameRate = 1.0f;
 const float kMaxFrameRate = 30.0f;
 
 // In device identifiers, the USB VID and PID are stored in 4 bytes each.
 const size_t kVidPidSize = 4;
 
 // The following constants are extracted from the specification "Universal
 // Serial Bus Device Class Definition for Video Devices", Rev. 1.1 June 1, 2005.
@@ skipping 93 matching lines @@
     DLOG(ERROR) << "IOCreatePlugInInterfaceForService";
     return false;
   }
   return true;
 }
 
 // Creates a control interface for |plugin_interface| and produces a command to
 // set the appropriate Power Line frequency for flicker removal.
 static void SetAntiFlickerInVideoControlInterface(
     IOCFPlugInInterface** plugin_interface,
-    const PowerLineFrequency frequency) {
+    const media::PowerLineFrequency frequency) {
   // Create, the control interface for the found plugin, and release
   // the intermediate plugin.
   IOUSBInterfaceInterface** control_interface = NULL;
   HRESULT res =
       (*plugin_interface)
           ->QueryInterface(plugin_interface,
                            CFUUIDGetUUIDBytes(kIOUSBInterfaceInterfaceID),
                            reinterpret_cast<LPVOID*>(&control_interface));
   if (!SUCCEEDED(res) || !control_interface) {
     DLOG(ERROR) << "Couldn’t create control interface";
@@ skipping 40 matching lines @@
   command.bRequest = kVcRequestCodeSetCur;
   UInt8 interface_number;
   (*control_interface)
       ->GetInterfaceNumber(control_interface, &interface_number);
   command.wIndex = (real_unit_id << 8) | interface_number;
   const int selector = kPuPowerLineFrequencyControl;
   command.wValue = (selector << 8);
   command.wLength = kPuPowerLineFrequencyControlCommandSize;
   command.wLenDone = 0;
   int power_line_flag_value =
-      (frequency == PowerLineFrequency::FREQUENCY_50HZ) ? k50Hz : k60Hz;
+      (frequency == media::PowerLineFrequency::FREQUENCY_50HZ) ? k50Hz : k60Hz;
   command.pData = &power_line_flag_value;
 
   IOReturn ret =
       (*control_interface)->ControlRequest(control_interface, 0, &command);
   DLOG_IF(ERROR, ret != kIOReturnSuccess) << "Anti-flicker control request"
                                           << " failed (0x" << std::hex << ret
                                           << "), unit id: " << real_unit_id;
   DVLOG_IF(1, ret == kIOReturnSuccess) << "Anti-flicker set to "
                                        << static_cast<int>(frequency) << "Hz";
 
   (*control_interface)->USBInterfaceClose(control_interface);
 }
 
 // Sets the flicker removal in a USB webcam identified by |vendor_id| and
 // |product_id|, if available. The process includes first finding all USB
 // devices matching the specified |vendor_id| and |product_id|; for each
 // matching device, a device interface, and inside it a video control interface
 // are created. The latter is used to a send a power frequency setting command.
-static void SetAntiFlickerInUsbDevice(const int vendor_id,
-                                      const int product_id,
-                                      const PowerLineFrequency frequency) {
-  if (frequency == PowerLineFrequency::FREQUENCY_DEFAULT)
+static void SetAntiFlickerInUsbDevice(
+    const int vendor_id,
+    const int product_id,
+    const media::PowerLineFrequency frequency) {
+  if (frequency == media::PowerLineFrequency::FREQUENCY_DEFAULT)
     return;
   DVLOG(1) << "Setting Power Line Frequency to " << static_cast<int>(frequency)
            << " Hz, device " << std::hex << vendor_id << "-" << product_id;
 
   // Compose a search dictionary with vendor and product ID.
   CFMutableDictionaryRef query_dictionary =
       IOServiceMatching(kIOUSBDeviceClassName);
   CFDictionarySetValue(
       query_dictionary, CFSTR(kUSBVendorName),
       CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &vendor_id));
@@ skipping 67 matching lines @@
     SetErrorState(FROM_HERE, "Could not open capture device.");
     return;
   }
 
   capture_format_.frame_size = params.requested_format.frame_size;
   capture_format_.frame_rate =
       std::max(kMinFrameRate,
                std::min(params.requested_format.frame_rate, kMaxFrameRate));
   // Leave the pixel format selection to AVFoundation. The pixel format
   // will be passed to |ReceiveFrame|.
-  capture_format_.pixel_format = PIXEL_FORMAT_UNKNOWN;
+  capture_format_.pixel_format = media::PIXEL_FORMAT_UNKNOWN;
 
   if (!UpdateCaptureResolution())
     return;
 
   // Try setting the power line frequency removal (anti-flicker). The built-in
   // cameras are normally suspended so the configuration must happen right
   // before starting capture and during configuration.
   const std::string device_model = GetDeviceModelId(
       device_descriptor_.device_id, device_descriptor_.capture_api,
       device_descriptor_.transport_type);
@@ skipping 73 matching lines @@
 
 void VideoCaptureDeviceMac::OnPhotoTaken(const uint8_t* image_data,
                                          size_t image_length,
                                          const std::string& mime_type) {
   DCHECK(photo_callback_);
   if (!image_data || !image_length) {
     OnPhotoError();
     return;
   }
 
-  mojom::BlobPtr blob = mojom::Blob::New();
+  media::mojom::BlobPtr blob = media::mojom::Blob::New();
   blob->data.assign(image_data, image_data + image_length);
   blob->mime_type = mime_type;
   photo_callback_->Run(std::move(blob));
   photo_callback_.reset();
 }
 
 void VideoCaptureDeviceMac::OnPhotoError() {
   DLOG(ERROR) << __FUNCTION__ << " error taking picture";
   photo_callback_.reset();
 }
@@ skipping 47 matching lines @@
 bool VideoCaptureDeviceMac::UpdateCaptureResolution() {
   if (![capture_device_ setCaptureHeight:capture_format_.frame_size.height()
                                    width:capture_format_.frame_size.width()
                                frameRate:capture_format_.frame_rate]) {
     ReceiveError(FROM_HERE, "Could not configure capture device.");
     return false;
   }
   return true;
 }
 
-}  // namespace media
+}  // namespace device