Aura: PostSubBuffer implementation for --ui-use-gpu-process

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 172 matching lines @@
   CHECK_GL_ERROR();
   fbo_id_ = 0;
 
   stub->RemoveDestructionObserver(this);
   stub_destroyed_ = true;
 }
 
 bool TextureImageTransportSurface::SwapBuffers() {
   glFlush();
   front_ = back();
+  previous_damage_rect_ = gfx::Rect(textures_[front_].size);
 
   GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params;
   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) {
-  // TODO(piman): implement this, similarly to EGLImageTransportSurface.
-  NOTREACHED();
-  return false;
+  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);
+  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;
+
+  const gfx::Rect new_damage_rect = gfx::Rect(x, y, width, height);

[apatrick_chromium, 2012/03/01 19:35:54]

const gfx::Rect new_damage_rect(x, y, width, height);

is shorter.

+  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();
+
+  GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params params;
+  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_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_.get() ? parent_stub_->surface()->GetHandle() : NULL;
 }
@@ skipping 11 matching lines @@
       AttachBackTextureToFBO();
     }
   }
 
   // Even if MakeCurrent fails, schedule anyway, to trigger the lost context
   // logic.
   helper_->SetScheduled(true);
 }
 
 void TextureImageTransportSurface::OnPostSubBufferACK() {
-  NOTREACHED();
+  OnBuffersSwappedACK();
 }
 
 void TextureImageTransportSurface::OnResizeViewACK() {
   NOTREACHED();
 }
 
 void TextureImageTransportSurface::ReleaseBackTexture() {
   if (!parent_stub_.get())
     return;
   TextureInfo* info = GetParentInfo(textures_[back()].client_id);
@@ skipping 95 matching lines @@
 #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;
 }