cc : Stop pushing properties not used by LayerImpl to LayerImpl. (2)

cc/trees/layer_tree_host_impl_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_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 199 matching lines @@
     host_impl_->animation_host()->AddAnimationTimeline(timeline_);
 
     return init;
   }
 
   void SetupRootLayerImpl(std::unique_ptr<LayerImpl> root) {
     root->SetPosition(gfx::PointF());
     root->SetBounds(gfx::Size(10, 10));
     root->SetDrawsContent(true);
     root->draw_properties().visible_layer_rect = gfx::Rect(0, 0, 10, 10);
-    root->SetForceRenderSurface(true);
+    root->test_properties()->force_render_surface = true;
     host_impl_->active_tree()->SetRootLayer(std::move(root));
   }
 
   static gfx::Vector2dF ScrollDelta(LayerImpl* layer_impl) {
     gfx::ScrollOffset delta =
         layer_impl->layer_tree_impl()
             ->property_trees()
             ->scroll_tree.GetScrollOffsetDeltaForTesting(layer_impl->id());
     return gfx::Vector2dF(delta.x(), delta.y());
   }
@@ skipping 47 matching lines @@
     const int kOuterViewportClipLayerId = 116;
     const int kOuterViewportScrollLayerId = 117;
     const int kContentLayerId = 118;
     const int kInnerViewportScrollLayerId = 2;
     const int kInnerViewportClipLayerId = 4;
     const int kPageScaleLayerId = 5;
 
     std::unique_ptr<LayerImpl> root = LayerImpl::Create(layer_tree_impl, 1);
     root->SetBounds(content_size);
     root->SetPosition(gfx::PointF());
-    root->SetForceRenderSurface(true);
+    root->test_properties()->force_render_surface = true;
 
     std::unique_ptr<LayerImpl> inner_scroll =
         LayerImpl::Create(layer_tree_impl, kInnerViewportScrollLayerId);
     inner_scroll->SetIsContainerForFixedPositionLayers(true);
     inner_scroll->layer_tree_impl()
         ->property_trees()
         ->scroll_tree.UpdateScrollOffsetBaseForTesting(inner_scroll->id(),
                                                        gfx::ScrollOffset());
 
     std::unique_ptr<LayerImpl> inner_clip =
