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

device/capture/video/video_capture_device.h

 // 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.
 //
 // VideoCaptureDevice is the abstract base class for realizing video capture
 // device support in Chromium. It provides the interface for OS dependent
 // implementations.
 // The class is created and functions are invoked on a thread owned by
 // VideoCaptureManager. Capturing is done on other threads, depending on the OS
 // specific implementation.
 
-#ifndef MEDIA_CAPTURE_VIDEO_VIDEO_CAPTURE_DEVICE_H_
-#define MEDIA_CAPTURE_VIDEO_VIDEO_CAPTURE_DEVICE_H_
+#ifndef DEVICE_CAPTURE_VIDEO_VIDEO_CAPTURE_DEVICE_H_
+#define DEVICE_CAPTURE_VIDEO_VIDEO_CAPTURE_DEVICE_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <list>
 #include <memory>
 #include <string>
 
 #include "base/callback.h"
 #include "base/files/file.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
+#include "device/capture/capture_export.h"
+#include "device/capture/video/scoped_result_callback.h"
+#include "device/capture/video/video_capture_device_descriptor.h"
 #include "media/base/video_capture_types.h"
 #include "media/base/video_frame.h"
-#include "media/capture/capture_export.h"
-#include "media/capture/video/scoped_result_callback.h"
-#include "media/capture/video/video_capture_device_descriptor.h"
 #include "media/mojo/interfaces/image_capture.mojom.h"
 #include "mojo/public/cpp/bindings/array.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 
 namespace tracked_objects {
 class Location;
 }  // namespace tracked_objects
 
-namespace media {
+namespace device {
+
+using media::VideoCaptureFormat;
+using media::VideoCaptureFormats;
+using media::VideoCaptureParams;
+using media::VideoFrame;
+using media::VideoFrameMetadata;
+using media::VideoPixelFormat;
+using media::VideoPixelStorage;
 
 class CAPTURE_EXPORT VideoCaptureDevice {
  public:
 
   // Interface defining the methods that clients of VideoCapture must have. It
   // is actually two-in-one: clients may implement OnIncomingCapturedData() or
   // ReserveOutputBuffer() + OnIncomingCapturedVideoFrame(), or all of them.
   // All clients must implement OnError().
   class CAPTURE_EXPORT Client {
    public:
@@ skipping 121 matching lines @@
   // memory associated with capture, and delete the |client| pointer passed into
   // AllocateAndStart.
   //
   // If deallocation is done asynchronously, then the device implementation must
   // ensure that a subsequent AllocateAndStart() operation targeting the same ID
   // would be sequenced through the same task runner, so that deallocation
   // happens first.
   virtual void StopAndDeAllocate() = 0;
 
   // Retrieve the photo capabilities of the device (e.g. zoom levels etc).
-  using GetPhotoCapabilitiesCallback =
-      ScopedResultCallback<base::Callback<void(mojom::PhotoCapabilitiesPtr)>>;
+  using GetPhotoCapabilitiesCallback = ScopedResultCallback<
+      base::Callback<void(media::mojom::PhotoCapabilitiesPtr)>>;
   virtual void GetPhotoCapabilities(GetPhotoCapabilitiesCallback callback);
 
   using SetPhotoOptionsCallback =
       ScopedResultCallback<base::Callback<void(bool)>>;
-  virtual void SetPhotoOptions(mojom::PhotoSettingsPtr settings,
+  virtual void SetPhotoOptions(media::mojom::PhotoSettingsPtr settings,
                                SetPhotoOptionsCallback callback);
 
   // Asynchronously takes a photo, possibly reconfiguring the capture objects
   // and/or interrupting the capture flow. Runs |callback| on the thread
   // where TakePhoto() is called, if the photo was successfully taken.
   using TakePhotoCallback =
-      ScopedResultCallback<base::Callback<void(mojom::BlobPtr blob)>>;
+      ScopedResultCallback<base::Callback<void(media::mojom::BlobPtr blob)>>;
   virtual void TakePhoto(TakePhotoCallback callback);
 
   // Gets the power line frequency, either from the params if specified by the
   // user or from the current system time zone.
-  PowerLineFrequency GetPowerLineFrequency(
+  media::PowerLineFrequency GetPowerLineFrequency(
       const VideoCaptureParams& params) const;
 
  private:
   // Gets the power line frequency from the current system time zone if this is
   // defined, otherwise returns 0.
-  PowerLineFrequency GetPowerLineFrequencyForLocation() const;
+  media::PowerLineFrequency GetPowerLineFrequencyForLocation() const;
 };
 
-}  // namespace media
+}  // namespace device
 
-#endif  // MEDIA_CAPTURE_VIDEO_VIDEO_CAPTURE_DEVICE_H_
+#endif  // DEVICE_CAPTURE_VIDEO_VIDEO_CAPTURE_DEVICE_H_