Fix assorted issues with remote CoreAnimation

content/common/gpu/image_transport_surface_fbo_mac.mm

 // Copyright 2014 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/common/gpu/image_transport_surface_fbo_mac.h"
 
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/gpu/image_transport_surface_calayer_mac.h"
 #include "content/common/gpu/image_transport_surface_iosurface_mac.h"
 #include "ui/base/cocoa/remote_layer_api.h"
@@ skipping 10 matching lines @@
     gfx::PluginWindowHandle handle)
     : backbuffer_suggested_allocation_(true),
       frontbuffer_suggested_allocation_(true),
       fbo_id_(0),
       texture_id_(0),
       depth_stencil_renderbuffer_id_(0),
       has_complete_framebuffer_(false),
       context_(NULL),
       scale_factor_(1.f),
       made_current_(false),
-      is_swap_buffers_pending_(false),
-      did_unschedule_(false) {
+      is_swap_buffers_send_pending_(false) {
   if (ui::RemoteLayerAPISupported())
     storage_provider_.reset(new CALayerStorageProvider(this));
   else
     storage_provider_.reset(new IOSurfaceStorageProvider(this));
   helper_.reset(new ImageTransportHelper(this, manager, stub, handle));
 }
 
 ImageTransportSurfaceFBO::~ImageTransportSurfaceFBO() {
 }
 
@@ skipping 12 matching lines @@
   return true;
 }
 
 void ImageTransportSurfaceFBO::Destroy() {
   DestroyFramebuffer();
 
   helper_->Destroy();
 }
 
 bool ImageTransportSurfaceFBO::DeferDraws() {
-  // The command buffer hit a draw/clear command that could clobber the
-  // IOSurface in use by an earlier SwapBuffers. If a Swap is pending, abort
-  // processing of the command by returning true and unschedule until the Swap
-  // Ack arrives.
-  if(did_unschedule_)
-    return true;  // Still unscheduled, so just return true.
-  if (is_swap_buffers_pending_) {
-    did_unschedule_ = true;
-    helper_->SetScheduled(false);
-    return true;
-  }
+  storage_provider_->WillWriteToBackbuffer();
+  // We should not have a pending send when we are drawing the next frame.
+  DCHECK(!is_swap_buffers_send_pending_);

[piman, 2014/08/27 22:13:05]

Is that DCHECK also invalid while the TODO in
CALayerStorageProvider::WillWriteToBackbuffer is in place?

[ccameron, 2014/08/27 22:46:08]

This is still valid.

At the moment it is valid, because the browser will respect the rule "don't
issue any additional GPU commands until you have received the IPC telling you
that the last frame is ready".

After the subsequent CL (still in the works), it will either be invalid (b/c the
browser will stop respecting this), or it will still be valid (because, even
though the browser doesn't respect this, the WillWriteToBackbuffer will issue
the IPC anyway). I have to see which way that will go (not certain yet).

But for now, this is valid.

   return false;
 }
 
 bool ImageTransportSurfaceFBO::IsOffscreen() {
   return false;
 }
 
 bool ImageTransportSurfaceFBO::OnMakeCurrent(gfx::GLContext* context) {
   context_ = context;
 
   if (made_current_)
     return true;
 
   OnResize(gfx::Size(1, 1), 1.f);
 
   made_current_ = true;
   return true;
 }
 
 unsigned int ImageTransportSurfaceFBO::GetBackingFrameBufferObject() {
   return fbo_id_;
 }
 
 bool ImageTransportSurfaceFBO::SetBackbufferAllocation(bool allocation) {
   if (backbuffer_suggested_allocation_ == allocation)
     return true;
   backbuffer_suggested_allocation_ = allocation;
   AdjustBufferAllocation();
+  if (!allocation)
+    storage_provider_->DiscardBackbuffer();
   return true;
 }
 
 void ImageTransportSurfaceFBO::SetFrontbufferAllocation(bool allocation) {
   if (frontbuffer_suggested_allocation_ == allocation)
     return;
   frontbuffer_suggested_allocation_ = allocation;
   AdjustBufferAllocation();
 }
 
 void ImageTransportSurfaceFBO::AdjustBufferAllocation() {
   // On mac, the frontbuffer and backbuffer are the same buffer. The buffer is
   // free'd when both the browser and gpu processes have Unref'd the IOSurface.
   if (!backbuffer_suggested_allocation_ &&
       !frontbuffer_suggested_allocation_ &&
       has_complete_framebuffer_) {
     DestroyFramebuffer();
     helper_->Suspend();
   } else if (backbuffer_suggested_allocation_ && !has_complete_framebuffer_) {
     CreateFramebuffer();
   }
 }
 
 bool ImageTransportSurfaceFBO::SwapBuffers() {
   DCHECK(backbuffer_suggested_allocation_);
   if (!frontbuffer_suggested_allocation_)
     return true;
   glFlush();
 
-  GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params;
-  params.surface_handle = storage_provider_->GetSurfaceHandle();
-  params.size = GetSize();
-  params.scale_factor = scale_factor_;
-  params.latency_info.swap(latency_info_);
-  helper_->SendAcceleratedSurfaceBuffersSwapped(params);
-
-  DCHECK(!is_swap_buffers_pending_);
-  is_swap_buffers_pending_ = true;
-
-  storage_provider_->WillSwapBuffers();
+  // It is the responsibility of the storage provider to send the swap IPC.
+  is_swap_buffers_send_pending_ = true;
+  storage_provider_->SwapBuffers(size_, scale_factor_);
   return true;
 }
 