@@ skipping 999 matching lines @@
 TEST_F(LayerTreeHostImplTest, AnimationSchedulingPendingTree) {
   EXPECT_FALSE(host_impl_->CommitToActiveTree());
 
   host_impl_->SetViewportSize(gfx::Size(50, 50));
 
   host_impl_->CreatePendingTree();
   host_impl_->pending_tree()->SetRootLayer(
       LayerImpl::Create(host_impl_->pending_tree(), 1));
   LayerImpl* root = host_impl_->pending_tree()->root_layer();
   root->SetBounds(gfx::Size(50, 50));
-  root->SetForceRenderSurface(true);
+  root->test_properties()->force_render_surface = true;
 
   root->AddChild(LayerImpl::Create(host_impl_->pending_tree(), 2));
   LayerImpl* child = root->children()[0];
   child->SetBounds(gfx::Size(10, 10));
   child->draw_properties().visible_layer_rect = gfx::Rect(10, 10);
   child->SetDrawsContent(true);
   AddAnimatedTransformToLayerWithPlayer(child->id(), timeline(), 10.0, 3, 0);
 
   EXPECT_FALSE(did_request_next_frame_);
   EXPECT_FALSE(did_request_redraw_);
@@ skipping 29 matching lines @@
 
 TEST_F(LayerTreeHostImplTest, AnimationSchedulingActiveTree) {
   EXPECT_FALSE(host_impl_->CommitToActiveTree());
 
   host_impl_->SetViewportSize(gfx::Size(50, 50));
 
   host_impl_->active_tree()->SetRootLayer(
       LayerImpl::Create(host_impl_->active_tree(), 1));
   LayerImpl* root = host_impl_->active_tree()->root_layer();
   root->SetBounds(gfx::Size(50, 50));
-  root->SetForceRenderSurface(true);
+  root->test_properties()->force_render_surface = true;
 
   root->AddChild(LayerImpl::Create(host_impl_->active_tree(), 2));
   LayerImpl* child = root->children()[0];
   child->SetBounds(gfx::Size(10, 10));
   child->draw_properties().visible_layer_rect = gfx::Rect(10, 10);
   child->SetDrawsContent(true);
 
   // Add a translate from 6,7 to 8,9.
   TransformOperations start;
   start.AppendTranslate(6.f, 7.f, 0.f);
@@ skipping 1922 matching lines @@
     append_quads_called_ = false;
     did_draw_called_ = false;
   }
 
   static void IgnoreResult(std::unique_ptr<CopyOutputResult> result) {}
 
   void AddCopyRequest() {
     std::vector<std::unique_ptr<CopyOutputRequest>> requests;
     requests.push_back(
         CopyOutputRequest::CreateRequest(base::Bind(&IgnoreResult)));
-    SetForceRenderSurface(true);
+    test_properties()->force_render_surface = true;
     PassCopyRequests(&requests);
   }
 
  protected:
   DidDrawCheckLayer(LayerTreeImpl* tree_impl, int id)
       : LayerImpl(tree_impl, id),
         will_draw_returns_false_(false),
         will_draw_called_(false),
         append_quads_called_(false),
         did_draw_called_(false) {
@@ skipping 11 matching lines @@
 
 TEST_F(LayerTreeHostImplTest, WillDrawReturningFalseDoesNotCall) {
   // The root layer is always drawn, so run this test on a child layer that
   // will be masked out by the root layer's bounds.
   host_impl_->active_tree()->SetRootLayer(
       DidDrawCheckLayer::Create(host_impl_->active_tree(), 1));
   DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(
       host_impl_->active_tree()->root_layer());
 
   root->AddChild(DidDrawCheckLayer::Create(host_impl_->active_tree(), 2));
-  root->SetForceRenderSurface(true);
+  root->test_properties()->force_render_surface = true;
   DidDrawCheckLayer* layer =
       static_cast<DidDrawCheckLayer*>(root->children()[0]);
 
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
     host_impl_->DrawLayers(&frame);
     host_impl_->DidDrawAllLayers(frame);
 
     EXPECT_TRUE(layer->will_draw_called());
@@ skipping 20 matching lines @@
 }
 
 TEST_F(LayerTreeHostImplTest, DidDrawNotCalledOnHiddenLayer) {
   // The root layer is always drawn, so run this test on a child layer that
   // will be masked out by the root layer's bounds.
   host_impl_->active_tree()->SetRootLayer(
       DidDrawCheckLayer::Create(host_impl_->active_tree(), 1));
   DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(
       host_impl_->active_tree()->root_layer());
   root->SetMasksToBounds(true);
-  root->SetForceRenderSurface(true);
+  root->test_properties()->force_render_surface = true;
   root->AddChild(DidDrawCheckLayer::Create(host_impl_->active_tree(), 2));
   DidDrawCheckLayer* layer =
       static_cast<DidDrawCheckLayer*>(root->children()[0]);
   // Ensure visible_layer_rect for layer is empty.
   layer->SetPosition(gfx::PointF(100.f, 100.f));
   layer->SetBounds(gfx::Size(10, 10));
 
   LayerTreeHostImpl::FrameData frame;
 
   EXPECT_FALSE(layer->will_draw_called());
@@ skipping 34 matching lines @@
   host_impl_->active_tree()->SetRootLayer(
       DidDrawCheckLayer::Create(host_impl_->active_tree(), 1));
   DidDrawCheckLayer* root =
       static_cast<DidDrawCheckLayer*>(host_impl_->active_tree()->root_layer());
 
   root->AddChild(DidDrawCheckLayer::Create(host_impl_->active_tree(), 2));
   DidDrawCheckLayer* occluded_layer =
       static_cast<DidDrawCheckLayer*>(root->children()[0]);
 
   root->AddChild(DidDrawCheckLayer::Create(host_impl_->active_tree(), 3));
-  root->SetForceRenderSurface(true);
+  root->test_properties()->force_render_surface = true;
   DidDrawCheckLayer* top_layer =
       static_cast<DidDrawCheckLayer*>(root->children()[1]);
   // This layer covers the occluded_layer above. Make this layer large so it can
   // occlude.
   top_layer->SetBounds(big_size);
   top_layer->SetContentsOpaque(true);
 
   LayerTreeHostImpl::FrameData frame;
 
   EXPECT_FALSE(occluded_layer->will_draw_called());
@@ skipping 11 matching lines @@
   EXPECT_TRUE(top_layer->did_draw_called());
 }
 
 TEST_F(LayerTreeHostImplTest, DidDrawCalledOnAllLayers) {
   host_impl_->active_tree()->SetRootLayer(
       DidDrawCheckLayer::Create(host_impl_->active_tree(), 1));
   DidDrawCheckLayer* root =
       static_cast<DidDrawCheckLayer*>(host_impl_->active_tree()->root_layer());
 
   root->AddChild(DidDrawCheckLayer::Create(host_impl_->active_tree(), 2));
-  root->SetForceRenderSurface(true);
+  root->test_properties()->force_render_surface = true;
   DidDrawCheckLayer* layer1 =
       static_cast<DidDrawCheckLayer*>(root->children()[0]);
 
   layer1->AddChild(DidDrawCheckLayer::Create(host_impl_->active_tree(), 3));
   DidDrawCheckLayer* layer2 =
       static_cast<DidDrawCheckLayer*>(layer1->children()[0]);
 
-  layer1->SetForceRenderSurface(true);
+  layer1->test_properties()->force_render_surface = true;
   layer1->SetShouldFlattenTransform(true);
 
   EXPECT_FALSE(root->did_draw_called());
   EXPECT_FALSE(layer1->did_draw_called());
   EXPECT_FALSE(layer2->did_draw_called());
 
   LayerTreeHostImpl::FrameData frame;
   FakeLayerTreeHostImpl::RecursiveUpdateNumChildren(
       host_impl_->active_tree()->root_layer());
   EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
@@ skipping 136 matching lines @@
       PrepareToDrawSuccessTestCase(DRAW_ABORTED_MISSING_HIGH_RES_CONTENT));
   cases.back().high_res_required = true;
   cases.back().layer_between.has_missing_tile = true;
   cases.back().layer_before.has_missing_tile = true;
   cases.back().layer_before.is_animating = true;
 
   host_impl_->active_tree()->SetRootLayer(
       DidDrawCheckLayer::Create(host_impl_->active_tree(), 1));
   DidDrawCheckLayer* root =
       static_cast<DidDrawCheckLayer*>(host_impl_->active_tree()->root_layer());
-  root->SetForceRenderSurface(true);
+  root->test_properties()->force_render_surface = true;
 
   LayerTreeHostImpl::FrameData frame;
   SetNeedsRebuildPropertyTrees();
   EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
   host_impl_->DrawLayers(&frame);
   host_impl_->DidDrawAllLayers(frame);
   host_impl_->SwapBuffers(frame);
 
   for (size_t i = 0; i < cases.size(); ++i) {
     // Clean up host_impl_ state.
@@ skipping 78 matching lines @@
   cases.back().layer_between.has_incomplete_tile = true;
   // 3. High res required with missing tile.
   cases.push_back(PrepareToDrawSuccessTestCase(DRAW_SUCCESS));
   cases.back().high_res_required = true;
   cases.back().layer_between.has_missing_tile = true;
 
   host_impl_->active_tree()->SetRootLayer(
       DidDrawCheckLayer::Create(host_impl_->active_tree(), 1));
   DidDrawCheckLayer* root =
       static_cast<DidDrawCheckLayer*>(host_impl_->active_tree()->root_layer());
-  root->SetForceRenderSurface(true);
+  root->test_properties()->force_render_surface = true;
 
   SetNeedsRebuildPropertyTrees();
   host_impl_->OnDraw(external_transform, external_viewport, external_clip,
                      resourceless_software_draw);
 
   for (size_t i = 0; i < cases.size(); ++i) {
     const auto& testcase = cases[i];
     std::vector<LayerImpl*> to_remove;
     for (const auto& child : root->children())
       to_remove.push_back(child);
@@ skipping 40 matching lines @@
     SetNeedsRebuildPropertyTrees();
     host_impl_->OnDraw(external_transform, external_viewport, external_clip,
                        resourceless_software_draw);
   }
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollRootIgnored) {
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetScrollClipLayer(Layer::INVALID_ID);
-  root->SetForceRenderSurface(true);
+  root->test_properties()->force_render_surface = true;
   host_impl_->active_tree()->SetRootLayer(std::move(root));
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
 
   // Scroll event is ignored because layer is not scrollable.
   InputHandler::ScrollStatus status = host_impl_->ScrollBegin(
       BeginState(gfx::Point()).get(), InputHandler::WHEEL);
   EXPECT_EQ(InputHandler::SCROLL_IGNORED, status.thread);
   EXPECT_EQ(MainThreadScrollingReason::kNoScrollingLayer,
             status.main_thread_scrolling_reasons);
@@ skipping 77 matching lines @@
 
     std::unique_ptr<LayerImpl> outer_scroll = LayerImpl::Create(tree_impl, 4);
     std::unique_ptr<LayerImpl> outer_clip = LayerImpl::Create(tree_impl, 5);
 
     root_clip->SetBounds(inner_viewport_size);
     root->SetScrollClipLayer(root_clip->id());
     root->SetBounds(outer_viewport_size);
     root->SetPosition(gfx::PointF());
     root->SetDrawsContent(false);
     root->SetIsContainerForFixedPositionLayers(true);
-    root_clip->SetForceRenderSurface(true);
+    root_clip->test_properties()->force_render_surface = true;
     outer_clip->SetBounds(outer_viewport_size);
     outer_scroll->SetScrollClipLayer(outer_clip->id());
     outer_scroll->SetBounds(scroll_layer_size);
     outer_scroll->SetPosition(gfx::PointF());
     outer_scroll->SetDrawsContent(false);
     outer_scroll->SetIsContainerForFixedPositionLayers(true);
 
     int inner_viewport_scroll_layer_id = root->id();
     int outer_viewport_scroll_layer_id = outer_scroll->id();
     int page_scale_layer_id = page_scale->id();
@@ skipping 789 matching lines @@
   scroll_clip_layer->SetBounds(surface_size);
 
   std::unique_ptr<LayerImpl> scroll_layer =
       LayerImpl::Create(host_impl_->active_tree(), 2);
   scroll_layer->SetScrollClipLayer(3);
   scroll_layer->SetBounds(contents_size);
   scroll_layer->SetPosition(gfx::PointF());
   scroll_layer->AddChild(std::move(content_layer));
   scroll_clip_layer->AddChild(std::move(scroll_layer));
 
-  scroll_clip_layer->SetForceRenderSurface(true);
+  scroll_clip_layer->test_properties()->force_render_surface = true;
   host_impl_->active_tree()->SetRootLayer(std::move(scroll_clip_layer));
   host_impl_->SetViewportSize(surface_size);
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_->ScrollBegin(BeginState(gfx::Point(5, 5)).get(),
                                     InputHandler::WHEEL)
                 .thread);
   host_impl_->ScrollBy(UpdateState(gfx::Point(), gfx::Vector2d(0, 10)).get());
   host_impl_->ScrollEnd(EndState().get());
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_TRUE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollChildCallsCommitAndRedraw) {
   gfx::Size surface_size(10, 10);
   gfx::Size contents_size(20, 20);
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetBounds(surface_size);
   root->AddChild(CreateScrollableLayer(2, contents_size, root.get()));
-  root->SetForceRenderSurface(true);
+  root->test_properties()->force_render_surface = true;
   host_impl_->active_tree()->SetRootLayer(std::move(root));
   host_impl_->SetViewportSize(surface_size);
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
             host_impl_->ScrollBegin(BeginState(gfx::Point(5, 5)).get(),
                                     InputHandler::WHEEL)
                 .thread);
   host_impl_->ScrollBy(UpdateState(gfx::Point(), gfx::Vector2d(0, 10)).get());
   host_impl_->ScrollEnd(EndState().get());
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_TRUE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollMissesChild) {
   gfx::Size surface_size(10, 10);
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl_->active_tree(), 1);
   root->AddChild(CreateScrollableLayer(2, surface_size, root.get()));
