cc: Move TextureMailbox::ReleaseCallback to SingleReleaseCallback.

cc/resources/resource_provider.cc

 // Copyright 2012 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/resource_provider.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/containers/hash_tables.h"
@@ skipping 294 matching lines @@
   ResourceId id = next_id_++;
   Resource resource(texture_id, gfx::Size(), 0, GL_LINEAR, 0, GL_CLAMP_TO_EDGE,
                     TextureUsageAny);
   resource.external = true;
   resource.allocated = true;
   resources_[id] = resource;
   return id;
 }
 
 ResourceProvider::ResourceId ResourceProvider::CreateResourceFromTextureMailbox(
-    const TextureMailbox& mailbox) {
+    const TextureMailbox& mailbox,
+    scoped_ptr<ScopedReleaseCallback> release_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Just store the information. Mailbox will be consumed in LockForRead().
   ResourceId id = next_id_++;
   DCHECK(mailbox.IsValid());
   Resource& resource = resources_[id];
   if (mailbox.IsTexture()) {
     resource = Resource(0, gfx::Size(), 0, GL_LINEAR, 0, GL_CLAMP_TO_EDGE,
                         TextureUsageAny);
   } else {
     DCHECK(mailbox.IsSharedMemory());
     base::SharedMemory* shared_memory = mailbox.shared_memory();
     DCHECK(shared_memory->memory());
     uint8_t* pixels = reinterpret_cast<uint8_t*>(shared_memory->memory());
     resource = Resource(pixels, mailbox.shared_memory_size(),
                         GL_RGBA, GL_LINEAR, GL_CLAMP_TO_EDGE);
   }
   resource.external = true;
   resource.allocated = true;
   resource.mailbox = mailbox;
+  resource.release_callback =
+      base::Bind(&ScopedReleaseCallback::Run,
+                 base::Owned(release_callback.release()));
   return id;
 }
 
 void ResourceProvider::DeleteResource(ResourceId id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
   Resource* resource = &it->second;
   DCHECK(!resource->lock_for_read_count);
   DCHECK(!resource->marked_for_deletion);
@@ skipping 48 matching lines @@
       if (!lost_resource && resource->gl_id)
         sync_point = context3d->insertSyncPoint();
     } else {
       DCHECK(resource->mailbox.IsSharedMemory());
       base::SharedMemory* shared_memory = resource->mailbox.shared_memory();
       if (resource->pixels && shared_memory) {
         DCHECK(shared_memory->memory() == resource->pixels);
         resource->pixels = NULL;
       }
     }
-    resource->mailbox.RunReleaseCallback(sync_point, lost_resource);
+    resource->release_callback.Run(sync_point, lost_resource);
   }
   if (resource->pixels)
     delete[] resource->pixels;
   if (resource->pixel_buffer)
     delete[] resource->pixel_buffer;
 
   resources_.erase(it);
 }
 
 ResourceProvider::ResourceType ResourceProvider::GetResourceType(
@@ skipping 542 matching lines @@
     DCHECK(map_iterator != resources_.end());
     Resource* resource = &map_iterator->second;
     CHECK_GE(resource->exported_count, it->count);
     resource->exported_count -= it->count;
     if (resource->exported_count)
       continue;
     if (resource->gl_id) {
       if (it->sync_point)
         GLC(context3d, context3d->waitSyncPoint(it->sync_point));
     } else {
-      resource->mailbox = TextureMailbox(resource->mailbox.name(),
-                                         resource->mailbox.callback(),
-                                         it->sync_point);
+      resource->mailbox =
+          TextureMailbox(resource->mailbox.name(), it->sync_point);
     }
     if (resource->marked_for_deletion)
       DeleteResourceInternal(map_iterator, Normal);
   }
 }
 
 void ResourceProvider::TransferResource(WebGraphicsContext3D* context,
                                         ResourceId id,
                                         TransferableResource* resource) {
   Resource* source = GetResource(id);
@@ skipping 468 matching lines @@
   context->getIntegerv(GL_ACTIVE_TEXTURE, &active_unit);
   return active_unit;
 }
 
 WebKit::WebGraphicsContext3D* ResourceProvider::Context3d() const {
   ContextProvider* context_provider = output_surface_->context_provider();
   return context_provider ? context_provider->Context3d() : NULL;
 }
 
 }  // namespace cc