Video Gmb Pool: Plumb GpuMemoryBufferId through to compositor

media/video/gpu_memory_buffer_video_frame_pool.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 "media/video/gpu_memory_buffer_video_frame_pool.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <stddef.h>
 #include <stdint.h>
@@ skipping 535 matching lines @@
   if (!lock) {
     frame_ready_cb.Run(video_frame);
     return;
   }
   gpu::gles2::GLES2Interface* gles2 = lock->ContextGL();
 
   const size_t num_planes = VideoFrame::NumPlanes(output_format_);
   const size_t planes_per_copy = PlanesPerCopy(output_format_);
   const gfx::Size coded_size = CodedSize(video_frame, output_format_);
   gpu::MailboxHolder mailbox_holders[VideoFrame::kMaxPlanes];
+  gfx::GpuMemoryBufferId gpu_memory_buffer_ids[VideoFrame::kMaxPlanes];
   // Set up the planes creating the mailboxes needed to refer to the textures.
   for (size_t i = 0; i < num_planes; i += planes_per_copy) {
     PlaneResource& plane_resource = frame_resources->plane_resources[i];
     const gfx::BufferFormat buffer_format =
         GpuMemoryBufferFormat(output_format_, i);
     unsigned texture_target = gpu_factories_->ImageTextureTarget(buffer_format);
     // Bind the texture and create or rebind the image.
     gles2->BindTexture(texture_target, plane_resource.texture_id);
 
     if (plane_resource.gpu_memory_buffer && !plane_resource.image_id) {
       const size_t width =
           VideoFrame::Columns(i, output_format_, coded_size.width());
       const size_t height =
           VideoFrame::Rows(i, output_format_, coded_size.height());
       plane_resource.image_id = gles2->CreateImageCHROMIUM(
           plane_resource.gpu_memory_buffer->AsClientBuffer(), width, height,
           ImageInternalFormat(output_format_, i));
     } else if (plane_resource.image_id) {
       gles2->ReleaseTexImage2DCHROMIUM(texture_target, plane_resource.image_id);
     }
+    if (plane_resource.gpu_memory_buffer)
+      gpu_memory_buffer_ids[i] = plane_resource.gpu_memory_buffer->GetId();
     if (plane_resource.image_id)
       gles2->BindTexImage2DCHROMIUM(texture_target, plane_resource.image_id);
     mailbox_holders[i] = gpu::MailboxHolder(plane_resource.mailbox,
                                             gpu::SyncToken(), texture_target);
   }
 
   // Insert a sync_token, this is needed to make sure that the textures the
   // mailboxes refer to will be used only after all the previous commands posted
   // in the command buffer have been processed.
   const GLuint64 fence_sync = gles2->InsertFenceSyncCHROMIUM();
   gles2->OrderingBarrierCHROMIUM();
 
   gpu::SyncToken sync_token;
   gles2->GenUnverifiedSyncTokenCHROMIUM(fence_sync, sync_token.GetData());
   for (size_t i = 0; i < num_planes; i += planes_per_copy)
     mailbox_holders[i].sync_token = sync_token;
 
 
   auto release_mailbox_callback = BindToCurrentLoop(
       base::Bind(&PoolImpl::MailboxHoldersReleased, this, frame_resources));
 
   // Create the VideoFrame backed by native textures.
   gfx::Size visible_size = video_frame->visible_rect().size();
-  scoped_refptr<VideoFrame> frame = VideoFrame::WrapNativeTextures(
-      output_format_, mailbox_holders, release_mailbox_callback, coded_size,
-      gfx::Rect(visible_size), video_frame->natural_size(),
-      video_frame->timestamp());
+  scoped_refptr<VideoFrame> frame =
+      VideoFrame::WrapGpuMemoryBufferBackedNativeTextures(
+          output_format_, mailbox_holders, gpu_memory_buffer_ids,
+          release_mailbox_callback, coded_size, gfx::Rect(visible_size),
+          video_frame->natural_size(), video_frame->timestamp());
 
   if (!frame) {
     release_mailbox_callback.Run(gpu::SyncToken());
     frame_ready_cb.Run(video_frame);
     return;
   }
 
   bool allow_overlay = false;
   switch (output_format_) {
     case PIXEL_FORMAT_I420:
@@ skipping 150 matching lines @@
 }
 
 void GpuMemoryBufferVideoFramePool::MaybeCreateHardwareFrame(
     const scoped_refptr<VideoFrame>& video_frame,
     const FrameReadyCB& frame_ready_cb) {
   DCHECK(video_frame);
   pool_impl_->CreateHardwareFrame(video_frame, frame_ready_cb);
 }
 
 }  // namespace media