Revert of VideoCapture: add support for GpuMemoryBuffer allocation and lifetime mgmt in VideoCaptureBufferPool

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 "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,
-  media::PIXEL_FORMAT_GPUMEMORYBUFFER
-};
-
-class VideoCaptureBufferPoolTest
-    : public testing::TestWithParam<media::VideoPixelFormat> {
+class VideoCaptureBufferPoolTest : public testing::Test {
  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_; }
-
-    bool Map(void** data) override {
-      EXPECT_EQ(mapped_, false);
-      mapped_ = true;
-      data[0] = static_cast<void*>(data_);
-      return true;
-    }
-    void Unmap() override {
-      EXPECT_EQ(mapped_, true);
-      mapped_ = false;
-    }
-    bool IsMapped() const override { return mapped_; }
-    Format GetFormat() const override { return BGRA_8888; }
-    void GetStride(int* stride) const override {
-      *stride = size_.width() * 4;
-      return;
-    }
-    gfx::GpuMemoryBufferHandle GetHandle() const override {
-      return gfx::GpuMemoryBufferHandle();
-    }
-    ClientBuffer AsClientBuffer() override { return nullptr; }
-
-   private:
-    const gfx::Size size_;
-    uint8* const data_;
-    bool mapped_;
-  };
-
-  // The next two classes are needed to replicate the GpuMemoryBuffer allocation
-  // on Browser side.
-  class StubBrowserGpuMemoryBufferManager
-      : public BrowserGpuMemoryBufferManager {
-   public:
-    StubBrowserGpuMemoryBufferManager()
-        : BrowserGpuMemoryBufferManager(nullptr, 1) {}
-
-    scoped_ptr<gfx::GpuMemoryBuffer> AllocateGpuMemoryBuffer(
-        const gfx::Size& size,
-        gfx::GpuMemoryBuffer::Format format,
-        gfx::GpuMemoryBuffer::Usage usage) override {
-      return make_scoped_ptr(new MockGpuMemoryBuffer(size));
-    }
-  };
-#if !defined(OS_ANDROID)
-  class MockBufferQueue : public BufferQueue {
-   public:
-    MockBufferQueue(scoped_refptr<cc::ContextProvider> context_provider,
-                    BrowserGpuMemoryBufferManager* gpu_memory_buffer_manager,
-                    unsigned int internalformat)
-        : BufferQueue(context_provider,
-                      internalformat,
-                      nullptr,
-                      gpu_memory_buffer_manager,
-                      1) {}
-    MOCK_METHOD4(CopyBufferDamage,
-                 void(int, int, const gfx::Rect&, const gfx::Rect&));
-  };
-#endif
-
-  // This is a generic Buffer tracker
   class Buffer {
    public:
     Buffer(const scoped_refptr<VideoCaptureBufferPool> pool,
-           scoped_ptr<VideoCaptureBufferPool::BufferHandle> buffer_handle,
-           int id)
-        : id_(id), pool_(pool), buffer_handle_(buffer_handle.Pass()) {}
+           int id,
+           void* data,
+           size_t size)
+        : pool_(pool), id_(id), data_(data), size_(size) {}
     ~Buffer() { pool_->RelinquishProducerReservation(id()); }
     int id() const { return id_; }
-    size_t size() { return buffer_handle_->size(); }
-    void* data() { return buffer_handle_->data(); }
+    void* data() const { return data_; }
+    size_t size() const { return size_; }
 
    private:
+    const scoped_refptr<VideoCaptureBufferPool> pool_;
     const int id_;
-    const scoped_refptr<VideoCaptureBufferPool> pool_;
-    const scoped_ptr<VideoCaptureBufferPool::BufferHandle> buffer_handle_;
+    void* const data_;
+    const size_t size_;
   };
-
   VideoCaptureBufferPoolTest()
       : expected_dropped_id_(0),
         pool_(new VideoCaptureBufferPool(3)) {}
 
