Pass GpuMemoryBuffer backed VideoFrame from browser to renderer processes

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"
@@ skipping 106 matching lines @@
 
   // 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()) {}
     ~Buffer() { pool_->RelinquishProducerReservation(id()); }
     int id() const { return id_; }
-    size_t size() { return buffer_handle_->size(); }
+    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 scoped_ptr<VideoCaptureBufferPool::BufferHandle> buffer_handle_;
   };
 
   VideoCaptureBufferPoolTest()
       : expected_dropped_id_(0),
@@ skipping 72 matching lines @@
   ASSERT_EQ(1.0 / kTestBufferPoolSize, pool_->GetBufferPoolUtilization());
   scoped_ptr<Buffer> buffer2 = ReserveBuffer(size_lo, GetParam());
   ASSERT_NE(nullptr, buffer2.get());
   ASSERT_EQ(2.0 / kTestBufferPoolSize, pool_->GetBufferPoolUtilization());
   scoped_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->size());
-    ASSERT_LE(format_lo.ImageAllocationSize(), buffer2->size());
-    ASSERT_LE(format_lo.ImageAllocationSize(), buffer3->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());
   }
 
   // Texture backed Frames cannot be manipulated via mapping.
   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());
+    memset(buffer1->data(), 0x11, buffer1->mapped_size());
   if (buffer2->data() != nullptr)
-    memset(buffer2->data(), 0x44, buffer2->size());
+    memset(buffer2->data(), 0x44, buffer2->mapped_size());
   if (buffer3->data() != nullptr)
-    memset(buffer3->data(), 0x77, buffer3->size());
+    memset(buffer3->data(), 0x77, buffer3->mapped_size());
 
   // Fourth buffer should fail.  Buffer pool utilization should be at 100%.
   ASSERT_FALSE(ReserveBuffer(size_lo, GetParam())) << "Pool should be empty";
   ASSERT_EQ(1.0, pool_->GetBufferPoolUtilization());
 
   // Release 1st buffer and retry; this should succeed.
   buffer1.reset();
   ASSERT_EQ(2.0 / kTestBufferPoolSize, pool_->GetBufferPoolUtilization());
   scoped_ptr<Buffer> buffer4 = ReserveBuffer(size_lo, GetParam());
   ASSERT_NE(nullptr, buffer4.get());
@@ skipping 71 matching lines @@
   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->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(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->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;
 
   // Touch the memory.
   if (buffer2->data() != nullptr)
-    memset(buffer2->data(), 0x22, buffer2->size());
+    memset(buffer2->data(), 0x22, buffer2->mapped_size());
   if (buffer4->data() != nullptr)
-    memset(buffer4->data(), 0x55, buffer4->size());
+    memset(buffer4->data(), 0x55, buffer4->mapped_size());
   buffer2.reset();
 
   if (buffer4->data() != nullptr)
-    memset(buffer4->data(), 0x77, buffer4->size());
+    memset(buffer4->data(), 0x77, buffer4->mapped_size());
   buffer4.reset();
 }
 
 INSTANTIATE_TEST_CASE_P(,
                         VideoCaptureBufferPoolTest,
                         testing::ValuesIn(kCapturePixelFormatAndStorages));
 
 } // namespace content