-  root->SetForceRenderSurface(true);
+  root->test_properties()->force_render_surface = true;
   host_impl_->active_tree()->SetRootLayer(std::move(root));
   host_impl_->SetViewportSize(surface_size);
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
 
   // Scroll event is ignored because the input coordinate is outside the layer
   // boundaries.
   InputHandler::ScrollStatus status = host_impl_->ScrollBegin(
       BeginState(gfx::Point(15, 5)).get(), InputHandler::WHEEL);
   EXPECT_EQ(InputHandler::SCROLL_IGNORED, status.thread);
   EXPECT_EQ(MainThreadScrollingReason::kNoScrollingLayer,
             status.main_thread_scrolling_reasons);
 
   EXPECT_FALSE(did_request_redraw_);
   EXPECT_FALSE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollMissesBackfacingChild) {
   gfx::Size surface_size(10, 10);
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl_->active_tree(), 1);
-  root->SetForceRenderSurface(true);
+  root->test_properties()->force_render_surface = true;
   std::unique_ptr<LayerImpl> child =
       CreateScrollableLayer(2, surface_size, root.get());
   host_impl_->SetViewportSize(surface_size);
 
   gfx::Transform matrix;
   matrix.RotateAboutXAxis(180.0);
   child->SetTransform(matrix);
