Drop frontbuffers with ui-use-gpu-process, synchronized with browser, decoupled from backbuffer dro…

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 "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/gpu_channel_manager.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "gpu/command_buffer/service/context_group.h"
@@ skipping 49 matching lines @@
 
 TextureImageTransportSurface::TextureImageTransportSurface(
     GpuChannelManager* manager,
     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),
+        ui_may_not_have_frontbuffer_handle_(false),
+        current_valid_release_front_request_id_(0),
+        next_unique_release_front_request_id_(0),
         parent_stub_(NULL) {
   GpuChannel* parent_channel = manager->LookupChannel(handle.parent_client_id);
   DCHECK(parent_channel);
   parent_stub_ = parent_channel->LookupCommandBuffer(handle.parent_context_id);
   DCHECK(parent_stub_);
   parent_stub_->AddDestructionObserver(this);
   TextureManager* texture_manager =
       parent_stub_->decoder()->GetContextGroup()->texture_manager();
   DCHECK(texture_manager);
 
@@ skipping 81 matching lines @@
   if (backbuffer_suggested_allocation_ == allocation)
      return;
   backbuffer_suggested_allocation_ = allocation;
 
   if (!helper_->MakeCurrent())
     return;
 
   if (backbuffer_suggested_allocation_)
     CreateBackTexture(textures_[back()].size);
   else
-    ReleaseBackTexture();
+    ReleaseTexture(back());
 }
 
 void TextureImageTransportSurface::SetFrontbufferAllocation(bool allocation) {
   if (frontbuffer_suggested_allocation_ == allocation)
     return;
   frontbuffer_suggested_allocation_ = allocation;
+  AdjustFrontBufferAllocation(0);
+}
+
+void TextureImageTransportSurface::AdjustFrontBufferAllocation(
+    int retry_count) {
+  if (!helper_->MakeCurrent())
+    return;
+
+  if (!frontbuffer_suggested_allocation_ &&
+      textures_[front()].info->service_id() &&
+      !frontbuffer_is_protected_)
+    RequestReleaseFrontTexture(retry_count);
 }
 
 void* TextureImageTransportSurface::GetShareHandle() {
   return GetHandle();
 }
 
 void* TextureImageTransportSurface::GetDisplay() {
   return parent_stub_ ? parent_stub_->surface()->GetDisplay() : NULL;
 }
 
