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

device/capture/video/fake_video_capture_device.cc

Index: device/capture/video/fake_video_capture_device.cc
diff --git a/media/capture/video/fake_video_capture_device.cc b/device/capture/video/fake_video_capture_device.cc
similarity index 87%
rename from media/capture/video/fake_video_capture_device.cc
rename to device/capture/video/fake_video_capture_device.cc
index 698588f3ecb13104696a0bb1afc4622178c482c9..e60a9dfef756a23921e05b361d22d7bb19098fe2 100644
--- a/media/capture/video/fake_video_capture_device.cc
+++ b/device/capture/video/fake_video_capture_device.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "media/capture/video/fake_video_capture_device.h"
+#include "device/capture/video/fake_video_capture_device.h"
 
 #include <stddef.h>
 #include <algorithm>
@@ -22,7 +22,7 @@
 #include "third_party/skia/include/core/SkPaint.h"
 #include "ui/gfx/codec/png_codec.h"
 
-namespace media {
+namespace device {
 
 // Sweep at 600 deg/sec.
 static const float kPacmanAngularVelocity = 600;
@@ -96,12 +96,12 @@ void DoTakeFakePhoto(VideoCaptureDevice::TakePhotoCallback callback,
                      float fake_capture_rate,
                      uint32_t zoom) {
   std::unique_ptr<uint8_t[]> buffer(new uint8_t[VideoFrame::AllocationSize(
-      PIXEL_FORMAT_ARGB, capture_format.frame_size)]);
+      media::PIXEL_FORMAT_ARGB, capture_format.frame_size)]);
 
   DrawPacman(true /* use_argb */, buffer.get(), elapsed_time, fake_capture_rate,
              capture_format.frame_size, zoom);
 
-  mojom::BlobPtr blob = mojom::Blob::New();
+  media::mojom::BlobPtr blob = media::mojom::Blob::New();
   const bool result = gfx::PNGCodec::Encode(
       buffer.get(), gfx::PNGCodec::FORMAT_RGBA, capture_format.frame_size,
       capture_format.frame_size.width() * 4, true /* discard_transparency */,
@@ -144,18 +144,18 @@ void FakeVideoCaptureDevice::AllocateAndStart(
     capture_format_.frame_size.SetSize(320, 240);
 
   if (buffer_ownership_ == BufferOwnership::CLIENT_BUFFERS) {
-    capture_format_.pixel_storage = PIXEL_STORAGE_CPU;
-    capture_format_.pixel_format = PIXEL_FORMAT_ARGB;
+    capture_format_.pixel_storage = media::PIXEL_STORAGE_CPU;
+    capture_format_.pixel_format = media::PIXEL_FORMAT_ARGB;
     DVLOG(1) << "starting with client argb buffers";
   } else if (buffer_ownership_ == BufferOwnership::OWN_BUFFERS) {
-    capture_format_.pixel_storage = PIXEL_STORAGE_CPU;
-    capture_format_.pixel_format = PIXEL_FORMAT_I420;
+    capture_format_.pixel_storage = media::PIXEL_STORAGE_CPU;
+    capture_format_.pixel_format = media::PIXEL_FORMAT_I420;
     DVLOG(1) << "starting with own I420 buffers";
   }
 
-  if (capture_format_.pixel_format == PIXEL_FORMAT_I420) {
+  if (capture_format_.pixel_format == media::PIXEL_FORMAT_I420) {
     fake_frame_.reset(new uint8_t[VideoFrame::AllocationSize(
-        PIXEL_FORMAT_I420, capture_format_.frame_size)]);
+        media::PIXEL_FORMAT_I420, capture_format_.frame_size)]);
   }
 
   beep_time_ = base::TimeDelta();