-  child->SetDoubleSided(false);
+  child->test_properties()->double_sided = false;
 
   root->AddChild(std::move(child));
   host_impl_->active_tree()->SetRootLayer(std::move(root));
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
 
   // Scroll event is ignored because the scrollable layer is not facing the
   // viewer and there is nothing scrollable behind it.
   InputHandler::ScrollStatus status = host_impl_->ScrollBegin(
       BeginState(gfx::Point(5, 5)).get(), InputHandler::WHEEL);
@@ skipping 14 matching lines @@
   content_layer->set_main_thread_scrolling_reasons(
       MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects);
   content_layer->SetScrollClipLayer(Layer::INVALID_ID);
 
   // Note: we can use the same clip layer for both since both calls to
   // CreateScrollableLayer() use the same surface size.
   std::unique_ptr<LayerImpl> scroll_layer =
       CreateScrollableLayer(2, surface_size, clip_layer.get());
   scroll_layer->AddChild(std::move(content_layer));
   clip_layer->AddChild(std::move(scroll_layer));
-  clip_layer->SetForceRenderSurface(true);
+  clip_layer->test_properties()->force_render_surface = true;
 
   host_impl_->active_tree()->SetRootLayer(std::move(clip_layer));
   host_impl_->SetViewportSize(surface_size);
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
 
   // Scrolling fails because the content layer is asking to be scrolled on the
   // main thread.
   InputHandler::ScrollStatus status = host_impl_->ScrollBegin(
       BeginState(gfx::Point(5, 5)).get(), InputHandler::WHEEL);
