Android media: VideoFrame should not store so many sync points.

cc/resources/video_resource_updater.cc

 // Copyright 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.
 
 #include "cc/resources/video_resource_updater.h"
 
 #include "base/bind.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/resources/resource_provider.h"
 #include "gpu/GLES2/gl2extchromium.h"
@@ skipping 266 matching lines @@
         TextureMailbox(plane_resources[i].mailbox, GL_TEXTURE_2D, 0));
     external_resources.release_callbacks.push_back(
         base::Bind(&RecycleResource, AsWeakPtr(), recycle_data));
   }
 
   external_resources.type = VideoFrameExternalResources::YUV_RESOURCE;
   return external_resources;
 }
 
 static void ReturnTexture(const scoped_refptr<media::VideoFrame>& frame,
+                          ContextProvider* context_provider,
                           uint32 sync_point,
                           bool lost_resource) {
-  frame->AppendReleaseSyncPoint(sync_point);
+  frame->AppendReleaseSyncPoint(reinterpret_cast<uintptr_t>(context_provider),
+                                sync_point);

[dshwang, 2014/06/05 14:38:30]

reinterpret_cast is ugly but I could not find better way.
In detail,
we want to make VideoFrame keep sync point per graphic 3d client. Here
compositor uses ContextProvider as graphics 3d context, while WebMediaPlayer
uses WebGraphicsContext3D as graphics 3d context. Moreover, both don't have kind
of id() method.
More elegant solution might be to add id() method in WebGraphicsContext3D and
expose the method to ContextProvider in both in_process and command_buffer impl.
But it seems to be overkill.

[dshwang, 2014/06/05 14:53:19]

That's good question. If one client waits for sync point made by another client,
VideoFrame can keep only one latest sync point. It's not important to keep sync
points for all clients.
However, VideoResourceUpdater can not wait a sync point because
VideoResourceUpdater can not use any graphics 3d context at this point. If we
really want to do that, we need hack that ResouceProvider passes graphics 3d
context to this callback. IMO, it's more ugly.

 }
 
 VideoFrameExternalResources VideoResourceUpdater::CreateForHardwarePlanes(
     const scoped_refptr<media::VideoFrame>& video_frame) {
   media::VideoFrame::Format frame_format = video_frame->format();
 
   DCHECK_EQ(frame_format, media::VideoFrame::NATIVE_TEXTURE);
   if (frame_format != media::VideoFrame::NATIVE_TEXTURE)
       return VideoFrameExternalResources();
 
@@ skipping 15 matching lines @@
       break;
     default:
       NOTREACHED();
       return VideoFrameExternalResources();
   }
 
   external_resources.mailboxes.push_back(
       TextureMailbox(mailbox_holder->mailbox,
                      mailbox_holder->texture_target,
                      mailbox_holder->sync_point));
-  external_resources.release_callbacks.push_back(
-      base::Bind(&ReturnTexture, video_frame));
+  external_resources.release_callbacks.push_back(base::Bind(
+      &ReturnTexture, video_frame, base::Unretained(context_provider_)));
   return external_resources;
 }
 
 // static
 void VideoResourceUpdater::RecycleResource(
     base::WeakPtr<VideoResourceUpdater> updater,
     RecycleResourceData data,
     uint32 sync_point,
     bool lost_resource) {
   if (!updater.get()) {
@@ skipping 21 matching lines @@
   }
 
   PlaneResource recycled_resource(data.resource_id,
                                   data.resource_size,
                                   data.resource_format,
                                   data.mailbox);
   updater->recycled_resources_.push_back(recycled_resource);
 }
 
 }  // namespace cc