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

cc/trees/layer_tree_host_unittest.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.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/synchronization/lock.h"
@@ skipping 417 matching lines @@
     else
       root_layer_ = ContentLayer::Create(&client_);
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(bounds_);
     layer_tree_host()->SetRootLayer(root_layer_);
     layer_tree_host()->SetViewportSize(bounds_);
     PostSetNeedsCommitToMainThread();
   }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                   LayerTreeHostImpl::FrameData* frame_data,
+                                   FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_EQ(DRAW_SUCCESS, draw_result);
 
     gfx::RectF root_damage_rect;
     if (!frame_data->render_passes.empty())
       root_damage_rect = frame_data->render_passes.back()->damage_rect;
 
     if (!num_draws_) {
       // If this is the first frame, expect full frame damage.
       EXPECT_EQ(root_damage_rect, gfx::Rect(bounds_));
@@ skipping 163 matching lines @@
     layer_tree_host()->SetViewportSize(bounds_);
     PostSetNeedsCommitToMainThread();
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     if (num_draws_ == 3 && host_impl->settings().impl_side_painting)
       host_impl->SetNeedsRedrawRect(invalid_rect_);
   }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                   LayerTreeHostImpl::FrameData* frame_data,
+                                   FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_EQ(DRAW_SUCCESS, draw_result);
 
     gfx::RectF root_damage_rect;
     if (!frame_data->render_passes.empty())
       root_damage_rect = frame_data->render_passes.back()->damage_rect;
 
     switch (num_draws_) {
       case 0:
         EXPECT_EQ(gfx::Rect(bounds_), root_damage_rect);
@@ skipping 86 matching lines @@
       child_layer_ = FakeContentLayer::Create(&client_);
     child_layer_->SetBounds(gfx::Size(25, 25));
     parent_layer_->AddChild(child_layer_);
 
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                   LayerTreeHostImpl::FrameData* frame_data,
+                                   FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_EQ(DRAW_SUCCESS, draw_result);
 
     gfx::RectF root_damage_rect;
     if (!frame_data->render_passes.empty())
       root_damage_rect = frame_data->render_passes.back()->damage_rect;
 
     // The first time, the whole view needs be drawn.
     // Afterwards, just the opacity of surface_layer1 is changed a few times,
     // and each damage should be the bounding box of it and its child. If this
@@ skipping 513 matching lines @@
     FakePictureLayerImpl* root =
         static_cast<FakePictureLayerImpl*>(impl->active_tree()->root_layer());
     FakePictureLayerImpl* child = static_cast<FakePictureLayerImpl*>(
         impl->active_tree()->root_layer()->children()[0]);
 
     // Positions remain in layout pixels.
     EXPECT_EQ(gfx::Point(0, 0), root->position());
     EXPECT_EQ(gfx::Point(2, 2), child->position());
 
     // Compute all the layer transforms for the frame.
-    LayerTreeHostImpl::FrameData frame_data;
+    FrameData frame_data;
     impl->PrepareToDraw(&frame_data);
     impl->DidDrawAllLayers(frame_data);
 
     const LayerImplList& render_surface_layer_list =
         *frame_data.render_surface_layer_list;
 
     // Both layers should be drawing into the root render surface.
     ASSERT_EQ(1u, render_surface_layer_list.size());
     ASSERT_EQ(root->render_surface(),
               render_surface_layer_list[0]->render_surface());
@@ skipping 1149 matching lines @@
     settings->use_external_begin_frame_source = true;
   }
 
   void BeginTest() override {
     // This will trigger a SetNeedsBeginFrame which will trigger a
     // BeginFrame.
     PostSetNeedsCommitToMainThread();
   }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                   LayerTreeHostImpl::FrameData* frame,
+                                   FrameData* frame,
                                    DrawResult draw_result) override {
     EndTest();
     return DRAW_SUCCESS;
   }
 
   void AfterTest() override {}
 
  private:
   base::TimeTicks frame_time_;
 };
@@ skipping 286 matching lines @@
                 texImageIOSurface2DCHROMIUM(GL_TEXTURE_RECTANGLE_ARB,
                                             io_surface_size_.width(),
                                             io_surface_size_.height(),
                                             io_surface_id_,
                                             0)).Times(1);
 
     EXPECT_CALL(*mock_context_, bindTexture(_, 0)).Times(AnyNumber());
   }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                   LayerTreeHostImpl::FrameData* frame,
+                                   FrameData* frame,
                                    DrawResult draw_result) override {
     Mock::VerifyAndClearExpectations(&mock_context_);
     ResourceProvider* resource_provider = host_impl->resource_provider();
     EXPECT_EQ(1u, resource_provider->num_resources());
     CHECK_EQ(1u, frame->render_passes.size());
     CHECK_LE(1u, frame->render_passes[0]->quad_list.size());
     const DrawQuad* quad = frame->render_passes[0]->quad_list.front();
     CHECK_EQ(DrawQuad::IO_SURFACE_CONTENT, quad->material);
     const IOSurfaceDrawQuad* io_surface_draw_quad =
         IOSurfaceDrawQuad::MaterialCast(quad);
@@ skipping 1316 matching lines @@
  public:
   LayerTreeHostTestTreeActivationCallback()
       : num_commits_(0), callback_count_(0) {}
 
   void BeginTest() override {
     EXPECT_TRUE(HasImplThread());
     PostSetNeedsCommitToMainThread();
   }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                   LayerTreeHostImpl::FrameData* frame_data,
+                                   FrameData* frame_data,
                                    DrawResult draw_result) override {
     ++num_commits_;
     switch (num_commits_) {
       case 1:
         EXPECT_EQ(0, callback_count_);
         callback_count_ = 0;
         SetCallback(true);
         PostSetNeedsCommitToMainThread();
         break;
       case 2:
@@ skipping 1486 matching lines @@
     pinch->AddChild(layer);
 
     layer_tree_host()->RegisterViewportLayers(NULL, root, pinch, pinch);
     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 1.f, 4.f);
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
   }
 
   // Returns the delta scale of all quads in the frame's root pass from their
   // ideal, or 0 if they are not all the same.
