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

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 79 matching lines @@
 using gfx::SkIRectToRect;
 
 using blink::WebScreenInfo;
 using blink::WebTouchEvent;
 
 namespace content {
 
 namespace {
 
 void MailboxReleaseCallback(scoped_ptr<base::SharedMemory> shared_memory,
-                            unsigned sync_point, bool lost_resource) {
+                            uint32 sync_point,
+                            bool lost_resource) {
   // NOTE: shared_memory will get released when we go out of scope.
 }
 
 // In mouse lock mode, we need to prevent the (invisible) cursor from hitting
 // the border of the view, in order to get valid movement information. However,
 // forcing the cursor back to the center of the view after each mouse move
 // doesn't work well. It reduces the frequency of useful mouse move messages
 // significantly. Therefore, we move the cursor to the center of the view only
 // if it approaches the border. |kMouseLockBorderPercentage| specifies the width
 // of the border area, in percentage of the corresponding dimension.
@@ skipping 989 matching lines @@
           &RenderWidgetHostViewAura::
                CopyFromCompositingSurfaceHasResultForVideo,
           AsWeakPtr(),  // For caching the ReadbackYUVInterface on this class.
           subscriber_texture,
           target,
           callback));
   gfx::Rect src_subrect_in_pixel =
       ConvertRectToPixel(current_device_scale_factor_, src_subrect);
   request->set_area(src_subrect_in_pixel);
   if (subscriber_texture) {
-    request->SetTextureMailbox(cc::TextureMailbox(
-        subscriber_texture->mailbox(), subscriber_texture->sync_point()));
+    request->SetTextureMailbox(
+        cc::TextureMailbox(subscriber_texture->mailbox(),
+                           subscriber_texture->target(),
+                           subscriber_texture->sync_point()));
   }
   window_->layer()->RequestCopyOfOutput(request.Pass());
 }
 
 bool RenderWidgetHostViewAura::CanCopyToBitmap() const {
   return GetCompositor() && window_->layer()->has_external_content();
 }
 
 bool RenderWidgetHostViewAura::CanCopyToVideoFrame() const {
   return GetCompositor() &&
@@ skipping 721 matching lines @@
   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.mailbox(),
       texture_mailbox.sync_point(),
       result->size(),
       gfx::Rect(result->size()),
       dst_size_in_pixel,
       pixels,
       base::Bind(&CopyFromCompositingSurfaceFinished,
                  callback,
                  base::Passed(&release_callback),
                  base::Passed(&bitmap),
                  base::Passed(&bitmap_pixels_lock)));
@@ skipping 36 matching lines @@
 
   GLHelper* gl_helper = ImageTransportFactory::GetInstance()->GetGLHelper();
   uint32 sync_point = gl_helper ? gl_helper->InsertSyncPoint() : 0;
   if (release_callback) {
     DCHECK(!subscriber_texture);
     release_callback->Run(sync_point, false);
   } else {
     // If there's no release callback, then the texture is from
     // idle_frame_subscriber_textures_ and we can put it back there.
     DCHECK(subscriber_texture);
-    subscriber_texture->UpdateSyncPoint(sync_point);
+    subscriber_texture->set_sync_point(sync_point);
     if (rwhva && rwhva->frame_subscriber_ && subscriber_texture->texture_id())
       rwhva->idle_frame_subscriber_textures_.push_back(subscriber_texture);
     subscriber_texture = NULL;
   }
 }
 
 // static
 void RenderWidgetHostViewAura::CopyFromCompositingSurfaceHasResultForVideo(
     base::WeakPtr<RenderWidgetHostViewAura> rwhva,
     scoped_refptr<OwnedMailbox> subscriber_texture,
@@ skipping 104 matching lines @@
     yuv_readback_pipeline = rwhva->yuv_readback_pipeline_.get();
   }
 
   ignore_result(scoped_callback_runner.Release());
   base::Callback<void(bool result)> finished_callback = base::Bind(
       &RenderWidgetHostViewAura::CopyFromCompositingSurfaceFinishedForVideo,
       rwhva->AsWeakPtr(),
       callback,
       subscriber_texture,
       base::Passed(&release_callback));
-  yuv_readback_pipeline->ReadbackYUV(
-      texture_mailbox.name(),
-      texture_mailbox.sync_point(),
-      video_frame.get(),
-      finished_callback);
+  yuv_readback_pipeline->ReadbackYUV(texture_mailbox.mailbox(),
+                                     texture_mailbox.sync_point(),
+                                     video_frame.get(),
+                                     finished_callback);
 }
 
 void RenderWidgetHostViewAura::GetScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, window_->GetRootWindow() ? window_ : NULL);
 }
 
 gfx::Rect RenderWidgetHostViewAura::GetBoundsInRootWindow() {
 #if defined(OS_WIN)
   // aura::Window::GetBoundsInScreen doesn't take non-client area into
   // account.
@@ skipping 1402 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content