CC: Force push properties for all layers when tracing is started

cc/layers/delegated_renderer_layer_impl_unittest.cc

 // Copyright 2012 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/layers/delegated_renderer_layer_impl.h"
 
 #include "cc/base/scoped_ptr_vector.h"
 #include "cc/layers/solid_color_layer_impl.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
@@ skipping 159 matching lines @@
     AddRenderPassQuad(pass3, pass2);
     delegated_renderer_layer->SetFrameDataForRenderPasses(
         1.f, delegated_render_passes);
 
     fake_delegated_renderer_layer_impl = delegated_renderer_layer.get();
 
     root_layer->AddChild(delegated_renderer_layer.Pass());
 
     host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
 
-    LayerTreeHostImpl::FrameData frame;
+    FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
     // Root layer has one render pass, and delegated renderer layer has two
     // contributing render passes and its own render pass.
     ASSERT_EQ(4u, frame.render_passes.size());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
   {
     // New frame makes delegated renderer layer loses its contributing render
     // passes.
     RenderPassList delegated_render_passes;
     AddRenderPass(&delegated_render_passes, RenderPassId(9, 8),
                   gfx::Rect(0, 0, 8, 8), gfx::Transform(1, 0, 0, 1, 9, 10));
     fake_delegated_renderer_layer_impl->SetFrameDataForRenderPasses(
         1.f, delegated_render_passes);
 
     // Force damage to redraw a new frame.
     host_impl_->SetViewportDamage(gfx::Rect(10, 10));
 
-    LayerTreeHostImpl::FrameData frame;
+    FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
     // Each non-DelegatedRendererLayer added one RenderPass. The
     // DelegatedRendererLayer added two contributing passes.
     ASSERT_EQ(1u, frame.render_passes.size());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
 }
@@ skipping 38 matching lines @@
     delegated_renderer_layer->SetFrameDataForRenderPasses(
         1.f, delegated_render_passes);
 
     fake_delegated_renderer_layer_impl = delegated_renderer_layer.get();
 
     root_layer->AddChild(delegated_renderer_layer.Pass());
 
     host_impl_->pending_tree()->SetRootLayer(root_layer.Pass());
     host_impl_->ActivateSyncTree();
 
