Move classses VideoCaptureDeviceClient and VideoCaptureBufferPool to media/capture/video

content/browser/renderer_host/media/video_capture_buffer_pool_unittest.cc

 // Copyright (c) 2013 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.
 
 // Unit test for VideoCaptureBufferPool.
+// Note that this test does not exercise the class VideoCaptureBufferPool
+// in isolation. The "unit under test" is an instance of VideoCaptureBufferPool
+// with some context that is specific to renderer_host/media, and therefore
+// this test must lives here and not in media/capture/video.

[mcasas, 2016/09/22 21:41:56]

s/lives/live/

File-class comments are rare in Chromium, I'd say
peg it to the VideoCaptureBufferPoolTest class.

[chfremer, 2016/09/22 23:41:52]

Done.

 
-#include "content/browser/renderer_host/media/video_capture_buffer_pool.h"
+#include "media/capture/video/video_capture_buffer_pool.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "build/build_config.h"
 #include "cc/test/test_context_provider.h"
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "components/display_compositor/buffer_queue.h"
 #include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
-#include "content/browser/renderer_host/media/video_capture_buffer_handle.h"
+#include "content/browser/renderer_host/media/renderer_host_video_capture_buffer_tracker_factory.h"
 #include "content/browser/renderer_host/media/video_capture_controller.h"
 #include "media/base/video_frame.h"
+#include "media/capture/video/video_capture_buffer_pool_impl.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 struct PixelFormatAndStorage {
   media::VideoPixelFormat pixel_format;
   media::VideoPixelStorage pixel_storage;
 };
 
