cc: Move TextureMailbox::ReleaseCallback to SingleReleaseCallback.

cc/layers/texture_layer.cc

 // Copyright 2010 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/layers/texture_layer.h"
 
 #include "base/bind.h"
+#include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/synchronization/lock.h"
 #include "cc/layers/texture_layer_client.h"
 #include "cc/layers/texture_layer_impl.h"
+#include "cc/resources/scoped_release_callback.h"
 #include "cc/trees/blocking_task_runner.h"
 #include "cc/trees/layer_tree_host.h"
 #include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
 
 namespace cc {
 
 scoped_refptr<TextureLayer> TextureLayer::Create(TextureLayerClient* client) {
   return scoped_refptr<TextureLayer>(new TextureLayer(client, false));
 }
 
@@ skipping 22 matching lines @@
 }
 
 TextureLayer::~TextureLayer() {
 }
 
 void TextureLayer::ClearClient() {
   if (rate_limit_context_ && client_ && layer_tree_host())
     layer_tree_host()->StopRateLimiter(client_->Context3d());
   client_ = NULL;
   if (uses_mailbox_)
-    SetTextureMailbox(TextureMailbox());
+    SetTextureMailbox(TextureMailbox(), scoped_ptr<ScopedReleaseCallback>());
   else
     SetTextureId(0);
 }
 
 scoped_ptr<LayerImpl> TextureLayer::CreateLayerImpl(LayerTreeImpl* tree_impl) {
   return TextureLayerImpl::Create(tree_impl, id(), uses_mailbox_).
       PassAs<LayerImpl>();
 }
 
 void TextureLayer::SetFlipped(bool flipped) {
@@ skipping 58 matching lines @@
     return;
   if (texture_id_ && layer_tree_host())
     layer_tree_host()->AcquireLayerTextures();
   texture_id_ = id;
   SetNeedsCommit();
   // The texture id needs to be removed from the active tree before the
   // commit is called complete.
   SetNextCommitWaitsForActivation();
 }
 