@@ skipping 15 matching lines @@
     // resources we allocated in the stub's context.
     glDeleteFramebuffersEXT(1, &fbo_id_);
     CHECK_GL_ERROR();
     fbo_id_ = 0;
 
     stub_destroyed_ = true;
   }
 }
 
 bool TextureImageTransportSurface::SwapBuffers() {
+  current_valid_release_front_request_id_ = 0;
   DCHECK(backbuffer_suggested_allocation_);
   if (!frontbuffer_suggested_allocation_)
     return true;
   if (!parent_stub_) {
     LOG(ERROR) << "SwapBuffers failed because no parent stub.";
     return false;
   }
 
   glFlush();
   front_ = back();
-  previous_damage_rect_ = gfx::Rect(textures_[front_].size);
+  previous_damage_rect_ = gfx::Rect(textures_[front()].size);
 
-  DCHECK(textures_[front_].client_id != 0);
+  DCHECK(textures_[front()].client_id != 0);
 
   GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params;
-  params.surface_handle = textures_[front_].client_id;
+  params.surface_handle = textures_[front()].client_id;
   helper_->SendAcceleratedSurfaceBuffersSwapped(params);
   helper_->SetScheduled(false);
   return true;
 }
 
 bool TextureImageTransportSurface::PostSubBuffer(
     int x, int y, int width, int height) {
+  current_valid_release_front_request_id_ = 0;
   DCHECK(backbuffer_suggested_allocation_);
   if (!frontbuffer_suggested_allocation_)
     return true;
   // If we are recreating the frontbuffer with this swap, make sure we are
   // drawing a full frame.
   DCHECK(textures_[front_].info->service_id() ||
          (!x && !y && gfx::Size(width, height) == textures_[back()].size));
   if (!parent_stub_) {
     LOG(ERROR) << "PostSubBuffer failed because no parent stub.";
     return false;
   }
 
-  DCHECK(textures_[back()].info);
-  int back_texture_service_id = textures_[back()].info->service_id();
-
-  DCHECK(textures_[front_].info);
-  int front_texture_service_id = textures_[front_].info->service_id();
-
-  gfx::Size expected_size = textures_[back()].size;
-  bool surfaces_same_size = textures_[front_].size == expected_size;
-
   const gfx::Rect new_damage_rect(x, y, width, height);
 
   // An empty damage rect is a successful no-op.
   if (new_damage_rect.IsEmpty())
     return true;
 
+  int back_texture_service_id = textures_[back()].info->service_id();
+  int front_texture_service_id = textures_[front()].info->service_id();
+
+  gfx::Size expected_size = textures_[back()].size;
+  bool surfaces_same_size = textures_[front()].size == expected_size;
+
   if (surfaces_same_size) {
     std::vector<gfx::Rect> regions_to_copy;
     GetRegionsToCopy(previous_damage_rect_, new_damage_rect, &regions_to_copy);
 
     ScopedFrameBufferBinder fbo_binder(fbo_id_);
     glFramebufferTexture2DEXT(GL_FRAMEBUFFER,
         GL_COLOR_ATTACHMENT0,
         GL_TEXTURE_2D,
         front_texture_service_id,
         0);
     ScopedTextureBinder texture_binder(back_texture_service_id);
 
     for (size_t i = 0; i < regions_to_copy.size(); ++i) {
       const gfx::Rect& region_to_copy = regions_to_copy[i];
       if (!region_to_copy.IsEmpty()) {
         glCopyTexSubImage2D(GL_TEXTURE_2D, 0, region_to_copy.x(),
             region_to_copy.y(), region_to_copy.x(), region_to_copy.y(),
             region_to_copy.width(), region_to_copy.height());
       }
     }
   } else {
     DCHECK(new_damage_rect == gfx::Rect(expected_size));
   }
 
   glFlush();
   front_ = back();
+  previous_damage_rect_ = new_damage_rect;
+
+  DCHECK(textures_[front()].client_id != 0);
 
   GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params params;
-  params.surface_handle = textures_[front_].client_id;
+  params.surface_handle = textures_[front()].client_id;
   params.x = x;
   params.y = y;
   params.width = width;
   params.height = height;
   helper_->SendAcceleratedSurfacePostSubBuffer(params);
   helper_->SetScheduled(false);
-
-  previous_damage_rect_ = new_damage_rect;
   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;
 }
 
 gfx::Size TextureImageTransportSurface::GetSize() {
   return textures_[back()].size;
 }
 
 void* TextureImageTransportSurface::GetHandle() {
   return parent_stub_ ? parent_stub_->surface()->GetHandle() : NULL;
 }
 
 
 void TextureImageTransportSurface::OnNewSurfaceACK(
     uint64 surface_handle, TransportDIB::Handle /*shm_handle*/) {
 }
 
