cc: Move TextureMailbox::ReleaseCallback to SingleReleaseCallback.

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 253 matching lines @@
     // In software mode, the resource provider won't be lost. Soon this callback
     // will be called directly from the resource provider, same as 3d
     // compositing mode, so this raw unretained resource_provider will always
     // be valid when the callback is fired.
     RecycleResourceData recycle_data = {
       plane_resources[0].resource_id,
       plane_resources[0].resource_size,
       plane_resources[0].resource_format,
       gpu::Mailbox()
     };
-    TextureMailbox::ReleaseCallback callback_to_free_resource =
-        base::Bind(&RecycleResource,
-                   AsWeakPtr(),
-                   recycle_data);
+
     external_resources.software_resources.push_back(
         plane_resources[0].resource_id);
-    external_resources.software_release_callback = callback_to_free_resource;
+    external_resources.software_release_callback =
+        base::Bind(&RecycleResource, AsWeakPtr(), recycle_data);
+
 
     external_resources.type = VideoFrameExternalResources::SOFTWARE_RESOURCE;
     return external_resources;
   }
 
   for (size_t i = 0; i < plane_resources.size(); ++i) {
     // Update each plane's resource id with its content.
     DCHECK_EQ(plane_resources[i].resource_format,
               static_cast<unsigned>(kYUVResourceFormat));
 
     const uint8_t* input_plane_pixels = video_frame->data(i);
 
     gfx::Rect image_rect(0,
                          0,
                          video_frame->stride(i),
                          plane_resources[i].resource_size.height());
     gfx::Rect source_rect(plane_resources[i].resource_size);
     resource_provider_->SetPixels(plane_resources[i].resource_id,
                                   input_plane_pixels,
                                   image_rect,
                                   source_rect,
                                   gfx::Vector2d());
 
     RecycleResourceData recycle_data = {
       plane_resources[i].resource_id,
       plane_resources[i].resource_size,
       plane_resources[i].resource_format,
       plane_resources[i].mailbox
     };
-    TextureMailbox::ReleaseCallback callback_to_free_resource =
-        base::Bind(&RecycleResource,
-                   AsWeakPtr(),
-                   recycle_data);
+
     external_resources.mailboxes.push_back(
-        TextureMailbox(plane_resources[i].mailbox,
-                       callback_to_free_resource));
+        TextureMailbox(plane_resources[i].mailbox));
+    external_resources.release_callbacks.push_back(
+        base::Bind(&RecycleResource, AsWeakPtr(), recycle_data));
   }
 
   external_resources.type = VideoFrameExternalResources::YUV_RESOURCE;
   return external_resources;
 }
 
 static void ReturnTexture(
     scoped_refptr<media::VideoFrame::MailboxHolder> mailbox_holder,
     unsigned sync_point,
     bool lost_resource) {
@@ skipping 24 matching lines @@
       external_resources.type = VideoFrameExternalResources::IO_SURFACE;
       break;
     default:
       NOTREACHED();
       return VideoFrameExternalResources();
   }
 
   scoped_refptr<media::VideoFrame::MailboxHolder> mailbox_holder =
       video_frame->texture_mailbox();
 
-  TextureMailbox::ReleaseCallback callback_to_return_resource =
-      base::Bind(&ReturnTexture, mailbox_holder);
-
   external_resources.mailboxes.push_back(
       TextureMailbox(mailbox_holder->mailbox(),
-                     callback_to_return_resource,
                      video_frame->texture_target(),
                      mailbox_holder->sync_point()));
+  external_resources.release_callbacks.push_back(
+      base::Bind(&ReturnTexture, mailbox_holder));
   return external_resources;
 }
 
 // static
 void VideoResourceUpdater::RecycleResource(
     base::WeakPtr<VideoResourceUpdater> updater,
     RecycleResourceData data,
     unsigned 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