Add gpu::MailboxHolder to hold state for a gpu::Mailbox

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 288 matching lines @@
                                   gfx::Vector2d());
 
     RecycleResourceData recycle_data = {
       plane_resources[i].resource_id,
       plane_resources[i].resource_size,
       plane_resources[i].resource_format,
       plane_resources[i].mailbox
     };
 
     external_resources.mailboxes.push_back(
-        TextureMailbox(plane_resources[i].mailbox));
+        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,
-                          unsigned sync_point,
+                          uint32 sync_point,
                           bool lost_resource) {
-  frame->texture_mailbox()->Resync(sync_point);
+  frame->mailbox_holder()->sync_point = sync_point;
 }
 
 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();
 
   if (!context_provider_)
     return VideoFrameExternalResources();
 
+  gpu::MailboxHolder* mailbox_holder = video_frame->mailbox_holder();
   VideoFrameExternalResources external_resources;
-  switch (video_frame->texture_target()) {
+  switch (mailbox_holder->texture_target) {
     case GL_TEXTURE_2D:
       external_resources.type = VideoFrameExternalResources::RGB_RESOURCE;
       break;
     case GL_TEXTURE_EXTERNAL_OES:
       external_resources.type =
           VideoFrameExternalResources::STREAM_TEXTURE_RESOURCE;
       break;
     case GL_TEXTURE_RECTANGLE_ARB:
       external_resources.type = VideoFrameExternalResources::IO_SURFACE;
       break;
     default:
       NOTREACHED();
       return VideoFrameExternalResources();
   }
 
-  media::VideoFrame::MailboxHolder* mailbox_holder =
-      video_frame->texture_mailbox();
-
   external_resources.mailboxes.push_back(
-      TextureMailbox(mailbox_holder->mailbox(),
-                     video_frame->texture_target(),
-                     mailbox_holder->sync_point()));
+      TextureMailbox(mailbox_holder->mailbox,
+                     mailbox_holder->texture_target,
+                     mailbox_holder->sync_point));
   external_resources.release_callbacks.push_back(
       base::Bind(&ReturnTexture, video_frame));
   return external_resources;
 }
 
 // static
 void VideoResourceUpdater::RecycleResource(
     base::WeakPtr<VideoResourceUpdater> updater,
     RecycleResourceData data,
-    unsigned sync_point,
+    uint32 sync_point,
     bool lost_resource) {
   if (!updater.get()) {
     // Resource was already deleted.
     return;
   }
 
   ContextProvider* context_provider = updater->context_provider_;
   if (context_provider && sync_point) {
     GLC(context_provider->ContextGL(),
         context_provider->ContextGL()->WaitSyncPointCHROMIUM(sync_point));
@@ skipping 13 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