Unified OutputSurface::SwapBuffers.

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/json/json_writer.h"
@@ skipping 910 matching lines @@
     device_viewport_damage_rect.Union(viewport_damage_rect_);
     viewport_damage_rect_ = gfx::Rect();
 
     active_tree_->root_layer()->render_surface()->damage_tracker()->
         AddDamageNextUpdate(device_viewport_damage_rect);
   }
 
   if (!CalculateRenderPasses(frame))
     return false;
 
-  frame->latency_info = active_tree_->GetLatencyInfo();
-
   // If we return true, then we expect DrawLayers() to be called before this
   // function is called again.
   return true;
 }
 
 void LayerTreeHostImpl::EnforceManagedMemoryPolicy(
     const ManagedMemoryPolicy& policy) {
 
   bool evicted_resources = client_->ReduceContentsTextureMemoryOnImplThread(
       visible_ ? policy.bytes_limit_when_visible
@@ skipping 113 matching lines @@
 
 void LayerTreeHostImpl::OnVSyncParametersChanged(base::TimeTicks timebase,
                                                  base::TimeDelta interval) {
   client_->OnVSyncParametersChanged(timebase, interval);
 }
 
 void LayerTreeHostImpl::BeginFrame(base::TimeTicks frame_time) {
   client_->BeginFrameOnImplThread(frame_time);
 }
 
-void LayerTreeHostImpl::OnSendFrameToParentCompositorAck(
-    const CompositorFrameAck& ack) {
-  if (!renderer_)
-    return;
-
+void LayerTreeHostImpl::OnSwapBuffersComplete(
+    const CompositorFrameAck* ack) {
   // TODO(piman): We may need to do some validation on this ack before
   // processing it.
-  renderer_->ReceiveCompositorFrameAck(ack);
+  if (ack && renderer_)
+    renderer_->ReceiveSwapBuffersAck(*ack);
 
-  // When using compositor frame data, the ack doubles as a swap complete ack.
-  OnSwapBuffersComplete();
+  client_->OnSwapBuffersCompleteOnImplThread();
 }
 
 void LayerTreeHostImpl::OnCanDrawStateChangedForTree() {
   client_->OnCanDrawStateChanged(CanDraw());
 }
 
 CompositorFrameMetadata LayerTreeHostImpl::MakeCompositorFrameMetadata() const {
   CompositorFrameMetadata metadata;
   metadata.device_scale_factor = device_scale_factor_;
   metadata.page_scale_factor = active_tree_->total_page_scale_factor();
@@ skipping 131 matching lines @@
   return renderer_ && renderer_->IsContextLost();
 }
 
 const RendererCapabilities& LayerTreeHostImpl::GetRendererCapabilities() const {
   return renderer_->Capabilities();
 }
 
 bool LayerTreeHostImpl::SwapBuffers(const LayerTreeHostImpl::FrameData& frame) {
   if (frame.has_no_damage)
     return false;
-  renderer_->SwapBuffers(frame.latency_info);
+  renderer_->SwapBuffers();
   active_tree_->ClearLatencyInfo();
   return true;
 }
 
 void LayerTreeHostImpl::SetNeedsBeginFrame(bool enable) {
   if (output_surface_)
     output_surface_->SetNeedsBeginFrame(enable);
 }
 
 float LayerTreeHostImpl::DeviceScaleFactor() const {
@@ skipping 22 matching lines @@
 }
 
 void LayerTreeHostImpl::DidLoseOutputSurface() {
   // TODO(jamesr): The renderer_ check is needed to make some of the
   // LayerTreeHostContextTest tests pass, but shouldn't be necessary (or
   // important) in production. We should adjust the test to not need this.
   if (renderer_)
     client_->DidLoseOutputSurfaceOnImplThread();
 }
 
-void LayerTreeHostImpl::OnSwapBuffersComplete() {
-  client_->OnSwapBuffersCompleteOnImplThread();
-}
-
 void LayerTreeHostImpl::Readback(void* pixels,
                                  gfx::Rect rect_in_device_viewport) {
   DCHECK(renderer_);
   renderer_->GetFramebufferPixels(pixels, rect_in_device_viewport);
 }
 
 bool LayerTreeHostImpl::HaveRootScrollLayer() const {
   return !!RootScrollLayer();
 }
 
@@ skipping 186 matching lines @@
       !is_deferred_init) {
     // TODO(joth): Defer creating the Renderer too, until GL is initialized.
     // See http://crbug.com/230197
     renderer_ = SoftwareRenderer::Create(this, output_surface.get(), NULL);
   } else {
     scoped_ptr<ResourceProvider> resource_provider = ResourceProvider::Create(
         output_surface.get(), settings_.highp_threshold_min);
     if (!resource_provider)
       return false;
 
-    if (output_surface->capabilities().has_parent_compositor) {
+    if (output_surface->capabilities().delegated_rendering) {
       renderer_ = DelegatingRenderer::Create(this, output_surface.get(),
                                              resource_provider.get());
     } else if (output_surface->context3d()) {
       renderer_ = GLRenderer::Create(this,
                                      output_surface.get(),
                                      resource_provider.get(),
                                      settings_.highp_threshold_min,
                                      settings_.force_direct_layer_drawing);
     } else if (output_surface->software_device()) {
       renderer_ = SoftwareRenderer::Create(this,
@@ skipping 820 matching lines @@
 }
 
 void LayerTreeHostImpl::SetDebugState(const LayerTreeDebugState& debug_state) {
   if (debug_state_.continuous_painting != debug_state.continuous_painting)
     paint_time_counter_->ClearHistory();
 
   debug_state_ = debug_state;
 }
 
 }  // namespace cc