+void ImageTransportSurfaceFBO::SendSwapBuffers(uint64 surface_handle,
+                                               const gfx::Size pixel_size,
+                                               float scale_factor) {
+  GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params;
+  params.surface_handle = surface_handle;
+  params.size = pixel_size;
+  params.scale_factor = scale_factor;
+  params.latency_info.swap(latency_info_);
+  helper_->SendAcceleratedSurfaceBuffersSwapped(params);
+  is_swap_buffers_send_pending_ = false;
+}
+
 bool ImageTransportSurfaceFBO::PostSubBuffer(
     int x, int y, int width, int height) {
   // Mac does not support sub-buffer swaps.
   NOTREACHED();
   return false;
 }
 
 bool ImageTransportSurfaceFBO::SupportsPostSubBuffer() {
   return true;
 }
 
 gfx::Size ImageTransportSurfaceFBO::GetSize() {
   return size_;
 }
 
 void* ImageTransportSurfaceFBO::GetHandle() {
   return NULL;
 }
 
 void* ImageTransportSurfaceFBO::GetDisplay() {
   return NULL;
 }
 
 void ImageTransportSurfaceFBO::OnBufferPresented(
     const AcceleratedSurfaceMsg_BufferPresented_Params& params) {
   context_->share_group()->SetRendererID(params.renderer_id);
-  storage_provider_->CanFreeSwappedBuffer();
-}
-
-void ImageTransportSurfaceFBO::UnblockContextAfterPendingSwap() {
-  DCHECK(is_swap_buffers_pending_);
-  is_swap_buffers_pending_ = false;
-  if (did_unschedule_) {
-    did_unschedule_ = false;
-    helper_->SetScheduled(true);
-  }
+  storage_provider_->SwapBuffersAckedByBrowser();
 }
 
 void ImageTransportSurfaceFBO::OnResize(gfx::Size size,
                                         float scale_factor) {
   TRACE_EVENT2("gpu", "ImageTransportSurfaceFBO::OnResize",
                "old_width", size_.width(), "new_width", size.width());
   // Caching |context_| from OnMakeCurrent. It should still be current.
   DCHECK(context_->IsCurrent(this));
 
   size_ = size;
@@ skipping 132 matching lines @@
     return;
   }
 
   has_complete_framebuffer_ = true;
 
   glBindTexture(GL_TEXTURE_RECTANGLE_ARB, previous_texture_id);
   // The FBO remains bound for this GL context.
 }
 
 }  // namespace content