media: Make GpuMemoryBuffers VideoFrame copies asynchronous.

media/video/gpu_memory_buffer_video_frame_pool_unittest.cc

 // Copyright 2015 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.
 
-#include "base/message_loop/message_loop.h"
-#include "base/run_loop.h"
+#include "base/bind.h"
+#include "base/test/test_simple_task_runner.h"
 #include "gpu/command_buffer/client/gles2_interface_stub.h"
 #include "media/base/video_frame.h"
 #include "media/renderers/mock_gpu_video_accelerator_factories.h"
 #include "media/video/gpu_memory_buffer_video_frame_pool.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace media {
 
 namespace {
 class TestGLES2Interface : public gpu::gles2::GLES2InterfaceStub {
@@ skipping 13 matching lines @@
  private:
   unsigned sync_point = 0u;
   unsigned mailbox = 0u;
 };
 
 }  // unnamed namespace
 
 class GpuMemoryBufferVideoFramePoolTest : public ::testing::Test {
  public:
   GpuMemoryBufferVideoFramePoolTest() {}
-  void SetUp() override { gles2_.reset(new TestGLES2Interface); }
+  void SetUp() override {
+    gles2_.reset(new TestGLES2Interface);
+    media_task_runner_ = make_scoped_refptr(new base::TestSimpleTaskRunner);
+    copy_task_runner_ = make_scoped_refptr(new base::TestSimpleTaskRunner);
+  }
 
-  void TearDown() override { base::RunLoop().RunUntilIdle(); }
+  void TearDown() override { RunUntilIdle(); }
+
+  void RunUntilIdle() {
+    media_task_runner_->RunUntilIdle();
+    copy_task_runner_->RunUntilIdle();
+    media_task_runner_->RunUntilIdle();
+  }
 
   static scoped_refptr<media::VideoFrame> CreateTestYUVVideoFrame(
       int dimension) {
     const int kDimension = 10;
     static uint8 y_data[kDimension * kDimension] = {0};
     static uint8 u_data[kDimension * kDimension / 2] = {0};
     static uint8 v_data[kDimension * kDimension / 2] = {0};
 
     DCHECK_LE(dimension, kDimension);
     gfx::Size size(dimension, dimension);
 
     return media::VideoFrame::WrapExternalYuvData(
         media::PIXEL_FORMAT_YV12,  // format
         size,                      // coded_size
         gfx::Rect(size),           // visible_rect
         size,                      // natural_size
         size.width(),              // y_stride
         size.width() / 2,          // u_stride
         size.width() / 2,          // v_stride
         y_data,                    // y_data
         u_data,                    // u_data
         v_data,                    // v_data
         base::TimeDelta());        // timestamp
   }
 
  protected:
-  base::MessageLoop media_message_loop_;
+  scoped_refptr<base::TestSimpleTaskRunner> media_task_runner_;
+  scoped_refptr<base::TestSimpleTaskRunner> copy_task_runner_;
   scoped_ptr<TestGLES2Interface> gles2_;
 };
 
+void MaybeCreateHardwareFrameCallback(
+    scoped_refptr<VideoFrame>* video_frame_output,
+    const scoped_refptr<VideoFrame>& video_frame) {
+  *video_frame_output = video_frame;
+}
+
 TEST_F(GpuMemoryBufferVideoFramePoolTest, NoGpuFactoryNoHardwareVideoFrame) {
   scoped_refptr<VideoFrame> frame = CreateTestYUVVideoFrame(10);
   scoped_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool_ =
       make_scoped_ptr(new GpuMemoryBufferVideoFramePool(
-          media_message_loop_.task_runner(), nullptr));
+          media_task_runner_, copy_task_runner_.get(), nullptr));
 
-  scoped_refptr<VideoFrame> frame2 =
-      gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(frame);
+  scoped_refptr<VideoFrame> frame2;
+  gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
+      frame, base::Bind(MaybeCreateHardwareFrameCallback, &frame2));
+  RunUntilIdle();
   EXPECT_EQ(frame.get(), frame2.get());
 }
 
 TEST_F(GpuMemoryBufferVideoFramePoolTest, NoTextureRGNoHardwareVideoFrame) {
   scoped_refptr<VideoFrame> frame = CreateTestYUVVideoFrame(10);
   scoped_refptr<MockGpuVideoAcceleratorFactories> mock_gpu_factories(
       new MockGpuVideoAcceleratorFactories);
   scoped_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool_ =
       make_scoped_ptr(new GpuMemoryBufferVideoFramePool(
-          media_message_loop_.task_runner(), mock_gpu_factories));
+          media_task_runner_, copy_task_runner_.get(), mock_gpu_factories));
 
   EXPECT_CALL(*mock_gpu_factories.get(), IsTextureRGSupported())
       .WillRepeatedly(testing::Return(false));
