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 38 matching lines @@
 };
 
 }  // anonymous namespace
 
 TextureImageTransportSurface::TextureImageTransportSurface(
     GpuChannelManager* manager,
     GpuCommandBufferStub* stub,
     const gfx::GLSurfaceHandle& handle)
       : fbo_id_(0),
         front_(0),
-        stub_destroyed_(false) {
+        stub_destroyed_(false),
+        backbuffer_allocated_(true),
+        frontbuffer_allocated_(true) {
   GpuChannel* parent_channel = manager->LookupChannel(handle.parent_client_id);
   DCHECK(parent_channel);
   GpuCommandBufferStub* parent_stub = parent_channel->LookupCommandBuffer(
       handle.parent_context_id);
   DCHECK(parent_stub);
   parent_stub_ = parent_stub->AsWeakPtr();
   TextureManager* texture_manager =
       parent_stub_->decoder()->GetContextGroup()->texture_manager();
   DCHECK(texture_manager);
 
@@ skipping 52 matching lines @@
   if (stub_destroyed_) {
     // Early-exit so that we don't recreate the fbo. We still want to return
     // true, so that the context is made current and the GLES2DecoderImpl can
     // release its own resources.
     return true;
   }
 
   if (!fbo_id_) {
     glGenFramebuffersEXT(1, &fbo_id_);
     glBindFramebufferEXT(GL_FRAMEBUFFER, fbo_id_);
-    CreateBackTexture(gfx::Size(1, 1));
+    CreateTexture(back(), gfx::Size(1, 1));
 
 #ifndef NDEBUG
     GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
     if (status != GL_FRAMEBUFFER_COMPLETE) {
       DLOG(ERROR) << "Framebuffer incomplete.";
       return false;
     }
 #endif
   }
 
   return true;
 }
 
 unsigned int TextureImageTransportSurface::GetBackingFrameBufferObject() {
   return fbo_id_;
 }
 
-void TextureImageTransportSurface::SetBufferAllocation(
-    BufferAllocationState state) {
+void TextureImageTransportSurface::SetBackbufferAllocation(bool allocated) {
+  if (backbuffer_allocated_ == allocated)
+    return;
   if (!helper_->MakeCurrent())
     return;
-  switch (state) {
-    case BUFFER_ALLOCATION_FRONT_AND_BACK:
-      CreateBackTexture(textures_[back()].size);
-      break;
-    case BUFFER_ALLOCATION_FRONT_ONLY:
-    case BUFFER_ALLOCATION_NONE:
-      ReleaseBackTexture();
-      break;
-  };
+  if (allocated)
+    CreateTexture(back(), textures_[back()].size);
+  else
+    RequestReleaseTexture(back());
+}
+
+void TextureImageTransportSurface::SetFrontbufferAllocation(bool allocated) {
+  if (frontbuffer_allocated_ == allocated)
+    return;
+  if (!helper_->MakeCurrent())
+    return;
+  if (allocated)
+    CreateTexture(front(), textures_[front()].size);

[mmocny, 2012/04/12 16:41:27]

I am playing with delaying this recreation until after the next
swap/postsubbuffer.  Otherwise, we tell the browser we have a new surface, but
its contents are empty and we display a blank frame (flash white).
Also, we have an open issue to delay switching tabs until after frontbuffer is
valid -- and since the browser has no way of knowing that contents are empty --
delaying AcceleratedSurfaceNew seems like the best option.

+  else
+    RequestReleaseTexture(front());
 }
 
 void* TextureImageTransportSurface::GetShareHandle() {
   return GetHandle();
 }
 
 void* TextureImageTransportSurface::GetDisplay() {
   return parent_stub_.get() ? parent_stub_->surface()->GetDisplay() : NULL;
 }
 
 void* TextureImageTransportSurface::GetConfig() {
   return parent_stub_.get() ? parent_stub_->surface()->GetConfig() : NULL;
 }
 
 void TextureImageTransportSurface::OnResize(gfx::Size size) {
-  CreateBackTexture(size);
+  CreateTexture(back(), size);
 }
 
 void TextureImageTransportSurface::OnWillDestroyStub(
     GpuCommandBufferStub* stub) {
   glDeleteFramebuffersEXT(1, &fbo_id_);
   CHECK_GL_ERROR();
   fbo_id_ = 0;
 
   stub->RemoveDestructionObserver(this);
   stub_destroyed_ = true;
 }
 
 bool TextureImageTransportSurface::SwapBuffers() {
+  DCHECK(backbuffer_allocated_);
+  if (!frontbuffer_allocated_) {
+    previous_damage_rect_ = gfx::Rect(textures_[back()].size);
+    return true;
+  }
   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) {
+  DCHECK(backbuffer_allocated_);
+  if (!frontbuffer_allocated_) {
+    previous_damage_rect_ = gfx::Rect(textures_[back()].size);

[mmocny, 2012/04/12 16:41:27]

I think I got this backwards, previous_damage_rect_ should become empty here.

As a coincidence it doesn't matter, because we only recreate frontbuffer before
recreating backbuffer and redrawing a whole frame.

+    return true;
+  }
   if (!parent_stub_.get())
     return false;
 
   TextureInfo* info = GetParentInfo(textures_[back()].client_id);
   if (!info)
     return false;
   int back_texture_service_id = info->service_id();
 
-  info = GetParentInfo(textures_[front_].client_id);
+  info = GetParentInfo(textures_[front()].client_id);
   if (!info)
     return false;
   int front_texture_service_id = info->service_id();
 
   gfx::Size expected_size = textures_[back()].size;
-  bool surfaces_same_size = textures_[front_].size == expected_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;
 
   if (surfaces_same_size) {
     std::vector<gfx::Rect> regions_to_copy;
     GetRegionsToCopy(previous_damage_rect_, new_damage_rect, &regions_to_copy);
@@ skipping 15 matching lines @@
       }
     }
   } else {
     DCHECK(new_damage_rect == gfx::Rect(expected_size));
   }
 
   glFlush();
   front_ = back();
 
   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;
 }
