cc: Move TextureMailbox::ReleaseCallback to SingleReleaseCallback.

content/browser/renderer_host/render_widget_host_view_aura.cc

 // Copyright (c) 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 "content/browser/renderer_host/render_widget_host_view_aura.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
@@ skipping 83 matching lines @@
 
 class MemoryHolder : public base::RefCounted<MemoryHolder> {
  public:
   MemoryHolder(scoped_ptr<base::SharedMemory> shared_memory,
                gfx::Size frame_size,
                base::Callback<void()> callback)
       : shared_memory_(shared_memory.Pass()),
         frame_size_(frame_size),
         callback_(callback) {}
 
-  cc::TextureMailbox GetMailbox() {
-    return cc::TextureMailbox(
-        shared_memory_.get(),
-        frame_size_,
+  void GetMailbox(cc::TextureMailbox* mailbox,
+                  scoped_ptr<cc::SingleReleaseCallback>* release_callback) {
+    *mailbox = cc::TextureMailbox(shared_memory_.get(), frame_size_);
+    *release_callback = cc::SingleReleaseCallback::Create(
         base::Bind(ReleaseMailbox, make_scoped_refptr(this)));
   }
 
  private:
   friend class base::RefCounted<MemoryHolder>;
   ~MemoryHolder() { callback_.Run(); }
 
   scoped_ptr<base::SharedMemory> shared_memory_;
   gfx::Size frame_size_;
   base::Callback<void()> callback_;
@@ skipping 1183 matching lines @@
     accelerated_compositing_state_changed_ = false;
 
   bool is_compositing_active = host_->is_accelerated_compositing_active();
   if (is_compositing_active && current_surface_.get()) {
     window_->layer()->SetExternalTexture(current_surface_.get());
     current_frame_size_ = ConvertSizeToDIP(
         current_surface_->device_scale_factor(), current_surface_->size());
     CheckResizeLock();
     framebuffer_holder_ = NULL;
   } else if (is_compositing_active && framebuffer_holder_) {
-    cc::TextureMailbox mailbox = framebuffer_holder_->GetMailbox();
+    cc::TextureMailbox mailbox;
+    scoped_ptr<cc::SingleReleaseCallback> callback;
+    framebuffer_holder_->GetMailbox(&mailbox, &callback);
     window_->layer()->SetTextureMailbox(mailbox,
+                                        callback.Pass(),
                                         last_swapped_surface_scale_factor_);
     current_frame_size_ = ConvertSizeToDIP(last_swapped_surface_scale_factor_,
                                            mailbox.shared_memory_size());
     CheckResizeLock();
   } else {
     window_->layer()->SetExternalTexture(NULL);
     resize_lock_.reset();
     host_->WasResized();
     framebuffer_holder_ = NULL;
   }
@@ skipping 216 matching lines @@
 
   scoped_refptr<MemoryHolder> holder(new MemoryHolder(
       shared_memory.Pass(),
       frame_size,
       base::Bind(&RenderWidgetHostViewAura::SendSoftwareFrameAck,
                  AsWeakPtr(),
                  output_surface_id,
                  frame_data->id)));
   bool first_frame = !framebuffer_holder_;
   framebuffer_holder_.swap(holder);
-  cc::TextureMailbox mailbox = framebuffer_holder_->GetMailbox();
+  cc::TextureMailbox mailbox;
+  scoped_ptr<cc::SingleReleaseCallback> callback;
+  framebuffer_holder_->GetMailbox(&mailbox, &callback);
   DCHECK(mailbox.IsSharedMemory());
   current_frame_size_ = frame_size_in_dip;
 
   released_front_lock_ = NULL;
   CheckResizeLock();
-  window_->layer()->SetTextureMailbox(mailbox, frame_device_scale_factor);
+  window_->layer()->SetTextureMailbox(mailbox,
+                                      callback.Pass(),
+                                      frame_device_scale_factor);
   window_->SchedulePaintInRect(
       ConvertRectToDIP(frame_device_scale_factor, damage_rect));
 
   ui::Compositor* compositor = GetCompositor();
   if (compositor) {
     compositor->SetLatencyInfo(latency_info);
     if (first_frame) {
       // Send swap for first frame, because no frame will be released due to
       // that.
       AddOnCommitCallbackAndDisableLocks(
@@ skipping 214 matching lines @@
     PrepareTextureCopyOutputResult(dst_size_in_pixel, callback, result.Pass());
     return;
   }
 
   DCHECK(result->HasBitmap());
   PrepareBitmapCopyOutputResult(dst_size_in_pixel, callback, result.Pass());
 }
 
 static void CopyFromCompositingSurfaceFinished(
     const base::Callback<void(bool, const SkBitmap&)>& callback,
-    const cc::TextureMailbox::ReleaseCallback& release_callback,
+    scoped_ptr<cc::SingleReleaseCallback> release_callback,
     scoped_ptr<SkBitmap> bitmap,
     scoped_ptr<SkAutoLockPixels> bitmap_pixels_lock,
     bool result) {
   bitmap_pixels_lock.reset();
-  release_callback.Run(0, false);
+  release_callback->Run(0, false);
   callback.Run(result, *bitmap);
 }
 
 // static
 void RenderWidgetHostViewAura::PrepareTextureCopyOutputResult(
     const gfx::Size& dst_size_in_pixel,
     const base::Callback<void(bool, const SkBitmap&)>& callback,
     scoped_ptr<cc::CopyOutputResult> result) {
   base::ScopedClosureRunner scoped_callback_runner(
       base::Bind(callback, false, SkBitmap()));
@@ skipping 11 matching lines @@
 
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   GLHelper* gl_helper = factory->GetGLHelper();
   if (!gl_helper)
     return;
 
   scoped_ptr<SkAutoLockPixels> bitmap_pixels_lock(
       new SkAutoLockPixels(*bitmap));
   uint8* pixels = static_cast<uint8*>(bitmap->getPixels());
 
-  scoped_ptr<cc::TextureMailbox> texture_mailbox = result->TakeTexture();
-  DCHECK(texture_mailbox->IsTexture());
-  if (!texture_mailbox->IsTexture())
+  cc::TextureMailbox texture_mailbox;
+  scoped_ptr<cc::SingleReleaseCallback> release_callback;
+  result->TakeTexture(&texture_mailbox, &release_callback);
+  DCHECK(texture_mailbox.IsTexture());
+  if (!texture_mailbox.IsTexture())
     return;
 
   ignore_result(scoped_callback_runner.Release());
 
   gl_helper->CropScaleReadbackAndCleanMailbox(
-      texture_mailbox->name(),
-      texture_mailbox->sync_point(),
+      texture_mailbox.name(),
+      texture_mailbox.sync_point(),
       result->size(),
       gfx::Rect(result->size()),
       dst_size_in_pixel,
       pixels,
       base::Bind(&CopyFromCompositingSurfaceFinished,
                  callback,
-                 texture_mailbox->callback(),
+                 base::Passed(&release_callback),
                  base::Passed(&bitmap),
                  base::Passed(&bitmap_pixels_lock)));
 }
 
 // static
 void RenderWidgetHostViewAura::PrepareBitmapCopyOutputResult(
     const gfx::Size& dst_size_in_pixel,
     const base::Callback<void(bool, const SkBitmap&)>& callback,
     scoped_ptr<cc::CopyOutputResult> result) {
   DCHECK(result->HasBitmap());
@@ skipping 13 matching lines @@
   SkBitmap bitmap = skia::ImageOperations::Resize(
       *source,
       skia::ImageOperations::RESIZE_BEST,
       dst_size_in_pixel.width(),
       dst_size_in_pixel.height());
   callback.Run(true, bitmap);
 }
 
 static void CopyFromCompositingSurfaceFinishedForVideo(
     const base::Callback<void(bool)>& callback,
-    const cc::TextureMailbox::ReleaseCallback& release_callback,
+    scoped_ptr<cc::SingleReleaseCallback> release_callback,
     bool result) {
-  release_callback.Run(0, false);
+  release_callback->Run(0, false);
   callback.Run(result);
 }
 
 // static
 void RenderWidgetHostViewAura::CopyFromCompositingSurfaceHasResultForVideo(
     base::WeakPtr<RenderWidgetHostViewAura> rwhva,
     scoped_refptr<media::VideoFrame> video_frame,
     const base::Callback<void(bool)>& callback,
     scoped_ptr<cc::CopyOutputResult> result) {
   base::ScopedClosureRunner scoped_callback_runner(base::Bind(callback, false));
@@ skipping 52 matching lines @@
     ignore_result(scoped_callback_runner.Release());
     callback.Run(true);
     return;
   }
 
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   GLHelper* gl_helper = factory->GetGLHelper();
   if (!gl_helper)
     return;
 
-  scoped_ptr<cc::TextureMailbox> texture_mailbox = result->TakeTexture();
-  DCHECK(texture_mailbox->IsTexture());
-  if (!texture_mailbox->IsTexture())
+  cc::TextureMailbox texture_mailbox;
+  scoped_ptr<cc::SingleReleaseCallback> release_callback;
+  result->TakeTexture(&texture_mailbox, &release_callback);
+  DCHECK(texture_mailbox.IsTexture());
+  if (!texture_mailbox.IsTexture())
     return;
 
   gfx::Rect result_rect(result->size());
 
   content::ReadbackYUVInterface* yuv_readback_pipeline =
       rwhva->yuv_readback_pipeline_.get();
   if (yuv_readback_pipeline == NULL ||
       yuv_readback_pipeline->scaler()->SrcSize() != result_rect.size() ||
       yuv_readback_pipeline->scaler()->SrcSubrect() != result_rect ||
       yuv_readback_pipeline->scaler()->DstSize() != region_in_frame.size()) {
@@ skipping 21 matching lines @@
                                              region_in_frame,
                                              true,
                                              false));
     yuv_readback_pipeline = rwhva->yuv_readback_pipeline_.get();
   }
 
   ignore_result(scoped_callback_runner.Release());
   base::Callback<void(bool result)> finished_callback = base::Bind(
       &CopyFromCompositingSurfaceFinishedForVideo,
       callback,
-      texture_mailbox->callback());
+      base::Passed(&release_callback));
   yuv_readback_pipeline->ReadbackYUV(
-      texture_mailbox->name(),
-      texture_mailbox->sync_point(),
+      texture_mailbox.name(),
+      texture_mailbox.sync_point(),
       video_frame.get(),
       finished_callback);
 }
 
 void RenderWidgetHostViewAura::GetScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, window_->GetRootWindow() ? window_ : NULL);
 }
 
 gfx::Rect RenderWidgetHostViewAura::GetBoundsInRootWindow() {
   return window_->GetToplevelWindow()->GetBoundsInScreen();
@@ skipping 520 matching lines @@
   } else if (old_mailbox.IsSharedMemory()) {
     base::SharedMemory* old_buffer = old_mailbox.shared_memory();
     const size_t size = old_mailbox.shared_memory_size_in_bytes();
 
     scoped_ptr<base::SharedMemory> new_buffer(new base::SharedMemory);
     new_buffer->CreateAndMapAnonymous(size);
 
     if (old_buffer->memory() && new_buffer->memory()) {
       memcpy(new_buffer->memory(), old_buffer->memory(), size);
       base::SharedMemory* new_buffer_raw_ptr = new_buffer.get();
-      cc::TextureMailbox::ReleaseCallback callback =
-          base::Bind(MailboxReleaseCallback, Passed(&new_buffer));
+      scoped_ptr<cc::SingleReleaseCallback> callback =
+          cc::SingleReleaseCallback::Create(base::Bind(MailboxReleaseCallback,
+                                                       Passed(&new_buffer)));
       cc::TextureMailbox new_mailbox(new_buffer_raw_ptr,
-                                     old_mailbox.shared_memory_size(),
-                                     callback);
-      new_layer->SetTextureMailbox(new_mailbox, mailbox_scale_factor);
+                                     old_mailbox.shared_memory_size());
+      new_layer->SetTextureMailbox(new_mailbox,
+                                   callback.Pass(),
+                                   mailbox_scale_factor);
     }
   }
   // TODO(piman): handle delegated frames.
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, ui::EventHandler implementation:
 
 void RenderWidgetHostViewAura::OnKeyEvent(ui::KeyEvent* event) {
   TRACE_EVENT0("input", "RenderWidgetHostViewAura::OnKeyEvent");
@@ skipping 746 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content