-  scoped_refptr<VideoFrame> frame2 =
-      gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(frame);
+  scoped_refptr<VideoFrame> frame2;
+  gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
+      frame, base::Bind(MaybeCreateHardwareFrameCallback, &frame2));
+  RunUntilIdle();
+
   EXPECT_EQ(frame.get(), frame2.get());
 }
 
 TEST_F(GpuMemoryBufferVideoFramePoolTest, CreateOneHardwareFrame) {
   scoped_refptr<VideoFrame> software_frame = CreateTestYUVVideoFrame(10);
   scoped_refptr<MockGpuVideoAcceleratorFactories> mock_gpu_factories(
       new MockGpuVideoAcceleratorFactories);
   scoped_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool_ =
       make_scoped_ptr(new GpuMemoryBufferVideoFramePool(
-          media_message_loop_.task_runner(), mock_gpu_factories));
+          media_task_runner_, copy_task_runner_.get(), mock_gpu_factories));
 
   EXPECT_CALL(*mock_gpu_factories.get(), GetGLES2Interface())
       .WillRepeatedly(testing::Return(gles2_.get()));
   EXPECT_CALL(*mock_gpu_factories.get(), IsTextureRGSupported())
       .WillRepeatedly(testing::Return(true));
 
-  scoped_refptr<VideoFrame> frame =
-      gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(software_frame);
+  scoped_refptr<VideoFrame> frame;
+  gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
+      software_frame, base::Bind(MaybeCreateHardwareFrameCallback, &frame));
+
+  RunUntilIdle();
+
   EXPECT_NE(software_frame.get(), frame.get());
   EXPECT_EQ(3u, gles2_->gen_textures);
 }
 
 TEST_F(GpuMemoryBufferVideoFramePoolTest, ReuseFirstResource) {
   scoped_refptr<VideoFrame> software_frame = CreateTestYUVVideoFrame(10);
   scoped_refptr<MockGpuVideoAcceleratorFactories> mock_gpu_factories(
       new MockGpuVideoAcceleratorFactories);
   scoped_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool_ =
       make_scoped_ptr(new GpuMemoryBufferVideoFramePool(
-          media_message_loop_.task_runner(), mock_gpu_factories));
+          media_task_runner_, copy_task_runner_.get(), mock_gpu_factories));
 
   EXPECT_CALL(*mock_gpu_factories.get(), GetGLES2Interface())
       .WillRepeatedly(testing::Return(gles2_.get()));
   EXPECT_CALL(*mock_gpu_factories.get(), IsTextureRGSupported())
       .WillRepeatedly(testing::Return(true));
 
-  scoped_refptr<VideoFrame> frame =
-      gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(software_frame);
+  scoped_refptr<VideoFrame> frame;
+  gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
+      software_frame, base::Bind(MaybeCreateHardwareFrameCallback, &frame));
+  RunUntilIdle();
+
   EXPECT_NE(software_frame.get(), frame.get());
   gpu::Mailbox mailbox = frame->mailbox_holder(0).mailbox;
   unsigned sync_point = frame->mailbox_holder(0).sync_point;
   EXPECT_EQ(3u, gles2_->gen_textures);
 
-  scoped_refptr<VideoFrame> frame2 =
-      gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(software_frame);
+  scoped_refptr<VideoFrame> frame2;
+  gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
+      software_frame, base::Bind(MaybeCreateHardwareFrameCallback, &frame2));
+  RunUntilIdle();
+
   EXPECT_NE(software_frame.get(), frame2.get());
   EXPECT_NE(mailbox, frame2->mailbox_holder(0).mailbox);
   EXPECT_EQ(6u, gles2_->gen_textures);
 
   frame = nullptr;
   frame2 = nullptr;
-  base::RunLoop().RunUntilIdle();  // Run posted closures.
-  frame = gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(software_frame);
+  RunUntilIdle();
+
+  gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
+      software_frame, base::Bind(MaybeCreateHardwareFrameCallback, &frame));
+  RunUntilIdle();
+
   EXPECT_NE(software_frame.get(), frame.get());
   EXPECT_EQ(6u, gles2_->gen_textures);
   EXPECT_EQ(frame->mailbox_holder(0).mailbox, mailbox);
   EXPECT_NE(frame->mailbox_holder(0).sync_point, sync_point);
 }
 
 TEST_F(GpuMemoryBufferVideoFramePoolTest, DropResourceWhenSizeIsDifferent) {
   scoped_refptr<MockGpuVideoAcceleratorFactories> mock_gpu_factories(
       new MockGpuVideoAcceleratorFactories);
   scoped_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool_ =
       make_scoped_ptr(new GpuMemoryBufferVideoFramePool(
-          media_message_loop_.task_runner(), mock_gpu_factories));
+          media_task_runner_, copy_task_runner_.get(), mock_gpu_factories));
 
   EXPECT_CALL(*mock_gpu_factories.get(), GetGLES2Interface())
       .WillRepeatedly(testing::Return(gles2_.get()));
   EXPECT_CALL(*mock_gpu_factories.get(), IsTextureRGSupported())
       .WillRepeatedly(testing::Return(true));
 
-  scoped_refptr<VideoFrame> frame =
-      gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
-          CreateTestYUVVideoFrame(10));
+  scoped_refptr<VideoFrame> frame;
+  gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
+      CreateTestYUVVideoFrame(10),
+      base::Bind(MaybeCreateHardwareFrameCallback, &frame));
+  RunUntilIdle();
+
   EXPECT_EQ(3u, gles2_->gen_textures);
 
   frame = nullptr;
-  base::RunLoop().RunUntilIdle();  // Run posted closures.
-  frame = gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
-      CreateTestYUVVideoFrame(4));
+  RunUntilIdle();
+  gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
+      CreateTestYUVVideoFrame(4),
+      base::Bind(MaybeCreateHardwareFrameCallback, &frame));
+  RunUntilIdle();
   EXPECT_EQ(6u, gles2_->gen_textures);
 }
 
 }  // namespace media