@@ skipping 198 matching lines @@
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollChildBeyondLimit) {
   // Scroll a child layer beyond its maximum scroll range and make sure the
   // parent layer isn't scrolled.
   gfx::Size surface_size(10, 10);
   gfx::Size content_size(20, 20);
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetBounds(surface_size);
-  root->SetForceRenderSurface(true);
+  root->test_properties()->force_render_surface = true;
   std::unique_ptr<LayerImpl> grand_child =
       CreateScrollableLayer(3, content_size, root.get());
 
   std::unique_ptr<LayerImpl> child =
       CreateScrollableLayer(2, content_size, root.get());
   LayerImpl* grand_child_layer = grand_child.get();
   child->AddChild(std::move(grand_child));
 
   LayerImpl* child_layer = child.get();
   root->AddChild(std::move(child));
@@ skipping 36 matching lines @@
 
 TEST_F(LayerTreeHostImplTest, ScrollWithoutBubbling) {
   // Scroll a child layer beyond its maximum scroll range and make sure the
   // the scroll doesn't bubble up to the parent layer.
   gfx::Size surface_size(20, 20);
   gfx::Size viewport_size(10, 10);
   std::unique_ptr<LayerImpl> root_ptr =
       LayerImpl::Create(host_impl_->active_tree(), 1);
   std::unique_ptr<LayerImpl> root_clip =
       LayerImpl::Create(host_impl_->active_tree(), 2);
-  root_clip->SetForceRenderSurface(true);
+  root_clip->test_properties()->force_render_surface = true;
   std::unique_ptr<LayerImpl> root_scrolling =
       CreateScrollableLayer(3, surface_size, root_clip.get());
   root_scrolling->SetIsContainerForFixedPositionLayers(true);
 
   std::unique_ptr<LayerImpl> grand_child =
       CreateScrollableLayer(5, surface_size, root_clip.get());
 
   std::unique_ptr<LayerImpl> child =
       CreateScrollableLayer(4, surface_size, root_clip.get());
   LayerImpl* grand_child_layer = grand_child.get();
@@ skipping 111 matching lines @@
 }
 TEST_F(LayerTreeHostImplTest, ScrollEventBubbling) {
   // When we try to scroll a non-scrollable child layer, the scroll delta
   // should be applied to one of its ancestors if possible.
   gfx::Size surface_size(10, 10);
   gfx::Size content_size(20, 20);
   std::unique_ptr<LayerImpl> root_ptr =
       LayerImpl::Create(host_impl_->active_tree(), 4);
   std::unique_ptr<LayerImpl> root_clip =
       LayerImpl::Create(host_impl_->active_tree(), 3);
-  root_clip->SetForceRenderSurface(true);
+  root_clip->test_properties()->force_render_surface = true;
   std::unique_ptr<LayerImpl> root_scroll =
       CreateScrollableLayer(1, content_size, root_clip.get());
   // Make 'root' the clip layer for child: since they have the same sizes the
   // child will have zero max_scroll_offset and scrolls will bubble.
   std::unique_ptr<LayerImpl> child =
       CreateScrollableLayer(2, content_size, root_scroll.get());
   child->SetIsContainerForFixedPositionLayers(true);
   root_scroll->SetBounds(content_size);
 
   int root_scroll_id = root_scroll->id();
@@ skipping 29 matching lines @@
 
 TEST_F(LayerTreeHostImplTest, ScrollBeforeRedraw) {
   gfx::Size surface_size(10, 10);
   std::unique_ptr<LayerImpl> root_ptr =
       LayerImpl::Create(host_impl_->active_tree(), 1);
   std::unique_ptr<LayerImpl> root_clip =
       LayerImpl::Create(host_impl_->active_tree(), 2);
   std::unique_ptr<LayerImpl> root_scroll =
       CreateScrollableLayer(3, surface_size, root_clip.get());
   root_scroll->SetIsContainerForFixedPositionLayers(true);
-  root_clip->SetForceRenderSurface(true);
+  root_clip->test_properties()->force_render_surface = true;
   root_clip->AddChild(std::move(root_scroll));
   root_ptr->AddChild(std::move(root_clip));
   host_impl_->active_tree()->SetRootLayer(std::move(root_ptr));
   host_impl_->active_tree()->SetViewportLayersFromIds(Layer::INVALID_ID, 1, 3,
                                                       Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
   host_impl_->SetViewportSize(surface_size);
 
   // Draw one frame and then immediately rebuild the layer tree to mimic a tree
   // synchronization.
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
   host_impl_->active_tree()->ClearLayers();
   std::unique_ptr<LayerImpl> root_ptr2 =
       LayerImpl::Create(host_impl_->active_tree(), 4);
   std::unique_ptr<LayerImpl> root_clip2 =
       LayerImpl::Create(host_impl_->active_tree(), 5);
   std::unique_ptr<LayerImpl> root_scroll2 =
       CreateScrollableLayer(6, surface_size, root_clip2.get());
   root_scroll2->SetIsContainerForFixedPositionLayers(true);
   root_clip2->AddChild(std::move(root_scroll2));
-  root_clip2->SetForceRenderSurface(true);
+  root_clip2->test_properties()->force_render_surface = true;
   root_ptr2->AddChild(std::move(root_clip2));
   host_impl_->active_tree()->SetRootLayer(std::move(root_ptr2));
   host_impl_->active_tree()->SetViewportLayersFromIds(Layer::INVALID_ID, 4, 6,
                                                       Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
 
   // Scrolling should still work even though we did not draw yet.
   SetNeedsRebuildPropertyTrees();
   RebuildPropertyTrees();
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
@@ skipping 606 matching lines @@
 }
 
 
 TEST_F(LayerTreeHostImplTest, OverscrollChildWithoutBubbling) {
   // Scroll child layers beyond their maximum scroll range and make sure root
   // overscroll does not accumulate.
   InputHandlerScrollResult scroll_result;
   gfx::Size surface_size(10, 10);
   std::unique_ptr<LayerImpl> root_clip =
       LayerImpl::Create(host_impl_->active_tree(), 4);
-  root_clip->SetForceRenderSurface(true);
+  root_clip->test_properties()->force_render_surface = true;
 
   std::unique_ptr<LayerImpl> root =
       CreateScrollableLayer(1, surface_size, root_clip.get());
 
   std::unique_ptr<LayerImpl> grand_child =
       CreateScrollableLayer(3, surface_size, root_clip.get());
 
   std::unique_ptr<LayerImpl> child =
       CreateScrollableLayer(2, surface_size, root_clip.get());
   LayerImpl* grand_child_layer = grand_child.get();
@@ skipping 268 matching lines @@
   gfx::Rect quad_visible_rect_;
   ResourceId resource_id_;
 };
 
 TEST_F(LayerTreeHostImplTest, BlendingOffWhenDrawingOpaqueLayers) {
   {
     std::unique_ptr<LayerImpl> root =
         LayerImpl::Create(host_impl_->active_tree(), 1);
     root->SetBounds(gfx::Size(10, 10));
     root->SetDrawsContent(false);
-    root->SetForceRenderSurface(true);
+    root->test_properties()->force_render_surface = true;
     host_impl_->active_tree()->SetRootLayer(std::move(root));
   }
   LayerImpl* root = host_impl_->active_tree()->root_layer();
 
   root->AddChild(
       BlendStateCheckLayer::Create(host_impl_->active_tree(),
                                    2,
                                    host_impl_->resource_provider()));
   BlendStateCheckLayer* layer1 =
       static_cast<BlendStateCheckLayer*>(root->children()[0]);
@@ skipping 101 matching lines @@
   host_impl_->DidDrawAllLayers(frame);
 
   // Parent layer with translucent opacity and opaque content. Since it has a
   // drawing child, it's drawn to a render surface which carries the opacity,
   // so it's itself drawn without blending.
   // Child layer with opaque content, drawn without blending (parent surface
   // carries the inherited opacity).
   layer1->SetContentsOpaque(true);
   layer1->SetOpacity(0.5f);
   layer1->NoteLayerPropertyChanged();
-  layer1->SetForceRenderSurface(true);
+  layer1->test_properties()->force_render_surface = true;
   layer1->SetExpectation(false, true);
   layer1->SetUpdateRect(gfx::Rect(layer1->bounds()));
   layer2->SetExpectation(false, false);
   layer2->SetUpdateRect(gfx::Rect(layer1->bounds()));
   FakeLayerTreeHostImpl::RecursiveUpdateNumChildren(
       host_impl_->active_tree()->root_layer());
   SetNeedsRebuildPropertyTrees();
   EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
   host_impl_->DrawLayers(&frame);
   EXPECT_TRUE(layer1->quads_appended());
   EXPECT_TRUE(layer2->quads_appended());
   host_impl_->DidDrawAllLayers(frame);
-  layer1->SetForceRenderSurface(false);
+  layer1->test_properties()->force_render_surface = false;
 
   // Draw again, but with child non-opaque, to make sure
   // layer1 not culled.
   layer1->SetContentsOpaque(true);
   layer1->SetOpacity(1.f);
   layer1->NoteLayerPropertyChanged();
   layer1->SetExpectation(false, false);
   layer1->SetUpdateRect(gfx::Rect(layer1->bounds()));
   layer2->SetContentsOpaque(true);
   layer2->SetOpacity(0.5f);
@@ skipping 110 matching lines @@
       return FakeOutputSurface::CreateSoftware(
           base::WrapUnique(new SoftwareOutputDevice()));
     }
     return FakeOutputSurface::Create3d();
   }
 
   void SetupActiveTreeLayers() {
     host_impl_->active_tree()->set_background_color(SK_ColorGRAY);
     host_impl_->active_tree()->SetRootLayer(
         LayerImpl::Create(host_impl_->active_tree(), 1));
-    host_impl_->active_tree()->root_layer()->SetForceRenderSurface(true);
+    host_impl_->active_tree()
+        ->root_layer()
+        ->test_properties()
+        ->force_render_surface = true;
     host_impl_->active_tree()->root_layer()->AddChild(
         BlendStateCheckLayer::Create(host_impl_->active_tree(),
                                      2,
                                      host_impl_->resource_provider()));
     child_ = static_cast<BlendStateCheckLayer*>(
         host_impl_->active_tree()->root_layer()->children()[0]);
     child_->SetExpectation(false, false);
     child_->SetContentsOpaque(true);
   }
 
@@ skipping 282 matching lines @@
 TEST_F(LayerTreeHostImplTest, ReshapeNotCalledUntilDraw) {
   scoped_refptr<TestContextProvider> provider(TestContextProvider::Create());
   std::unique_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(provider));
   CreateHostImpl(DefaultSettings(), std::move(output_surface));
 
   std::unique_ptr<LayerImpl> root =
       FakeDrawableLayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
-  root->SetForceRenderSurface(true);
+  root->test_properties()->force_render_surface = true;
   host_impl_->active_tree()->SetRootLayer(std::move(root));
   EXPECT_FALSE(provider->TestContext3d()->reshape_called());
   provider->TestContext3d()->clear_reshape_called();
 
   LayerTreeHostImpl::FrameData frame;
   host_impl_->SetViewportSize(gfx::Size(10, 10));
   host_impl_->active_tree()->SetDeviceScaleFactor(1.f);
   EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
   host_impl_->DrawLayers(&frame);
   EXPECT_TRUE(provider->TestContext3d()->reshape_called());
@@ skipping 45 matching lines @@
           settings, this, &task_runner_provider_, &stats_instrumentation_,
           &shared_bitmap_manager_, NULL, &task_graph_runner_, 0);
   layer_tree_host_impl->SetVisible(true);
   layer_tree_host_impl->InitializeRenderer(output_surface.get());
   layer_tree_host_impl->WillBeginImplFrame(
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
   layer_tree_host_impl->SetViewportSize(gfx::Size(500, 500));
 
   std::unique_ptr<LayerImpl> root =
       FakeDrawableLayerImpl::Create(layer_tree_host_impl->active_tree(), 1);
-  root->SetForceRenderSurface(true);
+  root->test_properties()->force_render_surface = true;
   std::unique_ptr<LayerImpl> child =
       FakeDrawableLayerImpl::Create(layer_tree_host_impl->active_tree(), 2);
   child->SetPosition(gfx::PointF(12.f, 13.f));
   child->SetBounds(gfx::Size(14, 15));
   child->SetDrawsContent(true);
   root->SetBounds(gfx::Size(500, 500));
   root->SetDrawsContent(true);
   root->AddChild(std::move(child));
   layer_tree_host_impl->active_tree()->SetRootLayer(std::move(root));
 
@@ skipping 49 matching lines @@
 
 TEST_F(LayerTreeHostImplTest, RootLayerDoesntCreateExtraSurface) {
   std::unique_ptr<LayerImpl> root =
       FakeDrawableLayerImpl::Create(host_impl_->active_tree(), 1);
   std::unique_ptr<LayerImpl> child =
       FakeDrawableLayerImpl::Create(host_impl_->active_tree(), 2);
   child->SetBounds(gfx::Size(10, 10));
   child->SetDrawsContent(true);
   root->SetBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
-  root->SetForceRenderSurface(true);
+  root->test_properties()->force_render_surface = true;
   root->AddChild(std::move(child));
 
   host_impl_->active_tree()->SetRootLayer(std::move(root));
 
   LayerTreeHostImpl::FrameData frame;
 
   EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
   EXPECT_EQ(1u, frame.render_surface_layer_list->size());
   EXPECT_EQ(1u, frame.render_passes.size());
   host_impl_->DidDrawAllLayers(frame);
@@ skipping 231 matching lines @@
       LayerImpl::Create(my_host_impl->active_tree(), 1);
   std::unique_ptr<LayerImpl> child =
       LayerImpl::Create(my_host_impl->active_tree(), 2);
   std::unique_ptr<LayerImpl> grand_child =
       FakeLayerWithQuads::Create(my_host_impl->active_tree(), 3);
 
   gfx::Rect root_rect(0, 0, 100, 100);
   gfx::Rect child_rect(10, 10, 50, 50);
   gfx::Rect grand_child_rect(5, 5, 150, 150);
 
-  root->SetForceRenderSurface(true);
+  root->test_properties()->force_render_surface = true;
   root->SetPosition(gfx::PointF(root_rect.origin()));
   root->SetBounds(root_rect.size());
   root->draw_properties().visible_layer_rect = root_rect;
   root->SetDrawsContent(false);
 
   child->SetPosition(gfx::PointF(child_rect.x(), child_rect.y()));
   child->SetOpacity(0.5f);
   child->SetBounds(gfx::Size(child_rect.width(), child_rect.height()));
   child->draw_properties().visible_layer_rect = child_rect;
   child->SetDrawsContent(false);
-  child->SetForceRenderSurface(true);
+  child->test_properties()->force_render_surface = true;
 
   grand_child->SetPosition(gfx::PointF(grand_child_rect.origin()));
   grand_child->SetBounds(grand_child_rect.size());
   grand_child->draw_properties().visible_layer_rect = grand_child_rect;
   grand_child->SetDrawsContent(true);
 
   child->AddChild(std::move(grand_child));
   root->AddChild(std::move(child));
 
   my_host_impl->active_tree()->SetRootLayer(std::move(root));
@@ skipping 65 matching lines @@
   std::unique_ptr<TestWebGraphicsContext3D> context =
       TestWebGraphicsContext3D::Create();
   TestWebGraphicsContext3D* context3d = context.get();
   std::unique_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(std::move(context)));
   CreateHostImpl(DefaultSettings(), std::move(output_surface));
 
   std::unique_ptr<LayerImpl> root_layer =
       LayerImpl::Create(host_impl_->active_tree(), 1);
   root_layer->SetBounds(gfx::Size(10, 10));
-  root_layer->SetForceRenderSurface(true);
+  root_layer->test_properties()->force_render_surface = true;
 
   scoped_refptr<VideoFrame> softwareFrame =
       media::VideoFrame::CreateColorFrame(
           gfx::Size(4, 4), 0x80, 0x80, 0x80, base::TimeDelta());
   FakeVideoFrameProvider provider;
   provider.set_frame(softwareFrame);
   std::unique_ptr<VideoLayerImpl> video_layer = VideoLayerImpl::Create(
       host_impl_->active_tree(), 4, &provider, media::VIDEO_ROTATION_0);
   video_layer->SetBounds(gfx::Size(10, 10));
   video_layer->SetDrawsContent(true);
@@ skipping 104 matching lines @@
     EXPECT_EQ(expect_to_draw, host_impl_->SwapBuffers(frame));
   }
 };
 
 TEST_F(LayerTreeHostImplTestWithDelegatingRenderer, FrameIncludesDamageRect) {
   std::unique_ptr<SolidColorLayerImpl> root =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetPosition(gfx::PointF());
   root->SetBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
-  root->SetForceRenderSurface(true);
+  root->test_properties()->force_render_surface = true;
 
   // Child layer is in the bottom right corner.
   std::unique_ptr<SolidColorLayerImpl> child =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), 2);
   child->SetPosition(gfx::PointF(9.f, 9.f));
   child->SetBounds(gfx::Size(1, 1));
   child->SetDrawsContent(true);
   root->AddChild(std::move(child));
 
   host_impl_->active_tree()->SetRootLayer(std::move(root));
