Reland: Video Capture: extract storage info from pixel format in VideoCaptureFormat.

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.
 
 #include "content/browser/renderer_host/media/video_capture_buffer_pool.h"
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "cc/test/test_context_provider.h"
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "content/browser/compositor/buffer_queue.h"
 #include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
 #include "content/browser/renderer_host/media/video_capture_controller.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
-static const media::VideoPixelFormat kCaptureFormats[] = {
-  media::PIXEL_FORMAT_I420,
-  media::PIXEL_FORMAT_TEXTURE,
+struct PixelFormatAndStorage {
+  media::VideoPixelFormat pixel_format;
+  media::VideoPixelStorage pixel_storage;
+};
+
+static const PixelFormatAndStorage kCapturePixelFormatAndStorages[] = {
+    {media::PIXEL_FORMAT_I420, media::PIXEL_STORAGE_CPU},
+    {media::PIXEL_FORMAT_ARGB, media::PIXEL_STORAGE_CPU},
+    {media::PIXEL_FORMAT_ARGB, media::PIXEL_STORAGE_TEXTURE},
 #if !defined(OS_ANDROID)
-  media::PIXEL_FORMAT_GPUMEMORYBUFFER
+    {media::PIXEL_FORMAT_I420, media::PIXEL_STORAGE_GPUMEMORYBUFFER},
+    {media::PIXEL_FORMAT_ARGB, media::PIXEL_STORAGE_GPUMEMORYBUFFER},
 #endif
 };
 
 static const int kTestBufferPoolSize = 3;
 
 class VideoCaptureBufferPoolTest
-    : public testing::TestWithParam<media::VideoPixelFormat> {
+    : public testing::TestWithParam<PixelFormatAndStorage> {
  protected:
   // A GpuMemoryBuffer Mock to provide a trivial RGBA buffer as Map() backing.
   // We need to allocate on ctor and deallocate on dtor so that consecutive
   // Map()-Unmap() cycles yield the same underlying data pointer.
   class MockGpuMemoryBuffer : public gfx::GpuMemoryBuffer {
    public:
     explicit MockGpuMemoryBuffer(const gfx::Size& size)
         : size_(size), data_(new uint8[size_.GetArea() * 4]), mapped_(false) {}
     ~MockGpuMemoryBuffer() override { delete[] data_; }
 
@@ skipping 86 matching lines @@
         context_provider, gpu_memory_buffer_manager_.get(), GL_RGBA));
     output_surface_->Initialize();
   }
 #endif
 
   void ExpectDroppedId(int expected_dropped_id) {
     expected_dropped_id_ = expected_dropped_id;
   }
 
   scoped_ptr<Buffer> ReserveBuffer(const gfx::Size& dimensions,
-                                   media::VideoPixelFormat pixel_format) {
+                                   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::PixelFormatToString(pixel_format)
-             << " " << dimensions.ToString();
-    int buffer_id =
-        pool_->ReserveForProducer(pixel_format, dimensions, &buffer_id_to_drop);
+    DVLOG(1) << media::VideoCaptureFormat::PixelStorageToString(
+                    format_and_storage.pixel_storage) << " "
+             << media::VideoCaptureFormat::PixelFormatToString(
+                    format_and_storage.pixel_format) << " "
+             << dimensions.ToString();
+    const int buffer_id = pool_->ReserveForProducer(
+        format_and_storage.pixel_format, format_and_storage.pixel_storage,
+        dimensions, &buffer_id_to_drop);
     if (buffer_id == VideoCaptureBufferPool::kInvalidId)
       return scoped_ptr<Buffer>();
     EXPECT_EQ(expected_dropped_id_, buffer_id_to_drop);
 
     scoped_ptr<VideoCaptureBufferPool::BufferHandle> buffer_handle =
         pool_->GetBufferHandle(buffer_id);
     return scoped_ptr<Buffer>(
         new Buffer(pool_, buffer_handle.Pass(), buffer_id));
   }
 
   base::MessageLoop loop_;
   int expected_dropped_id_;
   scoped_refptr<VideoCaptureBufferPool> pool_;
 
  private:
 #if !defined(OS_ANDROID)
   scoped_ptr<StubBrowserGpuMemoryBufferManager> gpu_memory_buffer_manager_;
   scoped_ptr<MockBufferQueue> output_surface_;
 #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());
-  const media::VideoCaptureFormat format_hi(size_hi, 0.0, GetParam());
+  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);
 
   // The buffer pool should have zero utilization before any buffers have been
   // reserved.
   ASSERT_EQ(0.0, pool_->GetBufferPoolUtilization());
 
   scoped_ptr<Buffer> buffer1 = ReserveBuffer(size_lo, GetParam());
   ASSERT_NE(nullptr, buffer1.get());
   ASSERT_LE(format_lo.ImageAllocationSize(), buffer1->size());
   ASSERT_EQ(1.0 / kTestBufferPoolSize, pool_->GetBufferPoolUtilization());
   scoped_ptr<Buffer> buffer2 = ReserveBuffer(size_lo, GetParam());
   ASSERT_NE(nullptr, buffer2.get());
   ASSERT_LE(format_lo.ImageAllocationSize(), buffer2->size());
   ASSERT_EQ(2.0 / kTestBufferPoolSize, pool_->GetBufferPoolUtilization());
   scoped_ptr<Buffer> buffer3 = ReserveBuffer(size_lo, GetParam());
   ASSERT_NE(nullptr, buffer3.get());
   ASSERT_LE(format_lo.ImageAllocationSize(), buffer3->size());
   ASSERT_EQ(3.0 / kTestBufferPoolSize, pool_->GetBufferPoolUtilization());
 
   // Texture backed Frames cannot be manipulated via mapping.
-  if (GetParam() != media::PIXEL_FORMAT_TEXTURE) {
+  if (GetParam().pixel_storage != media::PIXEL_STORAGE_TEXTURE) {
     ASSERT_NE(nullptr, buffer1->data());
     ASSERT_NE(nullptr, buffer2->data());
     ASSERT_NE(nullptr, buffer3->data());
 
   }
   // Touch the memory.
   if (buffer1->data() != nullptr)
     memset(buffer1->data(), 0x11, buffer1->size());
   if (buffer2->data() != nullptr)
     memset(buffer2->data(), 0x44, buffer2->size());
@@ skipping 120 matching lines @@
     memset(buffer4->data(), 0x55, buffer4->size());
   buffer2.reset();
 
   if (buffer4->data() != nullptr)
     memset(buffer4->data(), 0x77, buffer4->size());
   buffer4.reset();
 }
 
 INSTANTIATE_TEST_CASE_P(,
                         VideoCaptureBufferPoolTest,
-                        testing::ValuesIn(kCaptureFormats));
+                        testing::ValuesIn(kCapturePixelFormatAndStorages));
 
 } // namespace content