+void TextureImageTransportSurface::OnSetFrontSurfaceIsProtected(
+    bool is_protected) {
+  if (frontbuffer_is_protected_ == is_protected)
+    return;
+  frontbuffer_is_protected_ = is_protected;
+  AdjustFrontBufferAllocation(0);
+}
+
+void TextureImageTransportSurface::OnRequestReleaseFrontACK(
+    int request_id, int retry_count, bool was_released) {
+  if (!was_released) {
+    // If the browser ignored out request, but the request id is still valid,
+    // call AdjustFrontBufferAllocation, which will send another request only if
+    // it still makes sense to do so.  This can happen with visibility ABA
+    // transitions.
+    if (request_id == current_valid_release_front_request_id_ &&
+        retry_count < kMaxRequestReleaseFrontRetries)
+      AdjustFrontBufferAllocation(retry_count + 1);
+    return;
+  }
+  if (frontbuffer_suggested_allocation_ || frontbuffer_is_protected_ ||
+      request_id != current_valid_release_front_request_id_)
+    return;
+  Texture& texture = textures_[front()];
+  texture.sent_to_client = false;
+  ReleaseTexture(front());
+}
+
 void TextureImageTransportSurface::OnBuffersSwappedACK() {
   if (helper_->MakeCurrent()) {
-    if (textures_[front_].size != textures_[back()].size) {
-      CreateBackTexture(textures_[front_].size);
+    if (textures_[front()].size != textures_[back()].size ||
+        !textures_[back()].info->service_id() ||
+        !textures_[back()].sent_to_client ||
+        ui_may_not_have_frontbuffer_handle_) {
+      CreateBackTexture(textures_[front()].size);
+      ui_may_not_have_frontbuffer_handle_ = false;
     } else {
       AttachBackTextureToFBO();
     }
   }
 
   // Even if MakeCurrent fails, schedule anyway, to trigger the lost context
   // logic.
   helper_->SetScheduled(true);
 }
 
 void TextureImageTransportSurface::OnPostSubBufferACK() {
   OnBuffersSwappedACK();
 }
 
 void TextureImageTransportSurface::OnResizeViewACK() {
   NOTREACHED();
 }
 
-void TextureImageTransportSurface::ReleaseBackTexture() {
+void TextureImageTransportSurface::RequestReleaseFrontTexture(int retry_count) {
+  Texture& texture = textures_[front()];
+  DCHECK(texture.info);
+  DCHECK(texture.info->service_id());
+  if (!texture.sent_to_client) {
+    ReleaseTexture(front());
+    return;
+  }
+  if (!retry_count)
+    current_valid_release_front_request_id_ =
+        ++next_unique_release_front_request_id_;
+  GpuHostMsg_AcceleratedSurfaceRequestReleaseFront_Params params;
+  params.identifier = texture.client_id;
+  params.request_id = current_valid_release_front_request_id_;
+  params.retry_count = retry_count;
+  helper_->SendAcceleratedSurfaceRequestReleaseFront(params);
+  ui_may_not_have_frontbuffer_handle_ = true;
+}
+
+void TextureImageTransportSurface::ReleaseTexture(int id) {
   if (!parent_stub_)
     return;
-  TextureInfo* info = textures_[back()].info;
+  Texture& texture = textures_[id];
+  TextureInfo* info = texture.info;
   DCHECK(info);
 
   GLuint service_id = info->service_id();
   if (!service_id)
     return;
   info->SetServiceId(0);
 
   {
     ScopedFrameBufferBinder fbo_binder(fbo_id_);
     glDeleteTextures(1, &service_id);
   }
   glFlush();
   CHECK_GL_ERROR();
 }
 
 void TextureImageTransportSurface::CreateBackTexture(const gfx::Size& size) {
   if (!parent_stub_)
     return;
   Texture& texture = textures_[back()];
   TextureInfo* info = texture.info;
   DCHECK(info);
 
   GLuint service_id = info->service_id();
 
-  if (service_id && texture.size == size)
+  if (service_id && texture.size == size &&
+      !ui_may_not_have_frontbuffer_handle_ && texture.sent_to_client)
     return;
 
   if (!service_id) {
     glGenTextures(1, &service_id);
     info->SetServiceId(service_id);
   }
 
   if (size != texture.size) {
     texture.size = size;
     TextureManager* texture_manager =
@@ skipping 30 matching lines @@
   params.width = size.width();
   params.height = size.height();
   params.surface_handle = texture.client_id;
   helper_->SendAcceleratedSurfaceNew(params);
   texture.sent_to_client = true;
 }
 
 void TextureImageTransportSurface::AttachBackTextureToFBO() {
   if (!parent_stub_)
     return;
-  DCHECK(textures_[back()].info);
+  TextureInfo* info = textures_[back()].info;
+  DCHECK(info);
 
   ScopedFrameBufferBinder fbo_binder(fbo_id_);
   glFramebufferTexture2DEXT(GL_FRAMEBUFFER,
       GL_COLOR_ATTACHMENT0,
       GL_TEXTURE_2D,
-      textures_[back()].info->service_id(),
+      info->service_id(),
       0);
   glFlush();
   CHECK_GL_ERROR();
 
 #ifndef NDEBUG
   GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
   if (status != GL_FRAMEBUFFER_COMPLETE) {
     DLOG(ERROR) << "Framebuffer incomplete.";
   }
 #endif
 }
 
 void TextureImageTransportSurface::ReleaseParentStub() {
   DCHECK(parent_stub_);
   parent_stub_->RemoveDestructionObserver(this);
   for (int i = 0; i < 2; ++i) {
     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;
 }