@@ skipping 36 matching lines @@
   host_impl_->SetViewportSize(device_viewport_size);
 
   host_impl_->CreatePendingTree();
   host_impl_->pending_tree()->SetDeviceScaleFactor(device_scale_factor);
   host_impl_->pending_tree()->PushPageScaleFromMainThread(1.f, 1.f / 16.f,
                                                           16.f);
 
   std::unique_ptr<LayerImpl> scoped_root =
       LayerImpl::Create(host_impl_->pending_tree(), 1);
   LayerImpl* root = scoped_root.get();
-  root->SetForceRenderSurface(true);
+  root->test_properties()->force_render_surface = true;
 
   host_impl_->pending_tree()->SetRootLayer(std::move(scoped_root));
 
   std::unique_ptr<LayerImpl> scoped_scrolling_layer =
       LayerImpl::Create(host_impl_->pending_tree(), 2);
   LayerImpl* scrolling_layer = scoped_scrolling_layer.get();
   root->AddChild(std::move(scoped_scrolling_layer));
 
   gfx::Size content_layer_bounds(100000, 100);
   scoped_refptr<FakeRasterSource> raster_source(
@@ skipping 354 matching lines @@
 
 TEST_F(LayerTreeHostImplTest, TouchFlingShouldNotBubble) {
   // When flinging via touch, only the child should scroll (we should not
   // bubble).
   gfx::Size surface_size(10, 10);
   gfx::Size content_size(20, 20);
   std::unique_ptr<LayerImpl> root_ptr =
       LayerImpl::Create(host_impl_->active_tree(), 4);
   std::unique_ptr<LayerImpl> root_clip =
       LayerImpl::Create(host_impl_->active_tree(), 3);
-  root_clip->SetForceRenderSurface(true);
+  root_clip->test_properties()->force_render_surface = true;
 
   std::unique_ptr<LayerImpl> root_scroll =
       CreateScrollableLayer(1, content_size, root_clip.get());
   root_scroll->SetIsContainerForFixedPositionLayers(true);
   std::unique_ptr<LayerImpl> child =
       CreateScrollableLayer(2, content_size, root_clip.get());
 
   root_scroll->AddChild(std::move(child));
   int root_id = root_scroll->id();
   root_clip->AddChild(std::move(root_scroll));
@@ skipping 30 matching lines @@
     ExpectNone(*scroll_info.get(), root_id);
   }
 }
 
 TEST_F(LayerTreeHostImplTest, TouchFlingShouldContinueScrollingCurrentLayer) {
   // Scroll a child layer beyond its maximum scroll range and make sure the
   // the scroll doesn't bubble up to the parent layer.
   gfx::Size surface_size(10, 10);
   std::unique_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl_->active_tree(), 1);
