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

content/browser/media/capture/web_contents_video_capture_device_unittest.cc

 // 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 "content/browser/media/capture/web_contents_video_capture_device.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 307 matching lines @@
   }
 
  private:
   CaptureTestSourceController* controller_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(CaptureTestRenderViewHostFactory);
 };
 
 // A stub consumer of captured video frames, which checks the output of
 // WebContentsVideoCaptureDevice.
-class StubClient : public media::VideoCaptureDevice::Client {
+class StubClient : public device::VideoCaptureDevice::Client {
  public:
   StubClient(
       const base::Callback<void(SkColor, const gfx::Size&)>& report_callback,
       const base::Closure& error_callback)
       : report_callback_(report_callback),
         error_callback_(error_callback) {
     buffer_pool_ = new VideoCaptureBufferPool(2);
   }
   ~StubClient() override {}
 
   MOCK_METHOD6(OnIncomingCapturedData,
                void(const uint8_t* data,
                     int length,
                     const media::VideoCaptureFormat& frame_format,
                     int rotation,
                     base::TimeTicks reference_time,
                     base::TimeDelta timestamp));
 
   MOCK_METHOD0(DoOnIncomingCapturedBuffer, void(void));
 
-  std::unique_ptr<media::VideoCaptureDevice::Client::Buffer>
+  std::unique_ptr<device::VideoCaptureDevice::Client::Buffer>
   ReserveOutputBuffer(const gfx::Size& dimensions,
                       media::VideoPixelFormat format,
                       media::VideoPixelStorage storage) override {
     CHECK_EQ(format, media::PIXEL_FORMAT_I420);
     int buffer_id_to_drop = VideoCaptureBufferPool::kInvalidId;  // Ignored.
     const int buffer_id = buffer_pool_->ReserveForProducer(
         dimensions, format, storage, &buffer_id_to_drop);
     if (buffer_id == VideoCaptureBufferPool::kInvalidId)
       return NULL;
 
-    return std::unique_ptr<media::VideoCaptureDevice::Client::Buffer>(
+    return std::unique_ptr<device::VideoCaptureDevice::Client::Buffer>(
         new AutoReleaseBuffer(
             buffer_pool_, buffer_pool_->GetBufferHandle(buffer_id), buffer_id));
   }
 
   // Trampoline method to workaround GMOCK problems with std::unique_ptr<>.
   void OnIncomingCapturedBuffer(std::unique_ptr<Buffer> buffer,
                                 const media::VideoCaptureFormat& frame_format,
                                 base::TimeTicks reference_time,
                                 base::TimeDelta timestamp) override {
     DoOnIncomingCapturedBuffer();
@@ skipping 20 matching lines @@
     const int center_offset_uv =
         (frame->stride(VideoFrame::kUPlane) * (center.y() / 2)) +
             (center.x() / 2);
     report_callback_.Run(
         SkColorSetRGB(frame->data(VideoFrame::kYPlane)[center_offset_y],
                       frame->data(VideoFrame::kUPlane)[center_offset_uv],
                       frame->data(VideoFrame::kVPlane)[center_offset_uv]),
         frame->visible_rect().size());
   }
 
-  std::unique_ptr<media::VideoCaptureDevice::Client::Buffer>
+  std::unique_ptr<device::VideoCaptureDevice::Client::Buffer>
   ResurrectLastOutputBuffer(const gfx::Size& dimensions,
                             media::VideoPixelFormat format,
                             media::VideoPixelStorage storage) override {
     CHECK_EQ(format, media::PIXEL_FORMAT_I420);
     const int buffer_id =
         buffer_pool_->ResurrectLastForProducer(dimensions, format, storage);
     if (buffer_id == VideoCaptureBufferPool::kInvalidId)
       return nullptr;
-    return std::unique_ptr<media::VideoCaptureDevice::Client::Buffer>(
+    return std::unique_ptr<device::VideoCaptureDevice::Client::Buffer>(
         new AutoReleaseBuffer(
             buffer_pool_, buffer_pool_->GetBufferHandle(buffer_id), buffer_id));
   }
 
   void OnError(const tracked_objects::Location& from_here,
                const std::string& reason) override {
     error_callback_.Run();
   }
 
   double GetBufferPoolUtilization() const override { return 0.0; }
 
  private:
-  class AutoReleaseBuffer : public media::VideoCaptureDevice::Client::Buffer {
+  class AutoReleaseBuffer : public device::VideoCaptureDevice::Client::Buffer {
    public:
     AutoReleaseBuffer(
         const scoped_refptr<VideoCaptureBufferPool>& pool,
         std::unique_ptr<VideoCaptureBufferPool::BufferHandle> buffer_handle,
         int buffer_id)
         : id_(buffer_id),
           pool_(pool),
           buffer_handle_(std::move(buffer_handle)) {
       DCHECK(pool_);
     }
@@ skipping 33 matching lines @@
       : error_encountered_(false),
         wait_color_yuv_(0xcafe1950) {
     client_.reset(new StubClient(
         base::Bind(&StubClientObserver::DidDeliverFrame,
                    base::Unretained(this)),
         base::Bind(&StubClientObserver::OnError, base::Unretained(this))));
   }
 
   virtual ~StubClientObserver() {}
 
-  std::unique_ptr<media::VideoCaptureDevice::Client> PassClient() {
+  std::unique_ptr<device::VideoCaptureDevice::Client> PassClient() {
     return std::move(client_);
   }
 
   void QuitIfConditionsMet(SkColor color, const gfx::Size& size) {
     base::AutoLock guard(lock_);
     if (error_encountered_ || wait_color_yuv_ == kNotInterested ||
         wait_color_yuv_ == color) {
       last_frame_color_yuv_ = color;
       last_frame_size_ = size;
       base::MessageLoop::current()->QuitWhenIdle();
@@ skipping 161 matching lines @@
     render_frame_host_factory_.reset();
     render_view_host_factory_.reset();
     render_process_host_factory_.reset();
 
     display::Screen::SetScreenInstance(nullptr);
   }
 
   // Accessors.
   CaptureTestSourceController* source() { return &controller_; }
   WebContents* web_contents() const { return web_contents_.get(); }
-  media::VideoCaptureDevice* device() { return device_.get(); }
+  device::VideoCaptureDevice* device() { return device_.get(); }
 
   // Returns the device scale factor of the capture target's native view.  This
   // is necessary because, architecturally, the TestScreen implementation is
   // ignored on Mac platforms (when determining the device scale factor for a
   // particular window).
   float GetDeviceScaleFactor() const {
     RenderWidgetHostView* const view =
         web_contents_->GetRenderViewHost()->GetWidget()->GetView();
     CHECK(view);
     return ui::GetScaleFactorForNativeView(view->GetNativeView());
@@ skipping 70 matching lines @@
     base::RunLoop run_loop;
     BrowserThread::PostDelayedTask(
         BrowserThread::UI, FROM_HERE,
         run_loop.QuitClosure(),
         base::TimeDelta::FromMicroseconds(
             3 * base::Time::kMicrosecondsPerSecond / kTestFramesPerSecond));
     run_loop.Run();
 
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
-        base::Bind(&media::VideoCaptureDevice::RequestRefreshFrame,
+        base::Bind(&device::VideoCaptureDevice::RequestRefreshFrame,
                    base::Unretained(device_.get())));
   }
 
   void DestroyVideoCaptureDevice() { device_.reset(); }
 
   StubClientObserver* client_observer() {
     return &client_observer_;
   }
 
  private:
@@ skipping 12 matching lines @@
   std::unique_ptr<CaptureTestRenderViewHostFactory> render_view_host_factory_;
 
   // Self-registering RenderFrameHostFactory.
   std::unique_ptr<TestRenderFrameHostFactory> render_frame_host_factory_;
 
   // A mocked-out browser and tab.
   std::unique_ptr<TestBrowserContext> browser_context_;
   std::unique_ptr<WebContents> web_contents_;
 
   // Finally, the WebContentsVideoCaptureDevice under test.
-  std::unique_ptr<media::VideoCaptureDevice> device_;
+  std::unique_ptr<device::VideoCaptureDevice> device_;
 
   TestBrowserThreadBundle thread_bundle_;
 };
 
 TEST_F(MAYBE_WebContentsVideoCaptureDeviceTest,
        InvalidInitialWebContentsError) {
   // Before the installs itself on the UI thread up to start capturing, we'll
   // delete the web contents. This should trigger an error which can happen in
   // practice; we should be able to recover gracefully.
   ResetWebContents();
@@ skipping 415 matching lines @@
   for (int i = 0; i < 3; ++i) {
     SimulateRefreshFrameRequest();
     ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColor(SK_ColorGREEN));
   }
 
   device()->StopAndDeAllocate();
 }
 
 }  // namespace
 }  // namespace content