Aura: Keep scheduling in line with other platforms.

content/common/gpu/texture_image_transport_surface.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/common/gpu/texture_image_transport_surface.h"
 
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 24 matching lines @@
     GpuCommandBufferStub* stub,
     const gfx::GLSurfaceHandle& handle)
       : fbo_id_(0),
         front_(0),
         stub_destroyed_(false),
         backbuffer_suggested_allocation_(true),
         frontbuffer_suggested_allocation_(true),
         frontbuffer_is_protected_(true),
         protection_state_id_(0),
         handle_(handle),
-        parent_stub_(NULL) {
+        parent_stub_(NULL),
+        is_swap_buffers_pending_(false),
+        did_unschedule_(false) {
   helper_.reset(new ImageTransportHelper(this,
                                          manager,
                                          stub,
                                          gfx::kNullPluginWindow));
 }
 
 TextureImageTransportSurface::~TextureImageTransportSurface() {
   DCHECK(stub_destroyed_);
   Destroy();
 }
@@ skipping 53 matching lines @@
   }
 
   if (surface_.get()) {
     surface_->Destroy();
     surface_ = NULL;
   }
 
   helper_->Destroy();
 }
 
+bool TextureImageTransportSurface::DeferDraws() {
+  // The command buffer hit a draw/clear command that could clobber the
+  // texture in use by the UI compositor. If a Swap is pending, abort
+  // processing of the command by returning true and unschedule until the Swap
+  // Ack arrives.
+  if (did_unschedule_)

[piman, 2012/09/24 16:29:48]

nit: How can this be called at all if we're unscheduled? Should we just assert?

[jonathan.backer, 2012/09/24 21:08:18]

Done.

+    return true;  // Still unscheduled, so just return true.
+  if (is_swap_buffers_pending_) {
+    did_unschedule_ = true;
+    helper_->SetScheduled(false);
+    return true;
+  }
+  return false;
+}
+
 bool TextureImageTransportSurface::Resize(const gfx::Size&) {
   return true;
 }
 
 bool TextureImageTransportSurface::IsOffscreen() {
   return true;
 }
 
 bool TextureImageTransportSurface::OnMakeCurrent(gfx::GLContext* context) {
   if (stub_destroyed_) {
@@ skipping 118 matching lines @@
   front_ = back();
   previous_damage_rect_ = gfx::Rect(textures_[front()].size);
 
   DCHECK(textures_[front()].client_id != 0);
 
   GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params;
   params.surface_handle = textures_[front()].client_id;
   params.protection_state_id = protection_state_id_;
   params.skip_ack = false;
   helper_->SendAcceleratedSurfaceBuffersSwapped(params);
-  helper_->SetScheduled(false);
+
+  DCHECK(!is_swap_buffers_pending_);
+  is_swap_buffers_pending_ = true;
   return true;
 }
 
 bool TextureImageTransportSurface::PostSubBuffer(
     int x, int y, int width, int height) {
   DCHECK(backbuffer_suggested_allocation_);
   DCHECK(textures_[back()].info->service_id());
   if (!frontbuffer_suggested_allocation_ || !frontbuffer_is_protected_)
     return true;
   // If we are recreating the frontbuffer with this swap, make sure we are
@@ skipping 48 matching lines @@
   DCHECK(textures_[front()].client_id);
 
   GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params params;
   params.surface_handle = textures_[front()].client_id;
   params.x = x;
   params.y = y;
   params.width = width;
   params.height = height;
   params.protection_state_id = protection_state_id_;
   helper_->SendAcceleratedSurfacePostSubBuffer(params);
-  helper_->SetScheduled(false);
+
+  DCHECK(!is_swap_buffers_pending_);
+  is_swap_buffers_pending_ = true;
   return true;
 }
 
 std::string TextureImageTransportSurface::GetExtensions() {
   std::string extensions = gfx::GLSurface::GetExtensions();
   extensions += extensions.empty() ? "" : " ";
   extensions += "GL_CHROMIUM_front_buffer_cached ";
   extensions += "GL_CHROMIUM_post_sub_buffer";
   return extensions;
 }
@@ skipping 39 matching lines @@
     BufferPresentedImpl();
   } else {
     helper_->manager()->sync_point_manager()->AddSyncPointCallback(
         sync_point,
         base::Bind(&TextureImageTransportSurface::BufferPresentedImpl,
                    this->AsWeakPtr()));
   }
 }
 
 void TextureImageTransportSurface::BufferPresentedImpl() {
+  DCHECK(is_swap_buffers_pending_);
+  is_swap_buffers_pending_ = false;
+
   // We're relying on the fact that the parent context is
   // finished with it's context when it inserts the sync point that
   // triggers this callback.
   if (helper_->MakeCurrent()) {
     if (textures_[front()].size != textures_[back()].size ||
         !textures_[back()].info->service_id() ||
         !textures_[back()].sent_to_client) {
       // We may get an ACK from a stale swap just to reschedule.  In that case,
       // we may not have a backbuffer suggestion and should not recreate one.
       if (backbuffer_suggested_allocation_)
         CreateBackTexture(textures_[front()].size);
     } else {
       AttachBackTextureToFBO();
     }
   }
 
   // Even if MakeCurrent fails, schedule anyway, to trigger the lost context
   // logic.
-  helper_->SetScheduled(true);
+  if (did_unschedule_) {
+    did_unschedule_ = false;
+    helper_->SetScheduled(true);
+  }
 }
 
 void TextureImageTransportSurface::OnResizeViewACK() {
   NOTREACHED();
 }
 
 void TextureImageTransportSurface::ReleaseTexture(int id) {
   if (!parent_stub_)
     return;
   Texture& texture = textures_[id];
@@ skipping 100 matching lines @@
     Texture& texture = textures_[i];
     texture.info = NULL;
     if (!texture.sent_to_client)
       continue;
     GpuHostMsg_AcceleratedSurfaceRelease_Params params;
     params.identifier = texture.client_id;
     helper_->SendAcceleratedSurfaceRelease(params);
   }
   parent_stub_ = NULL;
 }