-  float FrameQuadScaleDeltaFromIdeal(LayerTreeHostImpl::FrameData* frame_data) {
+  float FrameQuadScaleDeltaFromIdeal(FrameData* frame_data) {
     if (frame_data->has_no_damage)
       return 0.f;
     float frame_scale = 0.f;
     RenderPass* root_pass = frame_data->render_passes.back();
     for (const auto& draw_quad : root_pass->quad_list) {
       // Checkerboards mean an incomplete frame.
       if (draw_quad->material != DrawQuad::TILED_CONTENT)
         return 0.f;
       const TileDrawQuad* quad = TileDrawQuad::MaterialCast(draw_quad);
       float quad_scale =
           quad->tex_coord_rect.width() / static_cast<float>(quad->rect.width());
       float transform_scale =
           SkMScalarToFloat(quad->quadTransform().matrix().get(0, 0));
       float scale = quad_scale / transform_scale;
       if (frame_scale != 0.f && frame_scale != scale)
         return 0.f;
       frame_scale = scale;
     }
     return frame_scale;
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                   LayerTreeHostImpl::FrameData* frame_data,
+                                   FrameData* frame_data,
                                    DrawResult draw_result) override {
     float quad_scale_delta = FrameQuadScaleDeltaFromIdeal(frame_data);
     switch (frame_) {
       case 1:
         // Drew at page scale 1 before any pinching.
         EXPECT_EQ(1.f, host_impl->active_tree()->current_page_scale_factor());
         EXPECT_EQ(1.f, quad_scale_delta);
         PostNextAfterDraw(host_impl);
         break;
       case 2:
@@ skipping 154 matching lines @@
     layer->SetContentsOpaque(true);
     root->AddChild(layer);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                   LayerTreeHostImpl::FrameData* frame_data,
+                                   FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_NE(0u, host_impl->resource_provider()->num_resources());
     EndTest();
     return draw_result;
   }
   void AfterTest() override {}
 
   FakeContentLayerClient client_;
 };
 
@@ skipping 24 matching lines @@
     root->SetContentsOpaque(true);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
     layer_tree_host()->SetViewportSize(viewport_size_);
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                   LayerTreeHostImpl::FrameData* frame_data,
+                                   FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_EQ(4u, host_impl->resource_provider()->num_resources());
 
     // Verify which tiles got resources using an eviction iterator, which has to
     // return all tiles that have resources.
     scoped_ptr<EvictionTilePriorityQueue> eviction_queue(
         host_impl->BuildEvictionQueue(SAME_PRIORITY_FOR_BOTH_TREES));
     int tile_count = 0;
     for (; !eviction_queue->IsEmpty(); eviction_queue->Pop()) {
       Tile* tile = eviction_queue->Top();
@@ skipping 42 matching lines @@
     root->SetContentsOpaque(true);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
     layer_tree_host()->SetViewportSize(viewport_size_);
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                   LayerTreeHostImpl::FrameData* frame_data,
+                                   FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_EQ(10u, host_impl->resource_provider()->num_resources());
     EndTest();
     return draw_result;
   }
 
   void AfterTest() override {}
 
  private:
   FakeContentLayerClient client_;
@@ skipping 40 matching lines @@
     pinch->AddChild(layer);
 
     layer_tree_host()->RegisterViewportLayers(NULL, root, pinch, pinch);
     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 1.f, 4.f);
     layer_tree_host()->SetRootLayer(root);
     LayerTreeHostTest::SetupTree();
   }
 
   // Returns the delta scale of all quads in the frame's root pass from their
   // ideal, or 0 if they are not all the same.
-  float FrameQuadScaleDeltaFromIdeal(LayerTreeHostImpl::FrameData* frame_data) {
+  float FrameQuadScaleDeltaFromIdeal(FrameData* frame_data) {
     if (frame_data->has_no_damage)
       return 0.f;
     float frame_scale = 0.f;
     RenderPass* root_pass = frame_data->render_passes.back();
     for (const auto& draw_quad : root_pass->quad_list) {
       const TileDrawQuad* quad = TileDrawQuad::MaterialCast(draw_quad);
       float quad_scale =
           quad->tex_coord_rect.width() / static_cast<float>(quad->rect.width());
       float transform_scale =
           SkMScalarToFloat(quad->quadTransform().matrix().get(0, 0));
       float scale = quad_scale / transform_scale;
       if (frame_scale != 0.f && frame_scale != scale)
         return 0.f;
       frame_scale = scale;
     }
     return frame_scale;
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                   LayerTreeHostImpl::FrameData* frame_data,
+                                   FrameData* frame_data,
                                    DrawResult draw_result) override {
     float quad_scale_delta = FrameQuadScaleDeltaFromIdeal(frame_data);
     switch (step_) {
       case 1:
         // Drew at scale 1 before any pinching.
         EXPECT_EQ(1.f, host_impl->active_tree()->current_page_scale_factor());
         EXPECT_EQ(1.f, quad_scale_delta);
         break;
       case 2:
         if (quad_scale_delta != 1.f / 1.5f)
@@ skipping 375 matching lines @@
 
   void AfterTest() override {}
 
  private:
   scoped_refptr<Layer> child_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerPreserveRenderSurfaceFromOutputRequests);
 
 }  // namespace cc