-void TextureLayer::SetTextureMailbox(const TextureMailbox& mailbox) {
+void TextureLayer::SetTextureMailbox(
+    const TextureMailbox& mailbox,
+    scoped_ptr<ScopedReleaseCallback> release_callback) {
   DCHECK(uses_mailbox_);
   DCHECK(!mailbox.IsValid() || !holder_ref_ ||
          !mailbox.Equals(holder_ref_->holder()->mailbox()));
+  DCHECK_EQ(mailbox.IsValid(), !!release_callback);
+
   // If we never commited the mailbox, we need to release it here.
   if (mailbox.IsValid())
-    holder_ref_ = MailboxHolder::Create(mailbox);
+    holder_ref_ = MailboxHolder::Create(mailbox, release_callback.Pass());
   else
     holder_ref_.reset();
   needs_set_mailbox_ = true;
   SetNeedsCommit();
   // The active frame needs to be replaced and the mailbox returned before the
   // commit is called complete.
   SetNextCommitWaitsForActivation();
 }
 
 void TextureLayer::WillModifyTexture() {
@@ skipping 41 matching lines @@
 bool TextureLayer::DrawsContent() const {
   return (client_ || texture_id_ || holder_ref_) && Layer::DrawsContent();
 }
 
 bool TextureLayer::Update(ResourceUpdateQueue* queue,
                           const OcclusionTracker* occlusion) {
   bool updated = Layer::Update(queue, occlusion);
   if (client_) {
     if (uses_mailbox_) {
       TextureMailbox mailbox;
+      scoped_ptr<ScopedReleaseCallback> release_callback;
       if (client_->PrepareTextureMailbox(
-              &mailbox, layer_tree_host()->UsingSharedMemoryResources())) {
-        SetTextureMailbox(mailbox);
+              &mailbox,
+              &release_callback,
+              layer_tree_host()->UsingSharedMemoryResources())) {
+        SetTextureMailbox(mailbox, release_callback.Pass());
         updated = true;
       }
     } else {
       texture_id_ = client_->PrepareTexture();
       DCHECK_EQ(!!texture_id_, !!client_->Context3d());
       if (client_->Context3d() &&
           client_->Context3d()->getGraphicsResetStatusARB() != GL_NO_ERROR)
         texture_id_ = 0;
       updated = true;
       // The texture id needs to be removed from the active tree before the
@@ skipping 13 matching lines @@
 
   TextureLayerImpl* texture_layer = static_cast<TextureLayerImpl*>(layer);
   texture_layer->set_flipped(flipped_);
   texture_layer->set_uv_top_left(uv_top_left_);
   texture_layer->set_uv_bottom_right(uv_bottom_right_);
   texture_layer->set_vertex_opacity(vertex_opacity_);
   texture_layer->set_premultiplied_alpha(premultiplied_alpha_);
   texture_layer->set_blend_background_color(blend_background_color_);
   if (uses_mailbox_ && needs_set_mailbox_) {
     TextureMailbox texture_mailbox;
+    scoped_ptr<ScopedReleaseCallback> release_callback;
     if (holder_ref_) {
       MailboxHolder* holder = holder_ref_->holder();
-      TextureMailbox::ReleaseCallback callback =
-          holder->GetCallbackForImplThread();
-      texture_mailbox = holder->mailbox().CopyWithNewCallback(callback);
+      texture_mailbox = holder->mailbox();
+      release_callback = holder->GetCallbackForImplThread();
     }
-    texture_layer->SetTextureMailbox(texture_mailbox);
+    texture_layer->SetTextureMailbox(texture_mailbox, release_callback.Pass());
     needs_set_mailbox_ = false;
   } else {
     texture_layer->set_texture_id(texture_id_);
   }
   content_committed_ = DrawsContent();
 }
 
 Region TextureLayer::VisibleContentOpaqueRegion() const {
   if (contents_opaque())
     return visible_content_rect();
@@ skipping 11 matching lines @@
 TextureLayer::MailboxHolder::MainThreadReference::MainThreadReference(
     MailboxHolder* holder)
     : holder_(holder) {
   holder_->InternalAddRef();
 }
 
 TextureLayer::MailboxHolder::MainThreadReference::~MainThreadReference() {
   holder_->InternalRelease();
 }
 
-TextureLayer::MailboxHolder::MailboxHolder(const TextureMailbox& mailbox)
+TextureLayer::MailboxHolder::MailboxHolder(
+    const TextureMailbox& mailbox,
+    scoped_ptr<ScopedReleaseCallback> release_callback)
     : message_loop_(BlockingTaskRunner::current()),
       internal_references_(0),
       mailbox_(mailbox),
+      release_callback_(release_callback.Pass()),
       sync_point_(mailbox.sync_point()),
       is_lost_(false) {
 }
 
 TextureLayer::MailboxHolder::~MailboxHolder() {
   DCHECK_EQ(0u, internal_references_);
 }
 
 scoped_ptr<TextureLayer::MailboxHolder::MainThreadReference>
-TextureLayer::MailboxHolder::Create(const TextureMailbox& mailbox) {
+TextureLayer::MailboxHolder::Create(
+    const TextureMailbox& mailbox,
+    scoped_ptr<ScopedReleaseCallback> release_callback) {
   return scoped_ptr<MainThreadReference>(new MainThreadReference(
-      new MailboxHolder(mailbox)));
+      new MailboxHolder(mailbox, release_callback.Pass())));
 }
 
 void TextureLayer::MailboxHolder::Return(unsigned sync_point, bool is_lost) {
   base::AutoLock lock(arguments_lock_);
   sync_point_ = sync_point;
   is_lost_ = is_lost;
 }
 
-TextureMailbox::ReleaseCallback
+scoped_ptr<ScopedReleaseCallback>
 TextureLayer::MailboxHolder::GetCallbackForImplThread() {
   // We can't call GetCallbackForImplThread if we released the main thread
   // reference.
   DCHECK_GT(internal_references_, 0u);
   InternalAddRef();
-  return base::Bind(&MailboxHolder::ReturnAndReleaseOnImplThread, this);
+  return ScopedReleaseCallback::Create(
+      base::Bind(&MailboxHolder::ReturnAndReleaseOnImplThread, this));
 }
 
 void TextureLayer::MailboxHolder::InternalAddRef() {
   ++internal_references_;
 }
 
 void TextureLayer::MailboxHolder::InternalRelease() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   if (!--internal_references_) {
-    mailbox_.RunReleaseCallback(sync_point_, is_lost_);
-    DCHECK(mailbox_.callback().is_null());
+    release_callback_->Run(sync_point_, is_lost_);
+    mailbox_ = TextureMailbox();
+    release_callback_.reset();
   }
 }
 
 void TextureLayer::MailboxHolder::ReturnAndReleaseOnImplThread(
     unsigned sync_point, bool is_lost) {
   Return(sync_point, is_lost);
   message_loop_->PostTask(FROM_HERE,
                           base::Bind(&MailboxHolder::InternalRelease, this));
 }
 
 }  // namespace cc