Run all LayerTreeHost tests with a delegating renderer.

cc/output/delegating_renderer.cc

Index: cc/output/delegating_renderer.cc
diff --git a/cc/output/delegating_renderer.cc b/cc/output/delegating_renderer.cc
index 2ee755a8a5dbafebc6b3044c3e103fbe730d76ff..6f042c2fe8172787f64bee71d7e7bc9f2411471a 100644
--- a/cc/output/delegating_renderer.cc
+++ b/cc/output/delegating_renderer.cc
@@ -133,20 +133,14 @@ static ResourceProvider::ResourceId AppendToArray(
 void DelegatingRenderer::DrawFrame(
     RenderPassList* render_passes_in_draw_order) {
   TRACE_EVENT0("cc", "DelegatingRenderer::DrawFrame");
-  render_passes_for_swap_buffers_.swap(*render_passes_in_draw_order);
-  render_passes_in_draw_order->clear();
-}
 
-void DelegatingRenderer::SwapBuffers(const LatencyInfo& latency_info) {
-  TRACE_EVENT0("cc", "DelegatingRenderer::SwapBuffers");
+  frame_for_swap_buffers_.metadata = client_->MakeCompositorFrameMetadata();
 
-  CompositorFrame out_frame;
-  out_frame.metadata = client_->MakeCompositorFrameMetadata();
-
-  out_frame.delegated_frame_data = make_scoped_ptr(new DelegatedFrameData);
-  DelegatedFrameData& out_data = *out_frame.delegated_frame_data;
+  frame_for_swap_buffers_.delegated_frame_data =
+      make_scoped_ptr(new DelegatedFrameData);
+  DelegatedFrameData& out_data = *frame_for_swap_buffers_.delegated_frame_data;
   // Move the render passes and resources into the |out_frame|.
-  out_data.render_pass_list.swap(render_passes_for_swap_buffers_);
+  out_data.render_pass_list.swap(*render_passes_in_draw_order);
 
   // Collect all resource ids in the render passes into a ResourceIdArray.
   ResourceProvider::ResourceIdArray resources;
@@ -158,8 +152,13 @@ void DelegatingRenderer::SwapBuffers(const LatencyInfo& latency_info) {
       render_pass->quad_list[j]->IterateResources(append_to_array);
   }
   resource_provider_->PrepareSendToParent(resources, &out_data.resource_list);

[piman, 2013/05/08 19:24:36]

I really meant for this to happen in SwapBuffers so that we don't pack resources
into mailboxes that we won't need anyway if we're not going to send that frame.

[danakj, 2013/05/08 19:28:03]

Ah, hm. I moved it so tests would be symmetrical in that draw uses the same
number of textures regardless.

We should really not draw if we're not going to send the frame either..

But I can move this back to swap, and change the test to see how many textures
were used after swap instead of after draw.

[piman, 2013/05/08 19:35:16]

Trying to understand: which test, and symmetrical wrt what?
I guess it's a bit awkward here since we're not planning to support
CompositeAndReadback (at least as is), but GLRenderer does draw without sending
the frame in that case.

[danakj, 2013/05/08 19:38:23]

LayerTreeHostTestAtomicCommit for example. Symmetrical to direct rendering.

ie. So when you finish DrawLayers in a unit test, the textures being used for
that frame will have been used. DrawLayers does the textury things. Swap just
does the shipping.
Yeh, we don't really support any code path with delegating renderer that won't
swap, so it's a bit fuzzy what's right.

[piman, 2013/05/08 19:47:00]

I see, we're trying to detect which texture is "used" by seeing if it gets bound
on the context, which happens, naturally, in GLRenderer when we draw it, and as
a side effect of sending it to the parent in the DelegatingRenderer case.
The latter is fragile though, because if we "draw" it in 2 successive frames,
we'll only send it once. The test you mentioned currently avoids the case but I
don't think it's a given...


Mmh, looking closer at this test in particular, I think it's trying to check
which textures are used for upload, which I think is orthogonal to this though.

[danakj, 2013/05/08 23:35:30]

Ya, for sure, this test is making sure that two commits with dirty state use
different textures. I think that's valid here.
That's true, but I think it could equally check which textures are being sent to
the parent compositor, in the same way.

+}
 
-  output_surface_->SendFrameToParentCompositor(&out_frame);
+void DelegatingRenderer::SwapBuffers(const LatencyInfo& latency_info) {
+  TRACE_EVENT0("cc", "DelegatingRenderer::SwapBuffers");
+
+  output_surface_->SendFrameToParentCompositor(&frame_for_swap_buffers_);
+  DCHECK(!frame_for_swap_buffers_.delegated_frame_data);
 }
 
 void DelegatingRenderer::GetFramebufferPixels(void* pixels, gfx::Rect rect) {
@@ -171,7 +170,6 @@ void DelegatingRenderer::ReceiveCompositorFrameAck(
   resource_provider_->ReceiveFromParent(ack.resources);
 }
 
-
 bool DelegatingRenderer::IsContextLost() {
   WebGraphicsContext3D* context3d = resource_provider_->GraphicsContext3D();
   if (!context3d)