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

device/capture/device_monitor_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/device_monitor_mac.h"
+#include "device/capture/device_monitor_mac.h"
 
 #include <set>
 
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/mac/bind_objc_block.h"
 #include "base/mac/scoped_nsobject.h"
 #include "base/macros.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/task_runner_util.h"
@@ skipping 22 matching lines @@
 
  private:
   std::string unique_id_;
   DeviceType type_;
   // Allow generated copy constructor and assignment.
 };
 
 // Base abstract class used by DeviceMonitorMac.
 class DeviceMonitorMacImpl {
  public:
-  explicit DeviceMonitorMacImpl(media::DeviceMonitorMac* monitor)
+  explicit DeviceMonitorMacImpl(device::DeviceMonitorMac* monitor)
       : monitor_(monitor),
         cached_devices_(),
         device_arrival_(nil),
         device_removal_(nil) {
     DCHECK(monitor);
     // Initialise the devices_cache_ with a not-valid entry. For the case in
     // which there is one single device in the system and we get notified when
     // it gets removed, this will prevent the system from thinking that no
     // devices were added nor removed and not notifying the |monitor_|.
     cached_devices_.push_back(DeviceInfo("invalid", DeviceInfo::kInvalid));
   }
   virtual ~DeviceMonitorMacImpl() {}
 
   virtual void OnDeviceChanged() = 0;
 
   // Method called by the default notification center when a device is removed
   // or added to the system. It will compare the |cached_devices_| with the
   // current situation, update it, and, if there's an update, signal to
   // |monitor_| with the appropriate device type.
   void ConsolidateDevicesListAndNotify(
       const std::vector<DeviceInfo>& snapshot_devices);
 
  protected:
-  media::DeviceMonitorMac* monitor_;
+  device::DeviceMonitorMac* monitor_;
   std::vector<DeviceInfo> cached_devices_;
 
   // Handles to NSNotificationCenter block observers.
   id device_arrival_;
   id device_removal_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DeviceMonitorMacImpl);
 };
 
@@ skipping 207 matching lines @@
 }
 
 // AVFoundation implementation of the Mac Device Monitor, registers as a global
 // device connect/disconnect observer and plugs suspend/wake up device observers
 // per device. This class is created and lives on the main Application thread
 // (UI for content). Owns a SuspendObserverDelegate that notifies when a device
 // is suspended/resumed.
 class AVFoundationMonitorImpl : public DeviceMonitorMacImpl {
  public:
   AVFoundationMonitorImpl(
-      media::DeviceMonitorMac* monitor,
+      device::DeviceMonitorMac* monitor,
       const scoped_refptr<base::SingleThreadTaskRunner>& device_task_runner);
   ~AVFoundationMonitorImpl() override;
 
   void OnDeviceChanged() override;
 
  private:
   // {Video,AudioInput}DeviceManager's "Device" thread task runner used for
   // posting tasks to |suspend_observer_delegate_|;
   const scoped_refptr<base::SingleThreadTaskRunner> device_task_runner_;
 
   // Pegged to the "main" thread -- usually content::BrowserThread::UI.
   base::ThreadChecker main_thread_checker_;
 
   scoped_refptr<SuspendObserverDelegate> suspend_observer_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(AVFoundationMonitorImpl);
 };
 
 AVFoundationMonitorImpl::AVFoundationMonitorImpl(
-    media::DeviceMonitorMac* monitor,
+    device::DeviceMonitorMac* monitor,
     const scoped_refptr<base::SingleThreadTaskRunner>& device_task_runner)
     : DeviceMonitorMacImpl(monitor),
       device_task_runner_(device_task_runner),
       suspend_observer_delegate_(new SuspendObserverDelegate(this)) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   NSNotificationCenter* nc = [NSNotificationCenter defaultCenter];
   device_arrival_ =
       [nc addObserverForName:AVFoundationGlue::
                                  AVCaptureDeviceWasConnectedNotification()
                       object:nil
@@ skipping 99 matching lines @@
                        context:(void*)context {
   DCHECK(mainThreadChecker_.CalledOnValidThread());
   if ([keyPath isEqual:@"suspended"])
     onDeviceChangedCallback_.Run();
   if ([keyPath isEqual:@"connected"])
     [self stopObserving:static_cast<CrAVCaptureDevice*>(context)];
 }
 
 @end  // @implementation CrAVFoundationDeviceObserver
 
-namespace media {
+namespace device {
 
 DeviceMonitorMac::DeviceMonitorMac() {
   // AVFoundation do not need to be fired up until the user
   // exercises a GetUserMedia. Bringing up either library and enumerating the
   // devices in the system is an operation taking in the range of hundred of ms,
   // so it is triggered explicitly from MediaStreamManager::StartMonitoring().
 }
 
 DeviceMonitorMac::~DeviceMonitorMac() {}
 
@@ skipping 14 matching lines @@
         new AVFoundationMonitorImpl(this, device_task_runner));
 }
 
 void DeviceMonitorMac::NotifyDeviceChanged(
     base::SystemMonitor::DeviceType type) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // TODO(xians): Remove the global variable for SystemMonitor.
   base::SystemMonitor::Get()->ProcessDevicesChanged(type);
 }
 
-}  // namespace media
+}  // namespace device