Add a GpuMemoryBuffer pool that creates hardware backed VideoFrames.

media/renderers/video_renderer_impl.cc

Index: media/renderers/video_renderer_impl.cc
diff --git a/media/renderers/video_renderer_impl.cc b/media/renderers/video_renderer_impl.cc
index 8d3f2ae0e41c75f9cbdc64fa902829294493961b..9487782461b98a01b2b7413b06fb40f8955dd3a5 100644
--- a/media/renderers/video_renderer_impl.cc
+++ b/media/renderers/video_renderer_impl.cc
@@ -21,6 +21,8 @@
 #include "media/base/media_switches.h"
 #include "media/base/pipeline.h"
 #include "media/base/video_frame.h"
+#include "media/renderers/gpu_video_accelerator_factories.h"
+#include "media/video/gpu_memory_buffer_video_frame_pool.h"
 
 namespace media {
 
@@ -43,6 +45,7 @@ VideoRendererImpl::VideoRendererImpl(
     VideoRendererSink* sink,
     ScopedVector<VideoDecoder> decoders,
     bool drop_frames,
+    scoped_refptr<GpuVideoAcceleratorFactories> gpu_factories,
     const scoped_refptr<MediaLog>& media_log)
     : task_runner_(task_runner),
       use_new_video_renderering_path_(ShouldUseVideoRenderingPath()),
@@ -50,6 +53,8 @@ VideoRendererImpl::VideoRendererImpl(
       sink_started_(false),
       video_frame_stream_(
           new VideoFrameStream(task_runner, decoders.Pass(), media_log)),
+      gpu_memory_buffer_pool_(
+          new GpuMemoryBufferVideoFramePool(task_runner, gpu_factories)),
       low_delay_(false),
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
@@ -499,6 +504,9 @@ void VideoRendererImpl::FrameReady(VideoFrameStream::Status status,
           algorithm_->Reset();
         ready_frames_.clear();
       }
+      // TODO(dcastagna): Enable GpuMemoryBuffer VideoFrames.

[DaleCurtis, 2015/05/12 17:23:20]

Some notes:
- To avoid blocking the media thread we might want to consider posting to the
worker pool for these copies. 
- In some cases the VideoRendererAlgorithm knows which frames we will always
drop, so say at 16x playback rate me may want to skip the uploading for frames
we know we'll never display.
- In the above case the code will let the frame pool grow to 12 frames, what
happens in OOM situations here?

[Daniele Castagna, 2015/05/12 21:21:29]

Good point. In our tests we noticed that the copy here blocks the media thread.
Overall the playback is still faster. Should we leave the copy in the worker
pool as a later optimization?
It'd be nice to skip the copy if the frame is going to be dropped.  Do you have
in mind a better place, after VideoRendererAlgorithm determined that we're not
dropping the frame, where we could do the copy?
If the original software frames are not needed for video decoding anymore, the
software frames will be dropped once we create the hardware frames, so the total
memory usage should be the same.
About this, we were planning to implement MemoryDumpProvider for the pool (the
ones in VpxVideoDecoder too) so we can better trace what's going on with memory
and pools.

[DaleCurtis, 2015/05/13 02:52:14]

Should be okay to do in a second pass, we can watch the telemetry scores to see
if it's necessary. To implement we could either refactor FrameReady slightly so
that the queuing portion can be posted to the worker pool. Or, we could have
GpuMemoryBufferPool immediately return a shell frame and have the copy happen in
the background on the worker pool thread. Though we'd need to make sure the copy
completes before the frame is actually displayed.
Well you'd need to integrate this code with the Algorithm instead somehow or
expose some information from the EnqueueFrame() call in AddReadyFrame_Locked()
which would indicate if it expects to use the frame.  There are reasons the
frame may still be used though, which would mean a copy happening on the
compositor thread sometimes.
Okay this was my confusion. I thought GPU memory might be more limited than
system memory, and thus fail in ways that we need to gracefully handle.

[Daniele Castagna, 2015/05/13 04:29:45]

Sounds good to me to do it in a second pass.
I'm going to delete these two lines since we need another cl in cc before we can
enable this.
I put the commented lines here here to start this kind of discussion.
I guess this would end up in the second pass too, right?

+      //AddReadyFrame_Locked(
+      //    gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(frame));
       AddReadyFrame_Locked(frame);
     }