-  void SetUp() override {
-    scoped_refptr<cc::TestContextProvider> context_provider =
-        cc::TestContextProvider::Create(cc::TestWebGraphicsContext3D::Create());
-    context_provider->BindToCurrentThread();
-    gpu_memory_buffer_manager_.reset(new StubBrowserGpuMemoryBufferManager);
-#if !defined(OS_ANDROID)
-    output_surface_.reset(new MockBufferQueue(
-        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) {
-    // To verify that ReserveBuffer always sets |buffer_id_to_drop|,
+  scoped_ptr<Buffer> ReserveI420Buffer(const gfx::Size& dimensions) {
+    // To verify that ReserveI420Buffer 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);
+    int buffer_id = pool_->ReserveForProducer(media::PIXEL_FORMAT_I420,
+                                              dimensions, &buffer_id_to_drop);
     if (buffer_id == VideoCaptureBufferPool::kInvalidId)
       return scoped_ptr<Buffer>();
+
+    void* memory;
+    size_t size;
+    pool_->GetBufferInfo(buffer_id, &memory, &size);
     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));
+    return scoped_ptr<Buffer>(new Buffer(pool_, buffer_id, memory, size));
   }
 
   int expected_dropped_id_;
   scoped_refptr<VideoCaptureBufferPool> pool_;
 
  private:
-  scoped_ptr<StubBrowserGpuMemoryBufferManager> gpu_memory_buffer_manager_;
-#if !defined(OS_ANDROID)
-  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());
+TEST_F(VideoCaptureBufferPoolTest, BufferPool) {
+  const gfx::Size size_lo = gfx::Size(640, 480);
+  const gfx::Size size_hi = gfx::Size(1024, 768);
+  scoped_refptr<media::VideoFrame> non_pool_frame =
+      media::VideoFrame::CreateFrame(media::VideoFrame::YV12, size_lo,
+                                     gfx::Rect(size_lo), size_lo,
+                                     base::TimeDelta());
 
   // Reallocation won't happen for the first part of the test.
   ExpectDroppedId(VideoCaptureBufferPool::kInvalidId);
 
-  scoped_ptr<Buffer> buffer1 = ReserveBuffer(size_lo, GetParam());
-  ASSERT_NE(nullptr, buffer1.get());
-  ASSERT_LE(format_lo.ImageAllocationSize(), buffer1->size());
-  scoped_ptr<Buffer> buffer2 = ReserveBuffer(size_lo, GetParam());
-  ASSERT_NE(nullptr, buffer2.get());
-  ASSERT_LE(format_lo.ImageAllocationSize(), buffer2->size());
-  scoped_ptr<Buffer> buffer3 = ReserveBuffer(size_lo, GetParam());
-  ASSERT_NE(nullptr, buffer3.get());
-  ASSERT_LE(format_lo.ImageAllocationSize(), buffer3->size());
+  scoped_ptr<Buffer> buffer1 = ReserveI420Buffer(size_lo);
+  ASSERT_TRUE(NULL != buffer1.get());
+  ASSERT_LE(media::VideoFrame::AllocationSize(media::VideoFrame::I420, size_lo),
+            buffer1->size());
+  scoped_ptr<Buffer> buffer2 = ReserveI420Buffer(size_lo);
+  ASSERT_TRUE(NULL != buffer2.get());
+  ASSERT_LE(media::VideoFrame::AllocationSize(media::VideoFrame::I420, size_lo),
+            buffer2->size());
+  scoped_ptr<Buffer> buffer3 = ReserveI420Buffer(size_lo);
+  ASSERT_TRUE(NULL != buffer3.get());
+  ASSERT_LE(media::VideoFrame::AllocationSize(media::VideoFrame::I420, size_lo),
+            buffer3->size());
 
-  // Texture backed Frames cannot be manipulated via mapping.
-  if (GetParam() != media::PIXEL_FORMAT_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());
-  if (buffer3->data() != nullptr)
-    memset(buffer3->data(), 0x77, buffer3->size());
+  memset(buffer1->data(), 0x11, buffer1->size());
+  memset(buffer2->data(), 0x44, buffer2->size());
+  memset(buffer3->data(), 0x77, buffer3->size());
 
   // Fourth buffer should fail.
-  ASSERT_FALSE(ReserveBuffer(size_lo, GetParam())) << "Pool should be empty";
+  ASSERT_FALSE(ReserveI420Buffer(size_lo)) << "Pool should be empty";
 
   // Release 1st buffer and retry; this should succeed.
   buffer1.reset();
-  scoped_ptr<Buffer> buffer4 = ReserveBuffer(size_lo, GetParam());
-  ASSERT_NE(nullptr, buffer4.get());
+  scoped_ptr<Buffer> buffer4 = ReserveI420Buffer(size_lo);
+  ASSERT_TRUE(NULL != buffer4.get());
 
-  ASSERT_FALSE(ReserveBuffer(size_lo, GetParam())) << "Pool should be empty";
-  ASSERT_FALSE(ReserveBuffer(size_hi, GetParam())) << "Pool should be empty";
+  ASSERT_FALSE(ReserveI420Buffer(size_lo)) << "Pool should be empty";
+  ASSERT_FALSE(ReserveI420Buffer(size_hi)) << "Pool should be empty";
 
   // Validate the IDs
   int buffer_id2 = buffer2->id();
   ASSERT_EQ(1, buffer_id2);
-  const int buffer_id3 = buffer3->id();
+  int buffer_id3 = buffer3->id();
   ASSERT_EQ(2, buffer_id3);
-  const int buffer_id4 = buffer4->id();
+  void* const memory_pointer3 = buffer3->data();
+  int buffer_id4 = buffer4->id();
   ASSERT_EQ(0, buffer_id4);
-  void* const memory_pointer3 = buffer3->data();
 
   // Deliver a buffer.
   pool_->HoldForConsumers(buffer_id3, 2);
 
-  ASSERT_FALSE(ReserveBuffer(size_lo, GetParam())) << "Pool should be empty";
+  ASSERT_FALSE(ReserveI420Buffer(size_lo)) << "Pool should be empty";
 
   buffer3.reset();  // Old producer releases buffer. Should be a noop.
-  ASSERT_FALSE(ReserveBuffer(size_lo, GetParam())) << "Pool should be empty";
-  ASSERT_FALSE(ReserveBuffer(size_hi, GetParam())) << "Pool should be empty";
+  ASSERT_FALSE(ReserveI420Buffer(size_lo)) << "Pool should be empty";
+  ASSERT_FALSE(ReserveI420Buffer(size_hi)) << "Pool should be empty";
 
   buffer2.reset();  // Active producer releases buffer. Should free a buffer.
 
-  buffer1 = ReserveBuffer(size_lo, GetParam());
-  ASSERT_NE(nullptr, buffer1.get());
-  ASSERT_FALSE(ReserveBuffer(size_lo, GetParam())) << "Pool should be empty";
+  buffer1 = ReserveI420Buffer(size_lo);
+  ASSERT_TRUE(NULL != buffer1.get());
+  ASSERT_FALSE(ReserveI420Buffer(size_lo)) << "Pool should be empty";
 
   // First consumer finishes.
   pool_->RelinquishConsumerHold(buffer_id3, 1);
-  ASSERT_FALSE(ReserveBuffer(size_lo, GetParam())) << "Pool should be empty";
+  ASSERT_FALSE(ReserveI420Buffer(size_lo)) << "Pool should be empty";
 
   // Second consumer finishes. This should free that buffer.
   pool_->RelinquishConsumerHold(buffer_id3, 1);
-  buffer3 = ReserveBuffer(size_lo, GetParam());
-  ASSERT_NE(nullptr, buffer3.get());
+  buffer3 = ReserveI420Buffer(size_lo);
+  ASSERT_TRUE(NULL != buffer3.get());
   ASSERT_EQ(buffer_id3, buffer3->id()) << "Buffer ID should be reused.";
   ASSERT_EQ(memory_pointer3, buffer3->data());
-  ASSERT_FALSE(ReserveBuffer(size_lo, GetParam())) << "Pool should be empty";
+  ASSERT_FALSE(ReserveI420Buffer(size_lo)) << "Pool should be empty";
 
   // Now deliver & consume buffer1, but don't release the buffer.
   int buffer_id1 = buffer1->id();
   ASSERT_EQ(1, buffer_id1);
   pool_->HoldForConsumers(buffer_id1, 5);
   pool_->RelinquishConsumerHold(buffer_id1, 5);
 
   // Even though the consumer is done with the buffer at |buffer_id1|, it cannot
   // be re-allocated to the producer, because |buffer1| still references it. But
   // when |buffer1| goes away, we should be able to re-reserve the buffer (and
   // the ID ought to be the same).
-  ASSERT_FALSE(ReserveBuffer(size_lo, GetParam())) << "Pool should be empty";
+  ASSERT_FALSE(ReserveI420Buffer(size_lo)) << "Pool should be empty";
   buffer1.reset();  // Should free the buffer.
-  buffer2 = ReserveBuffer(size_lo, GetParam());
-  ASSERT_NE(nullptr, buffer2.get());
+  buffer2 = ReserveI420Buffer(size_lo);
+  ASSERT_TRUE(NULL != buffer2.get());
   ASSERT_EQ(buffer_id1, buffer2->id());
   buffer_id2 = buffer_id1;
-  ASSERT_FALSE(ReserveBuffer(size_lo, GetParam())) << "Pool should be empty";
+  ASSERT_FALSE(ReserveI420Buffer(size_lo)) << "Pool should be empty";
 
   // Now try reallocation with different resolutions. We expect reallocation
   // to occur only when the old buffer is too small.
   buffer2.reset();
   ExpectDroppedId(buffer_id2);
-  buffer2 = ReserveBuffer(size_hi, GetParam());
-  ASSERT_NE(nullptr, buffer2.get());
-  ASSERT_LE(format_hi.ImageAllocationSize(), buffer2->size());
+  buffer2 = ReserveI420Buffer(size_hi);
+  ASSERT_TRUE(NULL != buffer2.get());
+  ASSERT_LE(media::VideoFrame::AllocationSize(media::VideoFrame::I420, size_hi),
+            buffer2->size());
   ASSERT_EQ(3, buffer2->id());
   void* const memory_pointer_hi = buffer2->data();
   buffer2.reset();  // Frees it.
   ExpectDroppedId(VideoCaptureBufferPool::kInvalidId);
-  buffer2 = ReserveBuffer(size_lo, GetParam());
+  buffer2 = ReserveI420Buffer(size_lo);
   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_TRUE(NULL != buffer2.get());
   ASSERT_EQ(3, buffer2->id());
-  ASSERT_LE(format_lo.ImageAllocationSize(), buffer2->size());
-  ASSERT_FALSE(ReserveBuffer(size_lo, GetParam())) << "Pool should be empty";
+  ASSERT_LE(media::VideoFrame::AllocationSize(media::VideoFrame::I420, size_lo),
+            buffer2->size());
+  ASSERT_FALSE(ReserveI420Buffer(size_lo)) << "Pool should be empty";
 
   // Tear down the pool_, writing into the buffers. The buffer should preserve
   // the lifetime of the underlying memory.
   buffer3.reset();
   pool_ = NULL;
 
   // Touch the memory.
-  if (buffer2->data() != nullptr)
-    memset(buffer2->data(), 0x22, buffer2->size());
-  if (buffer4->data() != nullptr)
-    memset(buffer4->data(), 0x55, buffer4->size());
+  memset(buffer2->data(), 0x22, buffer2->size());
+  memset(buffer4->data(), 0x55, buffer4->size());
+
   buffer2.reset();
 
-  if (buffer4->data() != nullptr)
-    memset(buffer4->data(), 0x77, buffer4->size());
+  memset(buffer4->data(), 0x77, buffer4->size());
   buffer4.reset();
 }
 
-INSTANTIATE_TEST_CASE_P(,
-                        VideoCaptureBufferPoolTest,
-                        testing::ValuesIn(kCaptureFormats));
-
 } // namespace content