Unified OutputSurface::SwapBuffers.

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 139 matching lines @@
       UTF16ToASCII(context_->getString(GL_EXTENSIONS));
   std::vector<std::string> extensions_list;
   base::SplitString(extensions_string, ' ', &extensions_list);
   std::set<std::string> extensions(extensions_list.begin(),
                                    extensions_list.end());
 
   capabilities_.using_partial_swap =
       Settings().partial_swap_enabled &&
       extensions.count("GL_CHROMIUM_post_sub_buffer");
 
-  // Use the SwapBuffers callback only with the threaded proxy.
-  if (client_->HasImplThread())
-    capabilities_.using_swap_complete_callback =
-        extensions.count("GL_CHROMIUM_swapbuffers_complete_callback") > 0;
-
   capabilities_.using_set_visibility =
       extensions.count("GL_CHROMIUM_set_visibility") > 0;
 
   if (extensions.count("GL_CHROMIUM_iosurface") > 0)
     DCHECK_GT(extensions.count("GL_ARB_texture_rectangle"), 0u);
 
   capabilities_.using_gpu_memory_manager =
       extensions.count("GL_CHROMIUM_gpu_memory_manager") > 0 &&
       Settings().use_memory_management;
   if (capabilities_.using_gpu_memory_manager)
@@ skipping 1677 matching lines @@
 
   GLC(Context(), Context()->bindTexture(GL_TEXTURE_RECTANGLE_ARB, 0));
 }
 
 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();
-    output_surface_->SendFrameToParentCompositor(&compositor_frame);
-  }
 }
 
 void GLRenderer::FinishDrawingQuadList() { FlushTextureQuadCache(); }
 
 bool GLRenderer::FlippedFramebuffer() const { return true; }
 
 void GLRenderer::EnsureScissorTestEnabled() {
   if (is_scissor_enabled_)
     return;
 
@@ skipping 99 matching lines @@
   SetShaderOpacity(1, program->fragment_shader().alpha_location());
   DrawQuadGeometry(
       frame, draw_matrix, rect, program->vertex_shader().matrix_location());
 }
 
 void GLRenderer::Finish() {
   TRACE_EVENT0("cc", "GLRenderer::finish");
   context_->finish();
 }
 
-void GLRenderer::SwapBuffers(const ui::LatencyInfo& latency_info) {
+void GLRenderer::SwapBuffers() {
   DCHECK(visible_);
   DCHECK(!is_backbuffer_discarded_);
 
   TRACE_EVENT0("cc", "GLRenderer::SwapBuffers");
   // We're done! Time to swapbuffers!
 
+  CompositorFrame compositor_frame;
+  compositor_frame.metadata = client_->MakeCompositorFrameMetadata();
+  compositor_frame.gl_frame_data = make_scoped_ptr(new GLFrameData);
+  compositor_frame.gl_frame_data->size = output_surface_->SurfaceSize();
   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);
+    compositor_frame.gl_frame_data->sub_buffer_rect =
+        gfx::Rect(swap_buffer_rect_.x(),
+                  flipped_y_pos_of_rect_bottom,
+                  swap_buffer_rect_.width(),
+                  swap_buffer_rect_.height());
+    compositor_frame.gl_frame_data->partial_swap_allowed = true;
   } else {
-    output_surface_->SwapBuffers(latency_info);
+    compositor_frame.gl_frame_data->sub_buffer_rect =
+        gfx::Rect(output_surface_->SurfaceSize());
+    compositor_frame.gl_frame_data->partial_swap_allowed = false;
   }
+  output_surface_->SwapBuffers(&compositor_frame);
 
   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())
     static_cast<SimpleSwapFence*>(last_swap_fence_.get())->SetHasPassed();
   last_swap_fence_ = resource_provider_->GetReadLockFence();
   resource_provider_->SetReadLockFence(new SimpleSwapFence());
@@ skipping 932 matching lines @@
   // 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);
 }
 
 }  // namespace cc