Cleanup of video capture into GpuMemoryBuffer

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 "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_tracker_factory_impl.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;
 };
 
 static const PixelFormatAndStorage kCapturePixelFormatAndStorages[] = {
     {media::PIXEL_FORMAT_I420, media::PIXEL_STORAGE_CPU},
     {media::PIXEL_FORMAT_ARGB, media::PIXEL_STORAGE_CPU},
-#if !defined(OS_ANDROID)
-    {media::PIXEL_FORMAT_I420,
-     media::PIXEL_STORAGE_GPUMEMORYBUFFER},
-#endif
 };
 
 static const int kTestBufferPoolSize = 3;
 
 // 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 live here and not in media/capture/video.
 class VideoCaptureBufferPoolTest
     : 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_t[size_.GetArea() * 4]),
-          mapped_(false) {}
-    ~MockGpuMemoryBuffer() override { delete[] data_; }
-
-    bool Map() override {
-      EXPECT_FALSE(mapped_);
-      mapped_ = true;
-      return true;
-    }
-    void* memory(size_t plane) override {
-      EXPECT_TRUE(mapped_);
-      EXPECT_EQ(0u, plane);
-      return static_cast<void*>(data_);
-    }
-    void Unmap() override {
-      EXPECT_TRUE(mapped_);
-      mapped_ = false;
-    }
-    gfx::Size GetSize() const override { return size_; }
-    gfx::BufferFormat GetFormat() const override {
-      return gfx::BufferFormat::BGRA_8888;
-    }
-    int stride(size_t plane) const override {
-      EXPECT_EQ(0u, plane);
-      return size_.width() * 4;
-    }
-    gfx::GpuMemoryBufferId GetId() const override {
-      return gfx::GpuMemoryBufferId(0);
-    }
-    gfx::GpuMemoryBufferHandle GetHandle() const override {
-      return gfx::GpuMemoryBufferHandle();
-    }
-    ClientBuffer AsClientBuffer() override { return nullptr; }
-
-   private:
-    const gfx::Size size_;
-    uint8_t* const data_;
-    bool mapped_;
-  };
-
-#if !defined(OS_ANDROID)
-  // The next two classes are needed to replicate the GpuMemoryBuffer allocation
-  // on Browser side.
-  class StubBrowserGpuMemoryBufferManager
-      : public BrowserGpuMemoryBufferManager {
-   public:
-    StubBrowserGpuMemoryBufferManager() : BrowserGpuMemoryBufferManager(1, 1) {}
-
-    std::unique_ptr<gfx::GpuMemoryBuffer> AllocateGpuMemoryBuffer(
-        const gfx::Size& size,
-        gfx::BufferFormat format,
-        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<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<media::VideoCaptureBufferPool> pool_;
     const std::unique_ptr<media::VideoCaptureBufferHandle> buffer_handle_;
   };
 
   VideoCaptureBufferPoolTest()
       : expected_dropped_id_(0),
         pool_(new media::VideoCaptureBufferPoolImpl(
             base::MakeUnique<VideoCaptureBufferTrackerFactoryImpl>(),
             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_;
@@ skipping 24 matching lines @@
       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<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(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());
   ASSERT_EQ(2.0 / kTestBufferPoolSize, pool_->GetBufferPoolUtilization());
   std::unique_ptr<Buffer> buffer3 = ReserveBuffer(size_lo, GetParam());
   ASSERT_NE(nullptr, buffer3.get());
   ASSERT_EQ(3.0 / kTestBufferPoolSize, pool_->GetBufferPoolUtilization());
 
-  // GMB backed frames have their platform and format specific allocations.
-  if (GetParam().pixel_storage != media::PIXEL_STORAGE_GPUMEMORYBUFFER) {
-    ASSERT_LE(format_lo.ImageAllocationSize(), buffer1->mapped_size());
-    ASSERT_LE(format_lo.ImageAllocationSize(), buffer2->mapped_size());
-    ASSERT_LE(format_lo.ImageAllocationSize(), buffer3->mapped_size());
-  }
+  ASSERT_LE(format_lo.ImageAllocationSize(), buffer1->mapped_size());
+  ASSERT_LE(format_lo.ImageAllocationSize(), buffer2->mapped_size());
+  ASSERT_LE(format_lo.ImageAllocationSize(), buffer3->mapped_size());
 
   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->mapped_size());
   if (buffer2->data() != nullptr)
     memset(buffer2->data(), 0x44, buffer2->mapped_size());
@@ skipping 82 matching lines @@
   ASSERT_FALSE(ReserveBuffer(size_lo, GetParam())) << "Pool should be empty";
   ASSERT_EQ(1.0, pool_->GetBufferPoolUtilization());
 
   // Now try reallocation with different resolutions. We expect reallocation
   // to occur only when the old buffer is too small.
   buffer2.reset();
   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_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(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_LE(format_lo.ImageAllocationSize(), buffer2->mapped_size());
   ASSERT_EQ(3.0 / kTestBufferPoolSize, pool_->GetBufferPoolUtilization());
   ASSERT_FALSE(ReserveBuffer(size_lo, GetParam())) << "Pool should be empty";
   ASSERT_EQ(1.0, pool_->GetBufferPoolUtilization());
 
   // Tear down the pool_, writing into the buffers. The buffer should preserve
   // the lifetime of the underlying memory.
   buffer3.reset();
   ASSERT_EQ(2.0 / kTestBufferPoolSize, pool_->GetBufferPoolUtilization());
   pool_ = NULL;
 
@@ skipping 76 matching lines @@
   // match.
   PixelFormatAndStorage altered_format_or_storage = GetParam();
   altered_format_or_storage.pixel_format =
       (altered_format_or_storage.pixel_format == media::PIXEL_FORMAT_I420
            ? media::PIXEL_FORMAT_ARGB
            : media::PIXEL_FORMAT_I420);
   resurrected =
       ResurrectLastBuffer(gfx::Size(10, 10), altered_format_or_storage);
   ASSERT_EQ(nullptr, resurrected.get());
 
-  // Expect that the buffer cannot be resurrected if the pixel storage does not
-  // match.
-  altered_format_or_storage = GetParam();
-  altered_format_or_storage.pixel_storage =
-      (altered_format_or_storage.pixel_storage == media::PIXEL_STORAGE_CPU)
-          ? media::PIXEL_STORAGE_GPUMEMORYBUFFER
-          : media::PIXEL_STORAGE_CPU;
-  resurrected =
-      ResurrectLastBuffer(gfx::Size(10, 10), altered_format_or_storage);
-  ASSERT_EQ(nullptr, resurrected.get());
-
   // Finally, check that the buffer CAN be resurrected if all properties match.
   resurrected = ResurrectLastBuffer(gfx::Size(10, 10), GetParam());
   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
@@ skipping 32 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