Aura: Support --enable-partial-swap with --composite-to-mailbox

cc/output/gl_renderer.cc

 // Copyright 2010 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 "cc/output/gl_renderer.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 1810 matching lines @@
 void GLRenderer::FinishDrawingFrame(DrawingFrame* frame) {
   current_framebuffer_lock_.reset();
   swap_buffer_rect_.Union(gfx::ToEnclosingRect(frame->root_damage_rect));
 
   GLC(context_, context_->disable(GL_BLEND));
   blend_shadow_ = false;
 
   if (Settings().compositor_frame_message) {
     CompositorFrame compositor_frame;
     compositor_frame.metadata = client_->MakeCompositorFrameMetadata();
+    compositor_frame.gl_frame_data.reset(new GLFrameData());
+    compositor_frame.gl_frame_data->damage_rect = GetFrameDamage();
     output_surface_->SendFrameToParentCompositor(&compositor_frame);
   }
 }
 
 void GLRenderer::FinishDrawingQuadList() { FlushTextureQuadCache(); }
 
 bool GLRenderer::FlippedFramebuffer() const { return true; }
 
 void GLRenderer::EnsureScissorTestEnabled() {
   if (is_scissor_enabled_)
@@ skipping 111 matching lines @@
 void GLRenderer::SwapBuffers(const ui::LatencyInfo& latency_info) {
   DCHECK(visible_);
   DCHECK(!is_backbuffer_discarded_);
 
   TRACE_EVENT0("cc", "GLRenderer::SwapBuffers");
   // We're done! Time to swapbuffers!
 
   if (capabilities_.using_partial_swap && client_->AllowPartialSwap()) {
     // If supported, we can save significant bandwidth by only swapping the
     // damaged/scissored region (clamped to the viewport)
-    swap_buffer_rect_.Intersect(client_->DeviceViewport());
-    int flipped_y_pos_of_rect_bottom =
-        client_->DeviceViewport().height() - swap_buffer_rect_.y() -
-        swap_buffer_rect_.height();
-    output_surface_->PostSubBuffer(gfx::Rect(swap_buffer_rect_.x(),
-                                             flipped_y_pos_of_rect_bottom,
-                                             swap_buffer_rect_.width(),
-                                             swap_buffer_rect_.height()),
-                                   latency_info);
+    output_surface_->PostSubBuffer(GetFrameDamage(), latency_info);

[aelias_OOO_until_Jul13, 2013/06/10 22:20:12]

To be clearer about what I was asking for earlier, could you do here:

gfx::Rect frame_damage = GetFrameDamage();
if (frame_damage.size() == SurfaceSize())
  output_surface_->SwapBuffers(latency_info);
else
  output_surface_->PostSubBuffer(GetFrameDamage(), latency_info);

That would match the behavior after my patch.  The reason is that I don't have
access to the "using_partial_swap" setting from the output surface, so I would
just choose based on the rect size.

[aelias_OOO_until_Jul13, 2013/06/10 23:20:20]

On second thought, since this doesn't truly need to be a big blocker, I changed
my other patch to pass another boolean in GLFrameData to preserve the existing
behavior.  We can clean it up later once Mesa is confirmed to work with a
postSubBuffer/prepareTexture mix.

   } else {
     output_surface_->SwapBuffers(latency_info);
   }
 
   swap_buffer_rect_ = gfx::Rect();
 
   // We don't have real fences, so we mark read fences as passed
   // assuming a double-buffered GPU pipeline. A texture can be
   // written to after one full frame has past since it was last read.
   if (last_swap_fence_.get())
@@ skipping 916 matching lines @@
 bool GLRenderer::CanUseSkiaGPUBackend() const {
   // The Skia GPU backend requires a stencil buffer.  See ReinitializeGrCanvas
   // implementation.
   return gr_context_ && context_->getContextAttributes().stencil;
 }
 
 bool GLRenderer::IsContextLost() {
   return (context_->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
+gfx::Rect GLRenderer::GetFrameDamage() {
+  gfx::Rect frame_damage = swap_buffer_rect_;
+  frame_damage.Intersect(client_->DeviceViewport());
+  int flipped_y_pos_of_rect_bottom = client_->DeviceViewport().height() -
+                                     frame_damage.y() - frame_damage.height();
+  frame_damage.set_y(flipped_y_pos_of_rect_bottom);
+  return frame_damage;
+}
+
 }  // namespace cc