-    LayerTreeHostImpl::FrameData frame;
+    FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
     // Root layer has one render pass, and delegated renderer layer has two
     // contributing render passes and its own render pass.
     ASSERT_EQ(4u, frame.render_passes.size());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
   {
     // Remove contributing render passes from the delegated renderer layer.
     host_impl_->CreatePendingTree();
     host_impl_->pending_tree()->set_needs_full_tree_sync(false);
     RenderPassList delegated_render_passes;
     AddRenderPass(&delegated_render_passes, RenderPassId(9, 8),
                   gfx::Rect(0, 0, 8, 8), gfx::Transform(1, 0, 0, 1, 9, 10));
 
     fake_delegated_renderer_layer_impl->SetFrameDataForRenderPasses(
         1.f, delegated_render_passes);
 
     // Force damage to redraw a new frame.
 
     host_impl_->ActivateSyncTree();
     host_impl_->SetViewportDamage(gfx::Rect(100, 100));
-    LayerTreeHostImpl::FrameData frame;
+    FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
     // Root layer has one render pass, and delegated renderer layer no longer
     // has contributing render passes.
     ASSERT_EQ(1u, frame.render_passes.size());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
 }
 
 TEST_F(DelegatedRendererLayerImplTestSimple, AddsContributingRenderPasses) {
-  LayerTreeHostImpl::FrameData frame;
+  FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes.
   ASSERT_EQ(5u, frame.render_passes.size());
 
   // The DelegatedRendererLayer should have added its contributing RenderPasses
   // to the frame.
   EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
   EXPECT_EQ(1, frame.render_passes[1]->id.index);
@@ skipping 13 matching lines @@
             frame.render_passes[1]->output_rect.ToString());
   EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(),
             frame.render_passes[2]->output_rect.ToString());
 
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestSimple,
        AddsQuadsToContributingRenderPasses) {
-  LayerTreeHostImpl::FrameData frame;
+  FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes.
   ASSERT_EQ(5u, frame.render_passes.size());
 
   // The DelegatedRendererLayer should have added its contributing RenderPasses
   // to the frame.
   EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
   EXPECT_EQ(1, frame.render_passes[1]->id.index);
@@ skipping 14 matching lines @@
             frame.render_passes[2]->quad_list.ElementAt(1)->rect.ToString());
   ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
   EXPECT_EQ(gfx::Rect(0, 0, 6, 6).ToString(),
             frame.render_passes[1]->quad_list.front()->rect.ToString());
 
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestSimple, AddsQuadsToTargetRenderPass) {
-  LayerTreeHostImpl::FrameData frame;
+  FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes.
   ASSERT_EQ(5u, frame.render_passes.size());
 
   // The layer's target is the RenderPass from layer_after_.
   EXPECT_EQ(RenderPassId(3, 0), frame.render_passes[3]->id);
 
   // The DelegatedRendererLayer should have added copies of quads in its root
   // RenderPass to its target RenderPass. The layer_after_ also adds one quad.
   ASSERT_EQ(2u, frame.render_passes[3]->quad_list.size());
 
   // Verify it added the right quads.
   EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(),
             frame.render_passes[3]->quad_list.front()->rect.ToString());
 
   // Its target layer should have a quad as well.
   EXPECT_EQ(gfx::Rect(0, 0, 15, 15).ToString(),
             frame.render_passes[3]->quad_list.ElementAt(1)->rect.ToString());
 
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestSimple,
        QuadsFromRootRenderPassAreModifiedForTheTarget) {
-  LayerTreeHostImpl::FrameData frame;
+  FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes.
   ASSERT_EQ(5u, frame.render_passes.size());
 
   // The DelegatedRendererLayer is at position 3,3 compared to its target, and
   // has a translation transform of 1,1. So its root RenderPass' quads should
   // all be transformed by that combined amount.
   gfx::Transform transform;
@@ skipping 13 matching lines @@
   ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       gfx::Transform(),
       frame.render_passes[1]->quad_list.front()->quadTransform());
 
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestSimple, RenderPassTransformIsModified) {
-  LayerTreeHostImpl::FrameData frame;
+  FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   // The delegated layer has a surface between it and the root.
   EXPECT_TRUE(delegated_renderer_layer_->render_target()->parent());
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes.
   ASSERT_EQ(5u, frame.render_passes.size());
 
   // The DelegatedRendererLayer is at position 9,9 compared to the root, so all
@@ skipping 20 matching lines @@
 class DelegatedRendererLayerImplTestOwnSurface
     : public DelegatedRendererLayerImplTestSimple {
  public:
   DelegatedRendererLayerImplTestOwnSurface()
       : DelegatedRendererLayerImplTestSimple() {
     delegated_renderer_layer_->SetHasRenderSurface(true);
   }
 };
 
 TEST_F(DelegatedRendererLayerImplTestOwnSurface, AddsRenderPasses) {
-  LayerTreeHostImpl::FrameData frame;
+  FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes and its owned surface
   // added one pass.
   ASSERT_EQ(6u, frame.render_passes.size());
 
   // The DelegatedRendererLayer should have added its contributing RenderPasses
   // to the frame.
   EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
@@ skipping 18 matching lines @@
             frame.render_passes[1]->output_rect.ToString());
   EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(),
             frame.render_passes[2]->output_rect.ToString());
 
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestOwnSurface,
        AddsQuadsToContributingRenderPasses) {
-  LayerTreeHostImpl::FrameData frame;
+  FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes and its owned surface
   // added one pass.
   ASSERT_EQ(6u, frame.render_passes.size());
 
   // The DelegatedRendererLayer should have added its contributing RenderPasses
   // to the frame.
   EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
@@ skipping 16 matching lines @@
             frame.render_passes[2]->quad_list.ElementAt(1)->rect.ToString());
   ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
   EXPECT_EQ(gfx::Rect(0, 0, 6, 6).ToString(),
             frame.render_passes[1]->quad_list.front()->rect.ToString());
 
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestOwnSurface, AddsQuadsToTargetRenderPass) {
-  LayerTreeHostImpl::FrameData frame;
+  FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes and its owned surface
   // added one pass.
   ASSERT_EQ(6u, frame.render_passes.size());
 
   // The layer's target is the RenderPass owned by itself.
   EXPECT_EQ(RenderPassId(4, 0), frame.render_passes[3]->id);
 
   // The DelegatedRendererLayer should have added copies of quads in its root
   // RenderPass to its target RenderPass.
   // The layer_after also adds one quad.
   ASSERT_EQ(1u, frame.render_passes[3]->quad_list.size());
 
   // Verify it added the right quads.
   EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(),
             frame.render_passes[3]->quad_list.front()->rect.ToString());
 
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestOwnSurface,
        QuadsFromRootRenderPassAreNotModifiedForTheTarget) {
-  LayerTreeHostImpl::FrameData frame;
+  FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes and its owned surface
   // added one pass.
   ASSERT_EQ(6u, frame.render_passes.size());
 
   // Because the DelegatedRendererLayer owns a RenderSurfaceImpl, its root
   // RenderPass' quads do not need to be translated at all.
   EXPECT_TRANSFORMATION_MATRIX_EQ(
@@ skipping 156 matching lines @@
         delegated_device_scale_factor_, delegated_render_passes);
 
     root_layer_ = root_layer.get();
     delegated_renderer_layer_ = delegated_renderer_layer.get();
 
     root_layer->AddChild(delegated_renderer_layer.Pass());
     host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
   }
 
   void VerifyRenderPasses(
-      const LayerTreeHostImpl::FrameData& frame,
+      const FrameData& frame,
       size_t num_render_passes,
       const SharedQuadState** root_delegated_shared_quad_state,
       const SharedQuadState** contrib_delegated_shared_quad_state) {
     ASSERT_EQ(num_render_passes, frame.render_passes.size());
     // The contributing render pass in the DelegatedRendererLayer.
     EXPECT_EQ(2, frame.render_passes[0]->id.layer_id);
     EXPECT_EQ(1, frame.render_passes[0]->id.index);
     // The root render pass.
     EXPECT_EQ(1, frame.render_passes.back()->id.layer_id);
     EXPECT_EQ(0, frame.render_passes.back()->id.index);
@@ skipping 31 matching lines @@
   LayerImpl* root_layer_;
   DelegatedRendererLayerImpl* delegated_renderer_layer_;
   bool root_delegated_render_pass_is_clipped_;
   float delegated_device_scale_factor_;
 };
 
 TEST_F(DelegatedRendererLayerImplTestTransform, QuadsUnclipped_NoSurface) {
   root_delegated_render_pass_is_clipped_ = false;
   SetUpTest();
 
-  LayerTreeHostImpl::FrameData frame;
+  FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   const SharedQuadState* root_delegated_shared_quad_state = nullptr;
   const SharedQuadState* contrib_delegated_shared_quad_state = nullptr;
   VerifyRenderPasses(
       frame,
       2,
       &root_delegated_shared_quad_state,
       &contrib_delegated_shared_quad_state);
 
@@ skipping 34 matching lines @@
       contrib_delegated_shared_quad_state->content_to_target_transform);
 
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestTransform, QuadsClipped_NoSurface) {
   root_delegated_render_pass_is_clipped_ = true;
   SetUpTest();
 
-  LayerTreeHostImpl::FrameData frame;
+  FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   const SharedQuadState* root_delegated_shared_quad_state = nullptr;
   const SharedQuadState* contrib_delegated_shared_quad_state = nullptr;
   VerifyRenderPasses(
       frame,
       2,
       &root_delegated_shared_quad_state,
       &contrib_delegated_shared_quad_state);
 
@@ skipping 40 matching lines @@
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestTransform, QuadsUnclipped_Surface) {
   root_delegated_render_pass_is_clipped_ = false;
   SetUpTest();
 
   delegated_renderer_layer_->SetHasRenderSurface(true);
 
-  LayerTreeHostImpl::FrameData frame;
+  FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   const SharedQuadState* root_delegated_shared_quad_state = nullptr;
   const SharedQuadState* contrib_delegated_shared_quad_state = nullptr;
   VerifyRenderPasses(
       frame,
       3,
       &root_delegated_shared_quad_state,
       &contrib_delegated_shared_quad_state);
 
@@ skipping 28 matching lines @@
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestTransform, QuadsClipped_Surface) {
   root_delegated_render_pass_is_clipped_ = true;
   SetUpTest();
 
   delegated_renderer_layer_->SetHasRenderSurface(true);
 
-  LayerTreeHostImpl::FrameData frame;
+  FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   const SharedQuadState* root_delegated_shared_quad_state = nullptr;
   const SharedQuadState* contrib_delegated_shared_quad_state = nullptr;
   VerifyRenderPasses(
       frame,
       3,
       &root_delegated_shared_quad_state,
       &contrib_delegated_shared_quad_state);
 
@@ skipping 27 matching lines @@
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestTransform, MismatchedDeviceScaleFactor) {
   root_delegated_render_pass_is_clipped_ = true;
   delegated_device_scale_factor_ = 1.3f;
 
   SetUpTest();
 
-  LayerTreeHostImpl::FrameData frame;
+  FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   const SharedQuadState* root_delegated_shared_quad_state = nullptr;
   const SharedQuadState* contrib_delegated_shared_quad_state = nullptr;
   VerifyRenderPasses(frame,
                      2,
                      &root_delegated_shared_quad_state,
                      &contrib_delegated_shared_quad_state);
 
   // The parent tree's device scale factor is 2.0, but the child has submitted a
@@ skipping 176 matching lines @@
   bool root_delegated_render_pass_is_clipped_;
   bool clip_delegated_renderer_layer_;
 };
 
 TEST_F(DelegatedRendererLayerImplTestClip,
        QuadsUnclipped_LayerUnclipped_NoSurface) {
   root_delegated_render_pass_is_clipped_ = false;
   clip_delegated_renderer_layer_ = false;
   SetUpTest();
 
-  LayerTreeHostImpl::FrameData frame;
+  FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   ASSERT_EQ(2u, frame.render_passes.size());
   const QuadList& contrib_delegated_quad_list =
       frame.render_passes[0]->quad_list;
   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
   const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
   ASSERT_EQ(5u, root_delegated_quad_list.size());
   const SharedQuadState* root_delegated_shared_quad_state =
       root_delegated_quad_list.front()->shared_quad_state;
 
   // When the quads don't have a clip of their own, the clip rect is set to
   // the drawable_content_rect of the delegated renderer layer.
   EXPECT_EQ(gfx::Rect(20, 20, 50, 50).ToString(),
             root_delegated_shared_quad_state->clip_rect.ToString());
   // Quads are clipped to the delegated renderer layer.
   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
 
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestClip,
        QuadsClipped_LayerUnclipped_NoSurface) {
   root_delegated_render_pass_is_clipped_ = true;
   clip_delegated_renderer_layer_ = false;
   SetUpTest();
 
-  LayerTreeHostImpl::FrameData frame;
+  FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   ASSERT_EQ(2u, frame.render_passes.size());
   const QuadList& contrib_delegated_quad_list =
       frame.render_passes[0]->quad_list;
   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
   const QuadList& root_delegated_quad_list =
       frame.render_passes[1]->quad_list;
   ASSERT_EQ(5u, root_delegated_quad_list.size());
   const SharedQuadState* root_delegated_shared_quad_state =
       root_delegated_quad_list.front()->shared_quad_state;
 
   // When the quads have a clip of their own, it is used.
   EXPECT_EQ(gfx::Rect(25, 25, 40, 40).ToString(),
             root_delegated_shared_quad_state->clip_rect.ToString());
   // Quads came with a clip rect.
   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
 
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestClip,
        QuadsUnclipped_LayerClipped_NoSurface) {
   root_delegated_render_pass_is_clipped_ = false;
   clip_delegated_renderer_layer_ = true;
   SetUpTest();
 
-  LayerTreeHostImpl::FrameData frame;
+  FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   ASSERT_EQ(2u, frame.render_passes.size());
   const QuadList& contrib_delegated_quad_list =
       frame.render_passes[0]->quad_list;
   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
   const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
   ASSERT_EQ(5u, root_delegated_quad_list.size());
   const SharedQuadState* root_delegated_shared_quad_state =
       root_delegated_quad_list.front()->shared_quad_state;
 
   // When the quads don't have a clip of their own, the clip rect is set to
   // the drawable_content_rect of the delegated renderer layer. When the layer
   // is clipped, that should be seen in the quads' clip_rect.
   EXPECT_EQ(gfx::Rect(21, 27, 23, 21).ToString(),
             root_delegated_shared_quad_state->clip_rect.ToString());
   // Quads are clipped to the delegated renderer layer.
   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
 
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestClip,
        QuadsClipped_LayerClipped_NoSurface) {
   root_delegated_render_pass_is_clipped_ = true;
   clip_delegated_renderer_layer_ = true;
   SetUpTest();
 
-  LayerTreeHostImpl::FrameData frame;
+  FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   ASSERT_EQ(2u, frame.render_passes.size());
   const QuadList& contrib_delegated_quad_list =
       frame.render_passes[0]->quad_list;
   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
   const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
   ASSERT_EQ(5u, root_delegated_quad_list.size());
   const SharedQuadState* root_delegated_shared_quad_state =
       root_delegated_quad_list.front()->shared_quad_state;
@@ skipping 10 matching lines @@
 }
 
 TEST_F(DelegatedRendererLayerImplTestClip,
        QuadsUnclipped_LayerUnclipped_Surface) {
   root_delegated_render_pass_is_clipped_ = false;
   clip_delegated_renderer_layer_ = false;
   SetUpTest();
 
   delegated_renderer_layer_->SetHasRenderSurface(true);
 
-  LayerTreeHostImpl::FrameData frame;
+  FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   ASSERT_EQ(3u, frame.render_passes.size());
   const QuadList& contrib_delegated_quad_list =
       frame.render_passes[0]->quad_list;
   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
   const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
   ASSERT_EQ(5u, root_delegated_quad_list.size());
   const SharedQuadState* root_delegated_shared_quad_state =
       root_delegated_quad_list.front()->shared_quad_state;
 
   // When the layer owns a surface, the quads don't need to be clipped
   // further than they already specify. If they aren't clipped, then their
   // clip rect is ignored, and they are not set as clipped.
   EXPECT_FALSE(root_delegated_shared_quad_state->is_clipped);
 
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestClip,
        QuadsClipped_LayerUnclipped_Surface) {
   root_delegated_render_pass_is_clipped_ = true;
   clip_delegated_renderer_layer_ = false;
   SetUpTest();
 
   delegated_renderer_layer_->SetHasRenderSurface(true);
 
-  LayerTreeHostImpl::FrameData frame;
+  FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   ASSERT_EQ(3u, frame.render_passes.size());
   const QuadList& contrib_delegated_quad_list =
       frame.render_passes[0]->quad_list;
   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
   const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
   ASSERT_EQ(5u, root_delegated_quad_list.size());
   const SharedQuadState* root_delegated_shared_quad_state =
       root_delegated_quad_list.front()->shared_quad_state;
 
   // When the quads have a clip of their own, it is used.
   EXPECT_EQ(gfx::Rect(5, 5, 40, 40).ToString(),
             root_delegated_shared_quad_state->clip_rect.ToString());
   // Quads came with a clip rect.
   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
 
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestClip,
        QuadsUnclipped_LayerClipped_Surface) {
   root_delegated_render_pass_is_clipped_ = false;
   clip_delegated_renderer_layer_ = true;
   SetUpTest();
 
   delegated_renderer_layer_->SetHasRenderSurface(true);
 
-  LayerTreeHostImpl::FrameData frame;
+  FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   ASSERT_EQ(3u, frame.render_passes.size());
   const QuadList& contrib_delegated_quad_list =
       frame.render_passes[0]->quad_list;
   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
   const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
   ASSERT_EQ(5u, root_delegated_quad_list.size());
   const SharedQuadState* root_delegated_shared_quad_state =
       root_delegated_quad_list.front()->shared_quad_state;
 
   // When the layer owns a surface, the quads don't need to be clipped
   // further than they already specify. If they aren't clipped, then their
   // clip rect is ignored, and they are not set as clipped.
   EXPECT_FALSE(root_delegated_shared_quad_state->is_clipped);
 
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestClip, QuadsClipped_LayerClipped_Surface) {
   root_delegated_render_pass_is_clipped_ = true;
   clip_delegated_renderer_layer_ = true;
   SetUpTest();
 
   delegated_renderer_layer_->SetHasRenderSurface(true);
 
-  LayerTreeHostImpl::FrameData frame;
+  FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   ASSERT_EQ(3u, frame.render_passes.size());
   const QuadList& contrib_delegated_quad_list =
       frame.render_passes[0]->quad_list;
   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
   const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
   ASSERT_EQ(5u, root_delegated_quad_list.size());
   const SharedQuadState* root_delegated_shared_quad_state =
       root_delegated_quad_list.front()->shared_quad_state;
@@ skipping 40 matching lines @@
 
   // But a render pass quad refers to it.
   AddRenderPassQuad(pass1, missing_pass.get());
 
   delegated_renderer_layer->SetFrameDataForRenderPasses(
       1.f, delegated_render_passes);
 
   root_layer->AddChild(delegated_renderer_layer.Pass());
   host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
 
-  LayerTreeHostImpl::FrameData frame;
+  FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   // The DelegatedRendererLayerImpl should drop the bad RenderPassDrawQuad.
   ASSERT_EQ(1u, frame.render_passes.size());
   ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
   EXPECT_EQ(DrawQuad::SOLID_COLOR,
             frame.render_passes[0]->quad_list.front()->material);
 
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
@@ skipping 187 matching lines @@
   scoped_ptr<DelegatedRendererLayerImpl> other_layer =
       DelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 6);
 
   delegated_renderer_layer_impl->PushPropertiesTo(other_layer.get());
 
   EXPECT_EQ(0.5f, other_layer->inverse_device_scale_factor());
 }
 
 }  // namespace
 }  // namespace cc