-  root->SetForceRenderSurface(true);
+  root->test_properties()->force_render_surface = true;
   std::unique_ptr<LayerImpl> root_scrolling =
       CreateScrollableLayer(2, surface_size, root.get());
 
   std::unique_ptr<LayerImpl> grand_child =
       CreateScrollableLayer(4, surface_size, root.get());
   grand_child->layer_tree_impl()
       ->property_trees()
       ->scroll_tree.UpdateScrollOffsetBaseForTesting(grand_child->id(),
                                                      gfx::ScrollOffset(0, 2));
 
@@ skipping 68 matching lines @@
     host_impl_->ScrollEnd(EndState().get());
   }
 }
 
 TEST_F(LayerTreeHostImplTest, WheelFlingShouldntBubble) {
   // When flinging via wheel, we shouldn't bubble.
   gfx::Size surface_size(10, 10);
   gfx::Size content_size(20, 20);
   std::unique_ptr<LayerImpl> root_clip =
       LayerImpl::Create(host_impl_->active_tree(), 3);
-  root_clip->SetForceRenderSurface(true);
+  root_clip->test_properties()->force_render_surface = true;
   std::unique_ptr<LayerImpl> root_scroll =
       CreateScrollableLayer(1, content_size, root_clip.get());
   int root_scroll_id = root_scroll->id();
   std::unique_ptr<LayerImpl> child =
       CreateScrollableLayer(2, content_size, root_clip.get());
 
   root_scroll->AddChild(std::move(child));
   root_clip->AddChild(std::move(root_scroll));
 
   host_impl_->SetViewportSize(surface_size);
@@ skipping 234 matching lines @@
 }
 
 // Make sure LatencyInfo carried by LatencyInfoSwapPromise are passed
 // to CompositorFrameMetadata after SwapBuffers();
 TEST_F(LayerTreeHostImplTest, LatencyInfoPassedToCompositorFrameMetadata) {
   std::unique_ptr<SolidColorLayerImpl> root =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetPosition(gfx::PointF());
   root->SetBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
-  root->SetForceRenderSurface(true);
+  root->test_properties()->force_render_surface = true;
 
   host_impl_->active_tree()->SetRootLayer(std::move(root));
 
   FakeOutputSurface* fake_output_surface =
       static_cast<FakeOutputSurface*>(host_impl_->output_surface());
 
   const std::vector<ui::LatencyInfo>& metadata_latency_before =
       fake_output_surface->last_sent_frame().metadata.latency_info;
   EXPECT_TRUE(metadata_latency_before.empty());
 
@@ skipping 19 matching lines @@
       ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT, 0, NULL));
 }
 
 TEST_F(LayerTreeHostImplTest, SelectionBoundsPassedToCompositorFrameMetadata) {
   int root_layer_id = 1;
   std::unique_ptr<SolidColorLayerImpl> root =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), root_layer_id);
   root->SetPosition(gfx::PointF());
   root->SetBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
