cc: Merge the DrawLayer()/DrawFrame() and SwapBuffers() methods.

This deletes the SwapBuffers() method in LayerTreeHostImpl and in
DelegatingRenderer, merging them into DrawLayers() and DrawFrame()
in their respective classes.

Next up is to collapse DelegatingRenderer into LayerTreeHostImpl and
remove all "renderer" and "draw and swap" terminology in
LayerTreeHostImpl, Scheduler, Proxies and friends.

R=enne
BUG=606056
CQ_INCLUDE_TRYBOTS=master.tryserver.blink:linux_precise_blink_rel

Review-Url: https://codereview.chromium.org/2317953002
Cr-Commit-Position: refs/heads/master@{#417098}

cc/output/delegating_renderer.cc

@@ -6,6 +6,7 @@
 
 #include <set>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
@@ -15,7 +16,6 @@
 #include "cc/quads/render_pass.h"
 #include "cc/resources/resource_provider.h"
 #include "gpu/command_buffer/client/context_support.h"
-#include "gpu/command_buffer/client/gles2_interface.h"
 
 
 namespace cc {
@@ -28,31 +28,26 @@ DelegatingRenderer::DelegatingRenderer(OutputSurface* output_surface,
 
 DelegatingRenderer::~DelegatingRenderer() = default;
 
-void DelegatingRenderer::DrawFrame(
-    RenderPassList* render_passes_in_draw_order) {
+void DelegatingRenderer::DrawFrame(CompositorFrameMetadata metadata,
+                                   RenderPassList render_passes_in_draw_order) {
   TRACE_EVENT0("cc", "DelegatingRenderer::DrawFrame");
 
-  delegated_frame_data_ = base::WrapUnique(new DelegatedFrameData);
-  DelegatedFrameData& out_data = *delegated_frame_data_;
-  // Move the render passes and resources into the |out_frame|.
-  out_data.render_pass_list.swap(*render_passes_in_draw_order);
-
-  // Collect all resource ids in the render passes into a ResourceIdArray.
+  // Collect all resource ids in the render passes into a single array.
   ResourceProvider::ResourceIdArray resources;
-  for (const auto& render_pass : out_data.render_pass_list) {
+  for (const auto& render_pass : render_passes_in_draw_order) {
     for (auto* quad : render_pass->quad_list) {
       for (ResourceId resource_id : quad->resources)
         resources.push_back(resource_id);
     }
   }
-  resource_provider_->PrepareSendToParent(resources, &out_data.resource_list);
-}
 
-void DelegatingRenderer::SwapBuffers(CompositorFrameMetadata metadata) {
-  TRACE_EVENT0("cc,benchmark", "DelegatingRenderer::SwapBuffers");
+  auto data = base::MakeUnique<DelegatedFrameData>();
+  resource_provider_->PrepareSendToParent(resources, &data->resource_list);
+  data->render_pass_list = std::move(render_passes_in_draw_order);
+
   CompositorFrame compositor_frame;
   compositor_frame.metadata = std::move(metadata);
-  compositor_frame.delegated_frame_data = std::move(delegated_frame_data_);
+  compositor_frame.delegated_frame_data = std::move(data);
   output_surface_->SwapBuffers(std::move(compositor_frame));
 }
 

cc/output/delegating_renderer.h

@@ -21,14 +21,12 @@ class CC_EXPORT DelegatingRenderer {
                      ResourceProvider* resource_provider);
   ~DelegatingRenderer();
 
-  void DrawFrame(RenderPassList* render_passes_in_draw_order);
-
-  void SwapBuffers(CompositorFrameMetadata metadata);
+  void DrawFrame(CompositorFrameMetadata metadata,
+                 RenderPassList render_passes_in_draw_order);
 
  private:
   OutputSurface* const output_surface_;
   ResourceProvider* const resource_provider_;
-  std::unique_ptr<DelegatedFrameData> delegated_frame_data_;
 
   DISALLOW_COPY_AND_ASSIGN(DelegatingRenderer);
 };

cc/test/layer_tree_test.cc

@@ -183,8 +183,8 @@ class LayerTreeHostImplForTesting : public LayerTreeHostImpl {
     return test_hooks_->PrepareToDrawOnThread(this, frame, draw_result);
   }
 
-  bool SwapBuffers(const FrameData& frame) override {
-    bool r = LayerTreeHostImpl::SwapBuffers(frame);
+  bool DrawLayers(FrameData* frame) override {
+    bool r = LayerTreeHostImpl::DrawLayers(frame);
     test_hooks_->DrawLayersOnThread(this);
     return r;
   }

cc/trees/layer_tree_host_impl.cc

@@ -1624,21 +1624,23 @@ CompositorFrameMetadata LayerTreeHostImpl::MakeCompositorFrameMetadata() const {
   return metadata;
 }
 
-void LayerTreeHostImpl::DrawLayers(FrameData* frame) {
+bool LayerTreeHostImpl::DrawLayers(FrameData* frame) {
+  DCHECK(CanDraw());
+  DCHECK_EQ(frame->has_no_damage, frame->render_passes.empty());
+
   TRACE_EVENT0("cc", "LayerTreeHostImpl::DrawLayers");
 
-  base::TimeTicks frame_begin_time = CurrentBeginFrameArgs().frame_time;
-  DCHECK(CanDraw());
+  ResetRequiresHighResToDraw();
 
   if (frame->has_no_damage) {
-    TRACE_EVENT_INSTANT0("cc", "EarlyOut_NoDamage", TRACE_EVENT_SCOPE_THREAD);
     DCHECK(!resourceless_software_draw_);
-    return;
-  }
 
-  DCHECK(!frame->render_passes.empty());
+    TRACE_EVENT_INSTANT0("cc", "EarlyOut_NoDamage", TRACE_EVENT_SCOPE_THREAD);
+    active_tree()->BreakSwapPromises(SwapPromise::SWAP_FAILS);
+    return false;
+  }
 
-  fps_counter_->SaveTimeStamp(frame_begin_time,
+  fps_counter_->SaveTimeStamp(CurrentBeginFrameArgs().frame_time,
                               !output_surface_->context_provider());
   rendering_stats_instrumentation_->IncrementFrameCount(1);
 
@@ -1679,9 +1681,41 @@ void LayerTreeHostImpl::DrawLayers(FrameData* frame) {
                                                 resource_provider_.get());
   }
 
-  renderer_->DrawFrame(&frame->render_passes);
-  // The render passes should be consumed by the renderer.
-  DCHECK(frame->render_passes.empty());
+  CompositorFrameMetadata metadata = MakeCompositorFrameMetadata();
+  metadata.may_contain_video = frame->may_contain_video;
+  active_tree()->FinishSwapPromises(&metadata);
+  for (auto& latency : metadata.latency_info) {
+    TRACE_EVENT_WITH_FLOW1("input,benchmark", "LatencyInfo.Flow",
+                           TRACE_ID_DONT_MANGLE(latency.trace_id()),
+                           TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT,
+                           "step", "SwapBuffers");
+    // Only add the latency component once for renderer swap, not the browser
+    // swap.
+    if (!latency.FindLatency(ui::INPUT_EVENT_LATENCY_RENDERER_SWAP_COMPONENT, 0,
+                             nullptr)) {
+      latency.AddLatencyNumber(ui::INPUT_EVENT_LATENCY_RENDERER_SWAP_COMPONENT,
+                               0, 0);
+    }
+  }
+
+  renderer_->DrawFrame(std::move(metadata), std::move(frame->render_passes));
+
+  // The next frame should start by assuming nothing has changed, and changes
+  // are noted as they occur.
+  // TODO(boliu): If we did a temporary software renderer frame, propogate the
+  // damage forward to the next frame.
+  for (size_t i = 0; i < frame->render_surface_layer_list->size(); i++) {
+    auto* surface = (*frame->render_surface_layer_list)[i]->render_surface();
+    surface->damage_tracker()->DidDrawDamagedArea();
+  }
+  active_tree_->ResetAllChangeTracking();
+
+  active_tree_->set_has_ever_been_drawn(true);
+  devtools_instrumentation::DidDrawFrame(id_);
+  benchmark_instrumentation::IssueImplThreadRenderingStatsEvent(
+      rendering_stats_instrumentation_->impl_thread_rendering_stats());
+  rendering_stats_instrumentation_->AccumulateAndClearImplThreadStats();
+  return true;
 }
 
 void LayerTreeHostImpl::DidDrawAllLayers(const FrameData& frame) {
@@ -1820,50 +1854,6 @@ void LayerTreeHostImpl::UpdateTreeResourcesForGpuRasterizationIfNeeded() {
   SetRequiresHighResToDraw();
 }
 
-bool LayerTreeHostImpl::SwapBuffers(const LayerTreeHostImpl::FrameData& frame) {
-  ResetRequiresHighResToDraw();
-
-  if (frame.has_no_damage) {
-    active_tree()->BreakSwapPromises(SwapPromise::SWAP_FAILS);
-    return false;
-  }
-
-  CompositorFrameMetadata metadata = MakeCompositorFrameMetadata();
-  metadata.may_contain_video = frame.may_contain_video;
-  active_tree()->FinishSwapPromises(&metadata);
-  for (auto& latency : metadata.latency_info) {
-    TRACE_EVENT_WITH_FLOW1("input,benchmark", "LatencyInfo.Flow",
-                           TRACE_ID_DONT_MANGLE(latency.trace_id()),
-                           TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT,
-                           "step", "SwapBuffers");
-    // Only add the latency component once for renderer swap, not the browser
-    // swap.
-    if (!latency.FindLatency(ui::INPUT_EVENT_LATENCY_RENDERER_SWAP_COMPONENT, 0,
-                             nullptr)) {
-      latency.AddLatencyNumber(ui::INPUT_EVENT_LATENCY_RENDERER_SWAP_COMPONENT,
-                               0, 0);
-    }
-  }
-  renderer_->SwapBuffers(std::move(metadata));
-
-  // The next frame should start by assuming nothing has changed, and changes
-  // are noted as they occur.
-  // TODO(boliu): If we did a temporary software renderer frame, propogate the
-  // damage forward to the next frame.
-  for (size_t i = 0; i < frame.render_surface_layer_list->size(); i++) {
-    auto* surface = (*frame.render_surface_layer_list)[i]->render_surface();
-    surface->damage_tracker()->DidDrawDamagedArea();
-  }
-  active_tree_->ResetAllChangeTracking();
-
-  active_tree_->set_has_ever_been_drawn(true);
-  devtools_instrumentation::DidDrawFrame(id_);
-  benchmark_instrumentation::IssueImplThreadRenderingStatsEvent(
-      rendering_stats_instrumentation_->impl_thread_rendering_stats());
-  rendering_stats_instrumentation_->AccumulateAndClearImplThreadStats();
-  return true;
-}
-
 void LayerTreeHostImpl::WillBeginImplFrame(const BeginFrameArgs& args) {
   current_begin_frame_tracker_.Start(args);
 

cc/trees/layer_tree_host_impl.h

@@ -309,7 +309,7 @@ class CC_EXPORT LayerTreeHostImpl
   // DidDrawAllLayers must also be called, regardless of whether DrawLayers is
   // called between the two.
   virtual DrawResult PrepareToDraw(FrameData* frame);
-  void DrawLayers(FrameData* frame);
+  virtual bool DrawLayers(FrameData* frame);
   // Must be called if and only if PrepareToDraw was called.
   void DidDrawAllLayers(const FrameData& frame);
 
@@ -420,7 +420,6 @@ class CC_EXPORT LayerTreeHostImpl
     return image_decode_controller_.get();
   }
 
-  virtual bool SwapBuffers(const FrameData& frame);
   virtual void WillBeginImplFrame(const BeginFrameArgs& args);
   virtual void DidFinishImplFrame();
   void DidModifyTilePriorities();

cc/trees/proxy_impl.cc

@@ -600,8 +600,7 @@ DrawResult ProxyImpl::DrawAndSwapInternal(bool forced_draw) {
   }
 
   if (draw_frame) {
-    layer_tree_host_impl_->DrawLayers(&frame);
-    if (layer_tree_host_impl_->SwapBuffers(frame))
+    if (layer_tree_host_impl_->DrawLayers(&frame))
       scheduler_->DidSwapBuffers();
     result = DRAW_SUCCESS;
   } else {

cc/trees/single_thread_proxy.cc

@@ -573,8 +573,7 @@ DrawResult SingleThreadProxy::DoComposite(LayerTreeHostImpl::FrameData* frame) {
     draw_result = layer_tree_host_impl_->PrepareToDraw(frame);
     draw_frame = draw_result == DRAW_SUCCESS;
     if (draw_frame) {
-      layer_tree_host_impl_->DrawLayers(frame);
-      if (layer_tree_host_impl_->SwapBuffers(*frame)) {
+      if (layer_tree_host_impl_->DrawLayers(frame)) {
         if (scheduler_on_impl_thread_)
           scheduler_on_impl_thread_->DidSwapBuffers();
         client_->DidPostSwapBuffers();