media: GpuMemoryBufferVideoFramePool uses BindToCurrentLoop()

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 <stdint.h>
 
 #include "base/bind.h"
 #include "base/test/test_simple_task_runner.h"
+#include "base/thread_task_runner_handle.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 46 matching lines @@
 
 }  // unnamed namespace
 
 class GpuMemoryBufferVideoFramePoolTest : public ::testing::Test {
  public:
   GpuMemoryBufferVideoFramePoolTest() {}
   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);
+    media_task_runner_handle_.reset(
+        new base::ThreadTaskRunnerHandle(media_task_runner_));

[dshwang, 2016/03/21 18:31:23]

To use BindToCurrentLoop, unittest has to define ThreadTaskRunnerHandle::Get()

[Daniele Castagna, 2016/03/21 18:45:19]

You might want to add this comment here.

[dshwang, 2016/03/21 19:04:38]

Done.

     mock_gpu_factories_.reset(
         new MockGpuVideoAcceleratorFactories(gles2_.get()));
     gpu_memory_buffer_pool_.reset(new GpuMemoryBufferVideoFramePool(
         media_task_runner_, copy_task_runner_.get(),
         mock_gpu_factories_.get()));
   }
 
   void TearDown() override {
     gpu_memory_buffer_pool_.reset();
     RunUntilIdle();
@@ skipping 31 matching lines @@
             base::TimeDelta());        // timestamp
     EXPECT_TRUE(video_frame);
     return video_frame;
   }
 
  protected:
   scoped_ptr<MockGpuVideoAcceleratorFactories> mock_gpu_factories_;
   scoped_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool_;
   scoped_refptr<base::TestSimpleTaskRunner> media_task_runner_;
   scoped_refptr<base::TestSimpleTaskRunner> copy_task_runner_;
+  scoped_ptr<base::ThreadTaskRunnerHandle> media_task_runner_handle_;
   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, VideoFrameOutputFormatUnknown) {
@@ skipping 161 matching lines @@
   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);
 }
 
 }  // namespace media