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

device/capture/video/mac/video_capture_device_decklink_mac.mm

 // Copyright 2014 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_decklink_mac.h"
+#include "device/capture/video/mac/video_capture_device_decklink_mac.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "third_party/decklink/mac/include/DeckLinkAPI.h"
 
@@ skipping 25 matching lines @@
 
 // This class is used to interact directly with DeckLink SDK for video capture.
 // Implements the reference counted interface IUnknown. Has a weak reference to
 // VideoCaptureDeviceDeckLinkMac for sending captured frames, error messages and
 // logs.
 class DeckLinkCaptureDelegate
     : public IDeckLinkInputCallback,
       public base::RefCountedThreadSafe<DeckLinkCaptureDelegate> {
  public:
   DeckLinkCaptureDelegate(
-      const media::VideoCaptureDeviceDescriptor& device_descriptor,
-      media::VideoCaptureDeviceDeckLinkMac* frame_receiver);
+      const device::VideoCaptureDeviceDescriptor& device_descriptor,
+      device::VideoCaptureDeviceDeckLinkMac* frame_receiver);
 
   void AllocateAndStart(const media::VideoCaptureParams& params);
   void StopAndDeAllocate();
 
   // Remove the VideoCaptureDeviceDeckLinkMac's weak reference.
   void ResetVideoCaptureDeviceReference();
 
  private:
   // IDeckLinkInputCallback interface implementation.
   HRESULT VideoInputFormatChanged(
       BMDVideoInputFormatChangedEvents notification_events,
       IDeckLinkDisplayMode* new_display_mode,
       BMDDetectedVideoInputFormatFlags detected_signal_flags) override;
   HRESULT VideoInputFrameArrived(
       IDeckLinkVideoInputFrame* video_frame,
       IDeckLinkAudioInputPacket* audio_packet) override;
 
   // IUnknown interface implementation.
   HRESULT QueryInterface(REFIID iid, void** ppv) override;
   ULONG AddRef() override;
   ULONG Release() override;
 
   // Forwarder to VideoCaptureDeviceDeckLinkMac::SendErrorString().
   void SendErrorString(const tracked_objects::Location& from_here,
                        const std::string& reason);
 
   // Forwarder to VideoCaptureDeviceDeckLinkMac::SendLogString().
   void SendLogString(const std::string& message);
 
-  const media::VideoCaptureDeviceDescriptor device_descriptor_;
+  const device::VideoCaptureDeviceDescriptor device_descriptor_;
 
   // Protects concurrent setting and using of |frame_receiver_|.
   base::Lock lock_;
   // Weak reference to the captured frames client, used also for error messages
   // and logging. Initialized on construction and used until cleared by calling
   // ResetVideoCaptureDeviceReference().
-  media::VideoCaptureDeviceDeckLinkMac* frame_receiver_;
+  device::VideoCaptureDeviceDeckLinkMac* frame_receiver_;
 
   // This is used to control the video capturing device input interface.
   ScopedDeckLinkPtr<IDeckLinkInput> decklink_input_;
   // |decklink_| represents a physical device attached to the host.
   ScopedDeckLinkPtr<IDeckLink> decklink_;
 
   base::TimeTicks first_ref_time_;
 
   // Checks for Device (a.k.a. Audio) thread.
   base::ThreadChecker thread_checker_;
@@ skipping 17 matching lines @@
   // Interlaced formats are going to be marked as double the frame rate,
   // which follows the general naming convention.
   if (display_mode->GetFieldDominance() == bmdLowerFieldFirst ||
       display_mode->GetFieldDominance() == bmdUpperFieldFirst) {
     display_mode_frame_rate *= 2.0f;
   }
   return display_mode_frame_rate;
 }
 
 DeckLinkCaptureDelegate::DeckLinkCaptureDelegate(
-    const media::VideoCaptureDeviceDescriptor& device_descriptor,
-    media::VideoCaptureDeviceDeckLinkMac* frame_receiver)
+    const device::VideoCaptureDeviceDescriptor& device_descriptor,
+    device::VideoCaptureDeviceDeckLinkMac* frame_receiver)
     : device_descriptor_(device_descriptor), frame_receiver_(frame_receiver) {}
 
 DeckLinkCaptureDelegate::~DeckLinkCaptureDelegate() {
 }
 
 void DeckLinkCaptureDelegate::AllocateAndStart(
     const media::VideoCaptureParams& params) {
   DCHECK(thread_checker_.CalledOnValidThread());
   scoped_refptr<IDeckLinkIterator> decklink_iter(
       CreateDeckLinkIteratorInstance());
@@ skipping 184 matching lines @@
 }
 
 void DeckLinkCaptureDelegate::ResetVideoCaptureDeviceReference() {
   DCHECK(thread_checker_.CalledOnValidThread());
   base::AutoLock lock(lock_);
   frame_receiver_ = NULL;
 }
 
 }  // namespace
 
-namespace media {
+namespace device {
 
 static std::string JoinDeviceNameAndFormat(CFStringRef name,
                                            CFStringRef format) {
   return base::SysCFStringRefToUTF8(name) + " - " +
          base::SysCFStringRefToUTF8(format);
 }
 
 // static
 void VideoCaptureDeviceDeckLinkMac::EnumerateDevices(
     VideoCaptureDeviceDescriptors* device_descriptors) {
@@ skipping 94 matching lines @@
               JoinDeviceNameAndFormat(device_model_name, format_name)) {
         display_mode.Release();
         continue;
       }
 
       // IDeckLinkDisplayMode does not have information on pixel format, this
       // is only available on capture.
       const media::VideoCaptureFormat format(
           gfx::Size(display_mode->GetWidth(), display_mode->GetHeight()),
           GetDisplayModeFrameRate(display_mode),
-          PIXEL_FORMAT_UNKNOWN);
+          media::PIXEL_FORMAT_UNKNOWN);
       supported_formats->push_back(format);
       DVLOG(2) << device.display_name << " "
                << VideoCaptureFormat::ToString(format);
       display_mode.Release();
     }
     return;
   }
 }
 
 VideoCaptureDeviceDeckLinkMac::VideoCaptureDeviceDeckLinkMac(
@@ skipping 42 matching lines @@
   client_ = std::move(client);
   if (decklink_capture_delegate_.get())
     decklink_capture_delegate_->AllocateAndStart(params);
 }
 
 void VideoCaptureDeviceDeckLinkMac::StopAndDeAllocate() {
   if (decklink_capture_delegate_.get())
     decklink_capture_delegate_->StopAndDeAllocate();
 }
 
-}  // namespace media
+}  // namespace device