@@ skipping 12 matching lines @@
 
 void* TextureImageTransportSurface::GetHandle() {
   return parent_stub_.get() ? parent_stub_->surface()->GetHandle() : NULL;
 }
 
 
 void TextureImageTransportSurface::OnNewSurfaceACK(
     uint64 surface_handle, TransportDIB::Handle /*shm_handle*/) {
 }
 
+void TextureImageTransportSurface::OnReleaseSurfaceACK(
+    uint64 surface_id, bool success) {
+  if (success)
+    ReleaseTexture(textures_[front()].client_id == surface_id ?
+                   front() : back());
+  helper_->SetScheduled(true);
+}
+
 void TextureImageTransportSurface::OnBuffersSwappedACK() {
   if (helper_->MakeCurrent()) {
-    if (textures_[front_].size != textures_[back()].size) {
-      CreateBackTexture(textures_[front_].size);
+    if (textures_[front()].size != textures_[back()].size) {
+      CreateTexture(back(), textures_[front()].size);
     } else {
-      AttachBackTextureToFBO();
+      AttachTextureToFBO(back());
     }
   }
 
   // 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::RequestReleaseTexture(int id) {
+  Texture& texture = textures_[id];
+  if (!texture.sent_to_client) {
+    ReleaseTexture(id);
+    return;
+  }
+  GpuHostMsg_AcceleratedSurfaceRelease_Params params;
+  params.identifier = texture.client_id;
+  helper_->SendAcceleratedSurfaceRelease(params);
+  helper_->SetScheduled(false);
+}
+
+void TextureImageTransportSurface::ReleaseTexture(int id) {
   if (!parent_stub_.get())
     return;
-  TextureInfo* info = GetParentInfo(textures_[back()].client_id);
+  Texture& texture = textures_[id];
+  TextureInfo* info = GetParentInfo(texture.client_id);
   if (!info)
     return;
 
   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();
+  texture.sent_to_client = false;
+  if (id == front())
+    frontbuffer_allocated_ = false;
+  else
+    backbuffer_allocated_ = false;
 }
 
-void TextureImageTransportSurface::CreateBackTexture(const gfx::Size& size) {
+void TextureImageTransportSurface::CreateTexture(
+    int id, const gfx::Size& size) {
   if (!parent_stub_.get())
     return;
-  Texture& texture = textures_[back()];
+  Texture& texture = textures_[id];
   TextureInfo* info = GetParentInfo(texture.client_id);
   if (!info)
     return;
 
   GLuint service_id = info->service_id();
 
   if (service_id && texture.size == size)
     return;
 
   if (!service_id) {
@@ skipping 24 matching lines @@
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
         size.width(), size.height(), 0,
         GL_RGBA, GL_UNSIGNED_BYTE, NULL);
     CHECK_GL_ERROR();
   }
 
-  AttachBackTextureToFBO();
+  AttachTextureToFBO(id);
 
   GpuHostMsg_AcceleratedSurfaceNew_Params params;
   params.width = size.width();
   params.height = size.height();
   params.surface_handle = texture.client_id;
   helper_->SendAcceleratedSurfaceNew(params);
   texture.sent_to_client = true;
+
+  if (id == front())
+    frontbuffer_allocated_ = true;
+  else
+    backbuffer_allocated_ = true;
 }
 
-void TextureImageTransportSurface::AttachBackTextureToFBO() {
+void TextureImageTransportSurface::AttachTextureToFBO(int id) {
   if (!parent_stub_.get())
     return;
-  TextureInfo* info = GetParentInfo(textures_[back()].client_id);
+  TextureInfo* info = GetParentInfo(textures_[id].client_id);
   if (!info)
     return;
 
   ScopedFrameBufferBinder fbo_binder(fbo_id_);
   glFramebufferTexture2DEXT(GL_FRAMEBUFFER,
       GL_COLOR_ATTACHMENT0,
       GL_TEXTURE_2D,
       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
 }
 
 TextureInfo* TextureImageTransportSurface::GetParentInfo(uint32 client_id) {
   DCHECK(parent_stub_.get());
   TextureManager* texture_manager =
       parent_stub_->decoder()->GetContextGroup()->texture_manager();
   TextureInfo* info = texture_manager->GetTextureInfo(client_id);
   return info;
 }