@@ -180,31 +180,32 @@ void FakeVideoCaptureDevice::StopAndDeAllocate() {
 
 void FakeVideoCaptureDevice::GetPhotoCapabilities(
     GetPhotoCapabilitiesCallback callback) {
-  mojom::PhotoCapabilitiesPtr photo_capabilities =
-      mojom::PhotoCapabilities::New();
-  photo_capabilities->iso = mojom::Range::New();
+  media::mojom::PhotoCapabilitiesPtr photo_capabilities =
+      media::mojom::PhotoCapabilities::New();
+  photo_capabilities->iso = media::mojom::Range::New();
   photo_capabilities->iso->current = 100;
   photo_capabilities->iso->max = 100;
   photo_capabilities->iso->min = 100;
-  photo_capabilities->height = mojom::Range::New();
+  photo_capabilities->height = media::mojom::Range::New();
   photo_capabilities->height->current = capture_format_.frame_size.height();
   photo_capabilities->height->max = 1080;
   photo_capabilities->height->min = 240;
-  photo_capabilities->width = mojom::Range::New();
+  photo_capabilities->width = media::mojom::Range::New();
   photo_capabilities->width->current = capture_format_.frame_size.width();
   photo_capabilities->width->max = 1920;
   photo_capabilities->width->min = 320;
-  photo_capabilities->focus_mode = mojom::FocusMode::UNAVAILABLE;
-  photo_capabilities->zoom = mojom::Range::New();
+  photo_capabilities->focus_mode = media::mojom::FocusMode::UNAVAILABLE;
+  photo_capabilities->zoom = media::mojom::Range::New();
   photo_capabilities->zoom->current = current_zoom_;
   photo_capabilities->zoom->max = kMaxZoom;
   photo_capabilities->zoom->min = kMinZoom;
-  photo_capabilities->focus_mode = mojom::FocusMode::UNAVAILABLE;
+  photo_capabilities->focus_mode = media::mojom::FocusMode::UNAVAILABLE;
   callback.Run(std::move(photo_capabilities));
 }
 
-void FakeVideoCaptureDevice::SetPhotoOptions(mojom::PhotoSettingsPtr settings,
-                                             SetPhotoOptionsCallback callback) {
+void FakeVideoCaptureDevice::SetPhotoOptions(
+    media::mojom::PhotoSettingsPtr settings,
+    SetPhotoOptionsCallback callback) {
   if (settings->has_zoom)
     current_zoom_ = std::max(kMinZoom, std::min(settings->zoom, kMaxZoom));
   callback.Run(true);
@@ -250,7 +251,7 @@ void FakeVideoCaptureDevice::CaptureUsingClientBuffers(
   DLOG_IF(ERROR, !capture_buffer) << "Couldn't allocate Capture Buffer";
   DCHECK(capture_buffer->data()) << "Buffer has NO backing memory";
 
-  if (capture_format_.pixel_storage == PIXEL_STORAGE_GPUMEMORYBUFFER &&
+  if (capture_format_.pixel_storage == media::PIXEL_STORAGE_GPUMEMORYBUFFER &&
       capture_format_.pixel_format == media::PIXEL_FORMAT_I420) {
     // Since SkBitmap expects a packed&continuous memory region for I420, we
     // need to use |fake_frame_| to draw onto.
@@ -260,17 +261,18 @@ void FakeVideoCaptureDevice::CaptureUsingClientBuffers(
 
     // Copy data from |fake_frame_| into the reserved planes of GpuMemoryBuffer.
     size_t offset = 0;
-    for (size_t i = 0; i < VideoFrame::NumPlanes(PIXEL_FORMAT_I420); ++i) {
+    for (size_t i = 0; i < VideoFrame::NumPlanes(media::PIXEL_FORMAT_I420);
+         ++i) {
       const size_t plane_size =
-          VideoFrame::PlaneSize(PIXEL_FORMAT_I420, i,
+          VideoFrame::PlaneSize(media::PIXEL_FORMAT_I420, i,
                                 capture_format_.frame_size)
               .GetArea();
       memcpy(capture_buffer->data(i), fake_frame_.get() + offset, plane_size);
       offset += plane_size;
     }
   } else {
-    DCHECK_EQ(capture_format_.pixel_storage, PIXEL_STORAGE_CPU);
-    DCHECK_EQ(capture_format_.pixel_format, PIXEL_FORMAT_ARGB);
+    DCHECK_EQ(capture_format_.pixel_storage, media::PIXEL_STORAGE_CPU);
+    DCHECK_EQ(capture_format_.pixel_format, media::PIXEL_FORMAT_ARGB);
     uint8_t* data_ptr = static_cast<uint8_t*>(capture_buffer->data());
     memset(data_ptr, 0, capture_buffer->mapped_size());
     DrawPacman(true /* use_argb */, data_ptr, elapsed_time_, fake_capture_rate_,
@@ -302,7 +304,7 @@ void FakeVideoCaptureDevice::BeepAndScheduleNextCapture(
 
   // Generate a synchronized beep twice per second.
   if (beep_time_ >= beep_interval) {
-    FakeAudioInputStream::BeepOnce();
+    media::FakeAudioInputStream::BeepOnce();
     beep_time_ -= beep_interval;
   }
 
@@ -317,4 +319,4 @@ void FakeVideoCaptureDevice::BeepAndScheduleNextCapture(
       FROM_HERE, base::Bind(next_capture, next_execution_time), delay);
 }
 
-}  // namespace media
+}  // namespace device