Partial swap implementation for surfaceless

content/browser/compositor/buffer_queue.cc

 // 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/browser/compositor/buffer_queue.h"
 
 #include "content/common/gpu/client/context_provider_command_buffer.h"
+#include "content/common/gpu/client/gl_helper.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
+#include "third_party/skia/include/core/SkRect.h"
+#include "third_party/skia/include/core/SkRegion.h"
 
 namespace content {
 
 BufferQueue::BufferQueue(scoped_refptr<cc::ContextProvider> context_provider,
+                         GLHelper* gl_helper,
                          unsigned int internalformat)
     : context_provider_(context_provider),
       fbo_(0),
       allocated_count_(0),
-      internalformat_(internalformat) {
+      internalformat_(internalformat),
+      gl_helper_(gl_helper) {
 }
 
 BufferQueue::~BufferQueue() {
   FreeAllSurfaces();
 
   gpu::gles2::GLES2Interface* gl = context_provider_->ContextGL();
   if (fbo_)
     gl->DeleteFramebuffers(1, &fbo_);
 }
 
@@ skipping 10 matching lines @@
   if (!current_surface_.texture) {
     current_surface_ = GetNextSurface();
     gl->FramebufferTexture2D(GL_FRAMEBUFFER,
                              GL_COLOR_ATTACHMENT0,
                              GL_TEXTURE_2D,
                              current_surface_.texture,
                              0);
   }
 }
 
-void BufferQueue::SwapBuffers() {
-  in_flight_surfaces_.push(current_surface_);
+void BufferQueue::CopyBufferDamage(int texture,
+                                   int source_texture,
+                                   const gfx::Rect& exclude_rect,
+                                   const gfx::Rect& copy_rect) {
+  gl_helper_->CopySubBufferDamage(
+      texture,
+      source_texture,
+      SkRegion(SkIRect::MakeXYWH(exclude_rect.x(),
+                                 exclude_rect.y(),
+                                 exclude_rect.width(),
+                                 exclude_rect.height())),
+      SkRegion(SkIRect::MakeXYWH(copy_rect.x(),
+                                 copy_rect.y(),
+                                 copy_rect.width(),
+                                 copy_rect.height())));
+}
+
+void BufferQueue::SwapBuffers(const gfx::Rect& damage) {
+  if (damage != gfx::Rect(size_)) {
+    // We must have a frame available to copy from.
+    DCHECK(!in_flight_surfaces_.empty());
+
+    if (!damage.Contains(current_surface_.damage)) {

[alexst (slow to review), 2014/09/18 15:39:15]

Contract on CopyBufferDamage says "Copies all pixels from |previous_texture|
into |texture| that are inside the region covered by |old_damage| but not part
of |new_damage|."

If I'm reading it right, if old_damage is part of new_damage, it'll be a no-op
and we can skip the check here.

[achaulk, 2014/09/18 16:45:02]

Sure, but we need it anyway for the below set

+      CopyBufferDamage(current_surface_.texture,
+                       in_flight_surfaces_.back().texture,
+                       damage,
+                       current_surface_.damage);
+      // Because we copied everything except |damage| to this texture,
+      // the cumulative damage for this frame is only |damage| now.
+      in_flight_surfaces_.back().damage = damage;

[alexst (slow to review), 2014/09/18 15:39:15]

I think this is redundant with the for loop below since we set damage here then
then again as damage.Union(damage).

[achaulk, 2014/09/18 16:45:02]

Not entirely, the important bit is that it any existing damage. Though because
of the set, there's no difference between setting it to damage or to zero

+    }
+
+    // Compute cumulative damage for all frames.
+    for (size_t i = 0; i < available_surfaces_.size(); i++)

[alexst (slow to review), 2014/09/18 15:39:15]

Can you break this into a separate function SetDamageOnBuffers(const gfx::Rect&
damage) and call it here with the union and below with just damage, these two
for loops are almost identical copies here and below.

[achaulk, 2014/09/18 16:45:02]

Sure

+      available_surfaces_[i].damage.Union(damage);
+    for (std::deque<AllocatedSurface>::iterator it =
+             in_flight_surfaces_.begin();
+         it != in_flight_surfaces_.end();
+         ++it)
+      it->damage.Union(damage);
+  } else {
+    for (size_t i = 0; i < available_surfaces_.size(); i++)
+      available_surfaces_[i].damage = damage;
+    for (std::deque<AllocatedSurface>::iterator it =
+             in_flight_surfaces_.begin();
+         it != in_flight_surfaces_.end();
+         ++it)
+      it->damage = damage;
+  }
+  current_surface_.damage = gfx::Rect();
+  in_flight_surfaces_.push_back(current_surface_);
   current_surface_.texture = 0;
   current_surface_.image = 0;
 }
 
 void BufferQueue::Reshape(const gfx::Size& size, float scale_factor) {
   DCHECK(!current_surface_.texture);
   if (size == size_)
     return;
   size_ = size;
 
   // TODO: add stencil buffer when needed.
   gpu::gles2::GLES2Interface* gl = context_provider_->ContextGL();
   gl->BindFramebuffer(GL_FRAMEBUFFER, fbo_);
   gl->FramebufferTexture2D(
       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
 
   FreeAllSurfaces();
 }
 
 void BufferQueue::PageFlipComplete() {
   if (in_flight_surfaces_.size() > 1) {
     available_surfaces_.push_back(in_flight_surfaces_.front());
-    in_flight_surfaces_.pop();
+    in_flight_surfaces_.pop_front();
   }
 }
 
 void BufferQueue::FreeAllSurfaces() {
   FreeSurface(&current_surface_);
   while (!in_flight_surfaces_.empty()) {
     FreeSurface(&in_flight_surfaces_.front());
-    in_flight_surfaces_.pop();
+    in_flight_surfaces_.pop_front();
   }
   for (size_t i = 0; i < available_surfaces_.size(); i++)
     FreeSurface(&available_surfaces_[i]);
   available_surfaces_.clear();
 }
 
 void BufferQueue::FreeSurface(AllocatedSurface* surface) {
   if (surface->texture) {
     gpu::gles2::GLES2Interface* gl = context_provider_->ContextGL();
     gl->BindTexture(GL_TEXTURE_2D, surface->texture);
     gl->ReleaseTexImage2DCHROMIUM(GL_TEXTURE_2D, surface->image);
     gl->DeleteTextures(1, &surface->texture);
     gl->DestroyImageCHROMIUM(surface->image);
     surface->image = 0;
     surface->texture = 0;
     allocated_count_--;
   }
 }
 
 BufferQueue::AllocatedSurface BufferQueue::GetNextSurface() {
   if (!available_surfaces_.empty()) {
-    AllocatedSurface id = available_surfaces_.back();
+    AllocatedSurface surface = available_surfaces_.back();
     available_surfaces_.pop_back();
-    return id;
+    return surface;
   }
 
   unsigned int texture = 0;
   gpu::gles2::GLES2Interface* gl = context_provider_->ContextGL();
   gl->GenTextures(1, &texture);
   if (!texture)
     return AllocatedSurface();
 
   // We don't want to allow anything more than triple buffering.
   DCHECK_LT(allocated_count_, 4U);
 
   unsigned int id = context_provider_->ContextGL()->CreateImageCHROMIUM(
       size_.width(),
       size_.height(),
       internalformat_,
       GL_IMAGE_SCANOUT_CHROMIUM);
   allocated_count_++;
   gl->BindTexture(GL_TEXTURE_2D, texture);
   gl->BindTexImage2DCHROMIUM(GL_TEXTURE_2D, id);
-  return AllocatedSurface(texture, id);
+  return AllocatedSurface(texture, id, gfx::Rect(size_));
 }
 
 }  // namespace content