@@ skipping 72 matching lines @@
         gfx::BufferUsage usage,
         gpu::SurfaceHandle surface_handle) override {
       return base::MakeUnique<MockGpuMemoryBuffer>(size);
     }
   };
 #endif
 
   // This is a generic Buffer tracker
   class Buffer {
    public:
-    Buffer(const scoped_refptr<VideoCaptureBufferPool> pool,
-           std::unique_ptr<VideoCaptureBufferHandle> buffer_handle,
+    Buffer(const scoped_refptr<media::VideoCaptureBufferPool> pool,
+           std::unique_ptr<media::VideoCaptureBufferHandle> buffer_handle,
            int id)
         : id_(id), pool_(pool), buffer_handle_(std::move(buffer_handle)) {}
     ~Buffer() { pool_->RelinquishProducerReservation(id()); }
     int id() const { return id_; }
     size_t mapped_size() { return buffer_handle_->mapped_size(); }
     void* data() { return buffer_handle_->data(0); }
 
    private:
     const int id_;
-    const scoped_refptr<VideoCaptureBufferPool> pool_;
-    const std::unique_ptr<VideoCaptureBufferHandle> buffer_handle_;
+    const scoped_refptr<media::VideoCaptureBufferPool> pool_;
+    const std::unique_ptr<media::VideoCaptureBufferHandle> buffer_handle_;
   };
 
   VideoCaptureBufferPoolTest()
       : expected_dropped_id_(0),
-        pool_(new VideoCaptureBufferPoolImpl(kTestBufferPoolSize)) {}
+        pool_(new media::VideoCaptureBufferPoolImpl(
+            base::MakeUnique<RendererHostVideoCaptureBufferTrackerFactory>(),
+            kTestBufferPoolSize)) {}
 
 #if !defined(OS_ANDROID)
   void SetUp() override {
     gpu_memory_buffer_manager_.reset(new StubBrowserGpuMemoryBufferManager);
   }
 #endif
 
   void ExpectDroppedId(int expected_dropped_id) {
     expected_dropped_id_ = expected_dropped_id;
   }
 
   std::unique_ptr<Buffer> ReserveBuffer(
       const gfx::Size& dimensions,
       PixelFormatAndStorage format_and_storage) {
     // To verify that ReserveBuffer always sets |buffer_id_to_drop|,
     // initialize it to something different than the expected value.
     int buffer_id_to_drop = ~expected_dropped_id_;
     DVLOG(1) << media::VideoCaptureFormat::PixelStorageToString(
                     format_and_storage.pixel_storage) << " "
              << media::VideoPixelFormatToString(format_and_storage.pixel_format)
              << " " << dimensions.ToString();
     const int buffer_id = pool_->ReserveForProducer(
         dimensions, format_and_storage.pixel_format,
         format_and_storage.pixel_storage, &buffer_id_to_drop);
-    if (buffer_id == VideoCaptureBufferPool::kInvalidId)
+    if (buffer_id == media::VideoCaptureBufferPool::kInvalidId)
       return std::unique_ptr<Buffer>();
     EXPECT_EQ(expected_dropped_id_, buffer_id_to_drop);
 
-    std::unique_ptr<VideoCaptureBufferHandle> buffer_handle =
+    std::unique_ptr<media::VideoCaptureBufferHandle> buffer_handle =
         pool_->GetBufferHandle(buffer_id);
     return std::unique_ptr<Buffer>(
         new Buffer(pool_, std::move(buffer_handle), buffer_id));
   }
 
   std::unique_ptr<Buffer> ResurrectLastBuffer(
       const gfx::Size& dimensions,
       PixelFormatAndStorage format_and_storage) {
     const int buffer_id = pool_->ResurrectLastForProducer(
         dimensions, format_and_storage.pixel_format,
         format_and_storage.pixel_storage);
-    if (buffer_id == VideoCaptureBufferPool::kInvalidId)
+    if (buffer_id == media::VideoCaptureBufferPool::kInvalidId)
       return std::unique_ptr<Buffer>();
     return std::unique_ptr<Buffer>(
         new Buffer(pool_, pool_->GetBufferHandle(buffer_id), buffer_id));
   }
 
   base::MessageLoop loop_;
   int expected_dropped_id_;
-  scoped_refptr<VideoCaptureBufferPool> pool_;
+  scoped_refptr<media::VideoCaptureBufferPool> pool_;
 
  private:
 #if !defined(OS_ANDROID)
   std::unique_ptr<StubBrowserGpuMemoryBufferManager> gpu_memory_buffer_manager_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureBufferPoolTest);
 };
 
 TEST_P(VideoCaptureBufferPoolTest, BufferPool) {
   const gfx::Size size_lo = gfx::Size(10, 10);
   const gfx::Size size_hi = gfx::Size(21, 33);
   const media::VideoCaptureFormat format_lo(
       size_lo, 0.0, GetParam().pixel_format, GetParam().pixel_storage);
   const media::VideoCaptureFormat format_hi(
       size_hi, 0.0, GetParam().pixel_format, GetParam().pixel_storage);
 
   // Reallocation won't happen for the first part of the test.
-  ExpectDroppedId(VideoCaptureBufferPool::kInvalidId);
+  ExpectDroppedId(media::VideoCaptureBufferPool::kInvalidId);
 
   // The buffer pool should have zero utilization before any buffers have been
   // reserved.
   ASSERT_EQ(0.0, pool_->GetBufferPoolUtilization());
 
   std::unique_ptr<Buffer> buffer1 = ReserveBuffer(size_lo, GetParam());
   ASSERT_NE(nullptr, buffer1.get());
   ASSERT_EQ(1.0 / kTestBufferPoolSize, pool_->GetBufferPoolUtilization());
   std::unique_ptr<Buffer> buffer2 = ReserveBuffer(size_lo, GetParam());
   ASSERT_NE(nullptr, buffer2.get());
@@ skipping 109 matching lines @@
   ExpectDroppedId(buffer_id2);
   ASSERT_EQ(2.0 / kTestBufferPoolSize, pool_->GetBufferPoolUtilization());
   buffer2 = ReserveBuffer(size_hi, GetParam());
   ASSERT_NE(nullptr, buffer2.get());
   if (GetParam().pixel_storage != media::PIXEL_STORAGE_GPUMEMORYBUFFER)
     ASSERT_LE(format_hi.ImageAllocationSize(), buffer2->mapped_size());
   ASSERT_EQ(3, buffer2->id());
   ASSERT_EQ(3.0 / kTestBufferPoolSize, pool_->GetBufferPoolUtilization());
   void* const memory_pointer_hi = buffer2->data();
   buffer2.reset();  // Frees it.
-  ExpectDroppedId(VideoCaptureBufferPool::kInvalidId);
+  ExpectDroppedId(media::VideoCaptureBufferPool::kInvalidId);
   ASSERT_EQ(2.0 / kTestBufferPoolSize, pool_->GetBufferPoolUtilization());
   buffer2 = ReserveBuffer(size_lo, GetParam());
   void* const memory_pointer_lo = buffer2->data();
   ASSERT_EQ(memory_pointer_hi, memory_pointer_lo)
       << "Decrease in resolution should not reallocate buffer";
   ASSERT_NE(nullptr, buffer2.get());
   ASSERT_EQ(3, buffer2->id());
   if (GetParam().pixel_storage != media::PIXEL_STORAGE_GPUMEMORYBUFFER)
     ASSERT_LE(format_lo.ImageAllocationSize(), buffer2->mapped_size());
   ASSERT_EQ(3.0 / kTestBufferPoolSize, pool_->GetBufferPoolUtilization());
@@ skipping 14 matching lines @@
   buffer2.reset();
 
   if (buffer4->data() != nullptr)
     memset(buffer4->data(), 0x77, buffer4->mapped_size());
   buffer4.reset();
 }
 
 // Tests that a previously-released buffer can be immediately resurrected under
 // normal conditions.
 TEST_P(VideoCaptureBufferPoolTest, ResurrectsLastBuffer) {
-  ExpectDroppedId(VideoCaptureBufferPool::kInvalidId);
+  ExpectDroppedId(media::VideoCaptureBufferPool::kInvalidId);
 
   // At the start, there should be nothing to resurrect.
   std::unique_ptr<Buffer> resurrected =
       ResurrectLastBuffer(gfx::Size(10, 10), GetParam());
   ASSERT_EQ(nullptr, resurrected.get());
 
   // Reserve a 10x10 buffer and fill it with 0xab values.
   std::unique_ptr<Buffer> original =
       ReserveBuffer(gfx::Size(10, 10), GetParam());
   ASSERT_NE(nullptr, original.get());
@@ skipping 23 matching lines @@
   resurrected = ResurrectLastBuffer(gfx::Size(10, 10), GetParam());
   ASSERT_NE(nullptr, resurrected.get());
   ASSERT_EQ(original_mapped_size, resurrected->mapped_size());
   resurrected_memory = reinterpret_cast<uint8_t*>(resurrected->data());
   for (size_t i = 0; i < original_mapped_size; ++i)
     EXPECT_EQ(0xbc, resurrected_memory[i]) << "Mismatch at byte offset: " << i;
 }
 
 // Tests that a buffer cannot be resurrected if its properties do not match.
 TEST_P(VideoCaptureBufferPoolTest, DoesNotResurrectIfPropertiesNotMatched) {
-  ExpectDroppedId(VideoCaptureBufferPool::kInvalidId);
+  ExpectDroppedId(media::VideoCaptureBufferPool::kInvalidId);
 
   // Reserve a 10x10 buffer, fill it with 0xcd values, and release it.
   std::unique_ptr<Buffer> original =
       ReserveBuffer(gfx::Size(10, 10), GetParam());
   ASSERT_NE(nullptr, original.get());
   const size_t original_mapped_size = original->mapped_size();
   memset(original->data(), 0xcd, original_mapped_size);
   original.reset();
 
   // Expect that the buffer cannot be resurrected if the dimensions do not
@@ skipping 29 matching lines @@
   ASSERT_NE(nullptr, resurrected.get());
   ASSERT_EQ(original_mapped_size, resurrected->mapped_size());
   uint8_t* resurrected_memory = reinterpret_cast<uint8_t*>(resurrected->data());
   for (size_t i = 0; i < original_mapped_size; ++i)
     EXPECT_EQ(0xcd, resurrected_memory[i]) << "Mismatch at byte offset: " << i;
 }
 
 // Tests that the buffers are managed by the pool such that the last-released
 // buffer is kept around as long as possible (for successful resurrection).
 TEST_P(VideoCaptureBufferPoolTest, AvoidsClobberingForResurrectingLastBuffer) {
-  ExpectDroppedId(VideoCaptureBufferPool::kInvalidId);
+  ExpectDroppedId(media::VideoCaptureBufferPool::kInvalidId);
 
   // Reserve a 10x10 buffer, fill it with 0xde values, and release it.
   std::unique_ptr<Buffer> original =
       ReserveBuffer(gfx::Size(10, 10), GetParam());
   ASSERT_NE(nullptr, original.get());
   const size_t original_mapped_size = original->mapped_size();
   memset(original->data(), 0xde, original_mapped_size);
   original.reset();
 
   // Reserve all but one of the pool's buffers.
@@ skipping 19 matching lines @@
   ASSERT_NE(nullptr, held_buffers.back().get());
   resurrected = ResurrectLastBuffer(gfx::Size(10, 10), GetParam());
   ASSERT_EQ(nullptr, resurrected.get());
 }
 
 INSTANTIATE_TEST_CASE_P(,
                         VideoCaptureBufferPoolTest,
                         testing::ValuesIn(kCapturePixelFormatAndStorages));
 
 } // namespace content