-  root->SetForceRenderSurface(true);
+  root->test_properties()->force_render_surface = true;
 
   host_impl_->active_tree()->SetRootLayer(std::move(root));
 
   // Ensure the default frame selection bounds are empty.
   FakeOutputSurface* fake_output_surface =
       static_cast<FakeOutputSurface*>(host_impl_->output_surface());
   const ViewportSelection& selection_before =
       fake_output_surface->last_sent_frame().metadata.selection;
   EXPECT_EQ(ViewportSelectionBound(), selection_before.start);
   EXPECT_EQ(ViewportSelectionBound(), selection_before.end);
@@ skipping 675 matching lines @@
     contents->SetDrawsContent(true);
     contents->SetBounds(content_size);
     contents->SetPosition(gfx::PointF());
 
     outer_scroll->AddChild(std::move(contents));
     outer_clip->AddChild(std::move(outer_scroll));
     inner_scroll->AddChild(std::move(outer_clip));
     page_scale->AddChild(std::move(inner_scroll));
     inner_clip->AddChild(std::move(page_scale));
 
-    inner_clip->SetForceRenderSurface(true);
+    inner_clip->test_properties()->force_render_surface = true;
     layer_tree_impl->SetRootLayer(std::move(inner_clip));
     layer_tree_impl->SetViewportLayersFromIds(
         Layer::INVALID_ID, kPageScaleLayerId, kInnerViewportScrollLayerId,
         kOuterViewportScrollLayerId);
 
     host_impl_->active_tree()->DidBecomeActive();
   }
 };
 
 TEST_F(LayerTreeHostImplVirtualViewportTest, ScrollBothInnerAndOuterLayer) {
@@ skipping 582 matching lines @@
   EXPECT_EQ(gfx::Rect(50, 50), content_layer->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostImplTest, ExternalTransformAffectsSublayerScaleFactor) {
   const gfx::Size layer_size(100, 100);
   SetupScrollAndContentsLayers(layer_size);
   LayerImpl* content_layer =
       host_impl_->active_tree()->OuterViewportScrollLayer()->children()[0];
   content_layer->AddChild(LayerImpl::Create(host_impl_->active_tree(), 100));
   LayerImpl* test_layer = host_impl_->active_tree()->LayerById(100);
-  test_layer->SetForceRenderSurface(true);
+  test_layer->test_properties()->force_render_surface = true;
   test_layer->SetDrawsContent(true);
   test_layer->SetBounds(layer_size);
   gfx::Transform perspective_transform;
   perspective_transform.ApplyPerspectiveDepth(2);
   test_layer->SetTransform(perspective_transform);
 
   SetNeedsRebuildPropertyTrees();
   RebuildPropertyTrees();
   bool update_lcd_text = false;
 
@@ skipping 1029 matching lines @@
 TEST_F(LayerTreeHostImplTest, SubLayerScaleForNodeInSubtreeOfPageScaleLayer) {
   // Checks that the sublayer scale of a transform node in the subtree of the
   // page scale layer is updated without a property tree rebuild.
   host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 1.f, 3.f);
   CreateScrollAndContentsLayers(host_impl_->active_tree(), gfx::Size(100, 100));
   LayerImpl* page_scale_layer = host_impl_->active_tree()->PageScaleLayer();
   page_scale_layer->AddChild(LayerImpl::Create(host_impl_->active_tree(), 100));
 
   LayerImpl* in_subtree_of_page_scale_layer =
       host_impl_->active_tree()->LayerById(100);
-  in_subtree_of_page_scale_layer->SetForceRenderSurface(true);
+  in_subtree_of_page_scale_layer->test_properties()->force_render_surface =
+      true;
   SetNeedsRebuildPropertyTrees();
   RebuildPropertyTrees();
   DrawFrame();
   TransformNode* node =
       host_impl_->active_tree()->property_trees()->transform_tree.Node(
           in_subtree_of_page_scale_layer->transform_tree_index());
   EXPECT_EQ(node->data.sublayer_scale, gfx::Vector2dF(1.f, 1.f));
 
   host_impl_->active_tree()->SetPageScaleOnActiveTree(2.f);
   DrawFrame();
@@ skipping 64 matching lines @@
     // There should not be any jitter measured till we hit the fixed point hits
     // threshold.
     float expected_jitter =
         (i == pending_tree->kFixedPointHitsThreshold) ? 500 : 0;
     EXPECT_EQ(jitter, expected_jitter);
   }
 }
 
 }  // namespace
 }  // namespace cc