cc: Move SyncedScrollOffset to scroll tree

Now updating scrolling information on impl side can be independent of layer impl.
There are still some left-over changes corresponding to NoteLayerPropertiesChanged.

SyncedScrollOffset of scrollable layers are now stored in property trees instead of
layer impl. The main thread property tree has one copy while pending and active share
one.

BUG=568830
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1736073002

Cr-Commit-Position: refs/heads/master@{#379116}

11 files changed, 78 insertions, 127 deletions

diff --git a/cc/layers/layer.cc b/cc/layers/layer.cc
index 23abc3b..7f51dc0 100644
--- a/cc/layers/layer.cc
+++ b/cc/layers/layer.cc
@@ -884,6 +884,10 @@ void Layer::SetScrollOffset(const gfx::ScrollOffset& scroll_offset) {
   if (!layer_tree_host_)
     return;
 
+  if (scroll_tree_index() != -1 && scrollable())
+    layer_tree_host_->property_trees()->scroll_tree.SetScrollOffset(
+        id(), scroll_offset);
+
   if (TransformNode* transform_node =
           layer_tree_host_->property_trees()->transform_tree.Node(
               transform_tree_index())) {
@@ -923,6 +927,11 @@ void Layer::SetScrollOffsetFromImplSide(
   SetNeedsPushProperties();
 
   bool needs_rebuild = true;
+
+  if (scroll_tree_index() != -1 && scrollable())
+    layer_tree_host_->property_trees()->scroll_tree.SetScrollOffset(
+        id(), scroll_offset);
+
   if (TransformNode* transform_node =
           layer_tree_host_->property_trees()->transform_tree.Node(
               transform_tree_index())) {
@@ -1338,9 +1347,10 @@ void Layer::PushPropertiesTo(LayerImpl* layer) {
   // active tree. To do so, avoid scrolling the pending tree along with it
   // instead of trying to undo that scrolling later.
   if (ScrollOffsetAnimationWasInterrupted())
-    layer->PushScrollOffsetFromMainThreadAndClobberActiveValue(scroll_offset_);
-  else
-    layer->PushScrollOffsetFromMainThread(scroll_offset_);
+    layer_tree_host()
+        ->property_trees()
+        ->scroll_tree.synced_scroll_offset(layer->id())
+        ->set_clobber_active_value();
   layer->SetScrollCompensationAdjustment(ScrollCompensationAdjustment());
 
   {
@@ -1703,8 +1713,7 @@ void Layer::FromLayerSpecificPropertiesProto(
 }
 
 scoped_ptr<LayerImpl> Layer::CreateLayerImpl(LayerTreeImpl* tree_impl) {
-  return LayerImpl::Create(tree_impl, layer_id_,
-                           new LayerImpl::SyncedScrollOffset);
+  return LayerImpl::Create(tree_impl, layer_id_);
 }
 
 bool Layer::DrawsContent() const {
diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc
index a16baa5..5d31a22 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc
@@ -43,13 +43,7 @@
 #include "ui/gfx/geometry/vector2d_conversions.h"
 
 namespace cc {
-LayerImpl::LayerImpl(LayerTreeImpl* layer_impl, int id)
-    : LayerImpl(layer_impl, id, new LayerImpl::SyncedScrollOffset) {
-}
-
-LayerImpl::LayerImpl(LayerTreeImpl* tree_impl,
-                     int id,
-                     scoped_refptr<SyncedScrollOffset> scroll_offset)
+LayerImpl::LayerImpl(LayerTreeImpl* tree_impl, int id)
     : parent_(nullptr),
       scroll_parent_(nullptr),
       clip_parent_(nullptr),
@@ -57,7 +51,6 @@ LayerImpl::LayerImpl(LayerTreeImpl* tree_impl,
       replica_layer_id_(-1),
       layer_id_(id),
       layer_tree_impl_(tree_impl),
-      scroll_offset_(scroll_offset),
       scroll_clip_layer_id_(Layer::INVALID_ID),
       main_thread_scrolling_reasons_(
           MainThreadScrollingReason::kNotScrollingOnMain),
@@ -490,17 +483,12 @@ bool LayerImpl::user_scrollable(ScrollbarOrientation orientation) const {
                                      : user_scrollable_vertical_;
 }
 
-void LayerImpl::ApplySentScrollDeltasFromAbortedCommit() {
-  DCHECK(layer_tree_impl()->IsActiveTree());
-  scroll_offset_->AbortCommit();
-}
-
 skia::RefPtr<SkPicture> LayerImpl::GetPicture() {
   return skia::RefPtr<SkPicture>();
 }
 
 scoped_ptr<LayerImpl> LayerImpl::CreateLayerImpl(LayerTreeImpl* tree_impl) {
-  return LayerImpl::Create(tree_impl, layer_id_, scroll_offset_);
+  return LayerImpl::Create(tree_impl, layer_id_);
 }
 
 void LayerImpl::set_main_thread_scrolling_reasons(
@@ -573,8 +561,6 @@ void LayerImpl::PushPropertiesTo(LayerImpl* layer) {
 
   layer->SetScrollCompensationAdjustment(scroll_compensation_adjustment_);
 
-  layer->PushScrollOffset(nullptr);
-
   layer->Set3dSortingContextId(sorting_context_id_);
   layer->SetNumDescendantsThatDrawContent(num_descendants_that_draw_content_);
 
@@ -1302,6 +1288,16 @@ void LayerImpl::GatherFrameTimingRequestIds(std::vector<int64_t>* request_ids) {
     request_ids->push_back(request.id());
 }
 
+const SyncedScrollOffset* LayerImpl::synced_scroll_offset() const {
+  return layer_tree_impl()->property_trees()->scroll_tree.synced_scroll_offset(
+      id());
+}
+
+SyncedScrollOffset* LayerImpl::synced_scroll_offset() {
+  return layer_tree_impl()->property_trees()->scroll_tree.synced_scroll_offset(
+      id());
+}
+
 void LayerImpl::SetTransform(const gfx::Transform& transform) {
   if (transform_ == transform)
     return;
@@ -1446,74 +1442,45 @@ void LayerImpl::AddDamageRect(const gfx::Rect& damage_rect) {
 
 void LayerImpl::SetCurrentScrollOffset(const gfx::ScrollOffset& scroll_offset) {
   DCHECK(IsActive());
-  if (scroll_offset_->SetCurrent(scroll_offset))
+  if (synced_scroll_offset()->SetCurrent(scroll_offset))
     DidUpdateScrollOffset();
 }
 
-void LayerImpl::PushScrollOffsetFromMainThread(
-    const gfx::ScrollOffset& scroll_offset) {
-  PushScrollOffset(&scroll_offset);
-}
-
-void LayerImpl::PushScrollOffsetFromMainThreadAndClobberActiveValue(
-    const gfx::ScrollOffset& scroll_offset) {
-  scroll_offset_->set_clobber_active_value();
-  PushScrollOffset(&scroll_offset);
-}
-
-gfx::ScrollOffset LayerImpl::PullDeltaForMainThread() {
-  // TODO(miletus): Remove all this temporary flooring machinery when
-  // Blink fully supports fractional scrolls.
-  gfx::ScrollOffset current_offset = CurrentScrollOffset();
-  gfx::ScrollOffset current_delta = IsActive()
-      ? scroll_offset_->Delta()
-      : scroll_offset_->PendingDelta().get();
-  gfx::ScrollOffset floored_delta(floor(current_delta.x()),
-                                  floor(current_delta.y()));
-  gfx::ScrollOffset diff_delta = floored_delta - current_delta;
-  gfx::ScrollOffset tmp_offset = current_offset + diff_delta;
-  scroll_offset_->SetCurrent(tmp_offset);
-  gfx::ScrollOffset delta = scroll_offset_->PullDeltaForMainThread();
-  scroll_offset_->SetCurrent(current_offset);
-  return delta;
-}
-
 gfx::ScrollOffset LayerImpl::CurrentScrollOffset() const {
-  return scroll_offset_->Current(IsActive());
+  return synced_scroll_offset()->Current(IsActive());
 }
 
 gfx::Vector2dF LayerImpl::ScrollDelta() const {
   if (IsActive())
-    return gfx::Vector2dF(scroll_offset_->Delta().x(),
-                          scroll_offset_->Delta().y());
+    return gfx::Vector2dF(synced_scroll_offset()->Delta().x(),
+                          synced_scroll_offset()->Delta().y());
   else
-    return gfx::Vector2dF(scroll_offset_->PendingDelta().get().x(),
-                          scroll_offset_->PendingDelta().get().y());
+    return gfx::Vector2dF(synced_scroll_offset()->PendingDelta().get().x(),
+                          synced_scroll_offset()->PendingDelta().get().y());
 }
 
 void LayerImpl::SetScrollDelta(const gfx::Vector2dF& delta) {
   DCHECK(IsActive());
   DCHECK(scrollable() || delta.IsZero());
-  SetCurrentScrollOffset(scroll_offset_->ActiveBase() +
+  SetCurrentScrollOffset(synced_scroll_offset()->ActiveBase() +
                          gfx::ScrollOffset(delta));
 }
 
 gfx::ScrollOffset LayerImpl::BaseScrollOffset() const {
   if (IsActive())
-    return scroll_offset_->ActiveBase();
+    return synced_scroll_offset()->ActiveBase();
   else
-    return scroll_offset_->PendingBase();
+    return synced_scroll_offset()->PendingBase();
 }
 
-void LayerImpl::PushScrollOffset(const gfx::ScrollOffset* scroll_offset) {
-  DCHECK(scroll_offset || IsActive());
+void LayerImpl::PushScrollOffsetFromMainThread(
+    const gfx::ScrollOffset& scroll_offset) {
   bool changed = false;
-  if (scroll_offset) {
-    DCHECK(!IsActive() || !layer_tree_impl_->FindPendingTreeLayerById(id()));
-    changed |= scroll_offset_->PushFromMainThread(*scroll_offset);
-  }
+  DCHECK(!IsActive() || !layer_tree_impl_->FindPendingTreeLayerById(id()));
+  changed |= synced_scroll_offset()->PushFromMainThread(scroll_offset);
+
   if (IsActive()) {
-    changed |= scroll_offset_->PushPendingToActive();
+    changed |= synced_scroll_offset()->PushPendingToActive();
   }
 
   if (changed)
@@ -1527,7 +1494,8 @@ void LayerImpl::UpdatePropertyTreeScrollOffset() {
     TransformTree& transform_tree =
         layer_tree_impl()->property_trees()->transform_tree;
     TransformNode* node = transform_tree.Node(transform_tree_index_);
-    gfx::ScrollOffset current_offset = scroll_offset_->Current(IsActive());
+    gfx::ScrollOffset current_offset =
+        synced_scroll_offset()->Current(IsActive());
     if (node->data.scroll_offset != current_offset) {
       node->data.scroll_offset = current_offset;
       node->data.needs_local_transform_update = true;
@@ -1537,8 +1505,6 @@ void LayerImpl::UpdatePropertyTreeScrollOffset() {
 }
 
 void LayerImpl::DidUpdateScrollOffset() {
-  DCHECK(scroll_offset_);
-
   layer_tree_impl()->DidUpdateScrollState(id());
 
   if (transform_tree_index_ != -1) {
@@ -1653,10 +1619,11 @@ void LayerImpl::AsValueInto(base::trace_event::TracedValue* state) const {
     state->SetInteger("mutable_properties", mutable_properties_);
   }
 
-  MathUtil::AddToTracedValue(
-      "scroll_offset", scroll_offset_ ? scroll_offset_->Current(IsActive())
-                                      : gfx::ScrollOffset(),
-      state);
+  MathUtil::AddToTracedValue("scroll_offset",
+                             synced_scroll_offset()
+                                 ? synced_scroll_offset()->Current(IsActive())
+                                 : gfx::ScrollOffset(),
+                             state);
 
   MathUtil::AddToTracedValue("transform_origin", transform_origin_, state);
 
diff --git a/cc/layers/layer_impl.h b/cc/layers/layer_impl.h
index f0e14a7..f3e4aca 100644
--- a/cc/layers/layer_impl.h
+++ b/cc/layers/layer_impl.h
@@ -83,20 +83,12 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
                             public LayerAnimationValueProvider,
                             public AnimationDelegate {
  public:
-  typedef SyncedProperty<AdditionGroup<gfx::ScrollOffset>> SyncedScrollOffset;
   typedef LayerImplList RenderSurfaceListType;
   typedef LayerImplList LayerListType;
   typedef RenderSurfaceImpl RenderSurfaceType;
 
   enum RenderingContextConstants { NO_RENDERING_CONTEXT = 0 };
 
-  static scoped_ptr<LayerImpl> Create(
-      LayerTreeImpl* tree_impl,
-      int id,
-      scoped_refptr<SyncedScrollOffset> scroll_offset) {
-    return make_scoped_ptr(new LayerImpl(tree_impl, id, scroll_offset));
-  }
-
   static scoped_ptr<LayerImpl> Create(LayerTreeImpl* tree_impl, int id) {
     return make_scoped_ptr(new LayerImpl(tree_impl, id));
   }
@@ -460,13 +452,12 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
   gfx::Vector2dF bounds_delta() const { return bounds_delta_; }
 
   void SetCurrentScrollOffset(const gfx::ScrollOffset& scroll_offset);
+  // must only be called by tests when updating scroll offset of a single layer,
+  // the standard process to update scroll offsets is to call
+  // ScrollTree::UpdateScrollOffsetMap() which updates scroll offsets of all
+  // layers.
   void PushScrollOffsetFromMainThread(const gfx::ScrollOffset& scroll_offset);
-  // This method is similar to PushScrollOffsetFromMainThread but will cause the
-  // scroll offset given to clobber any scroll changes on the active tree in the
-  // time until this value is pushed to the active tree.
-  void PushScrollOffsetFromMainThreadAndClobberActiveValue(
-      const gfx::ScrollOffset& scroll_offset);
-  gfx::ScrollOffset PullDeltaForMainThread();
+
   gfx::ScrollOffset CurrentScrollOffset() const;
   gfx::ScrollOffset BaseScrollOffset() const;
   gfx::Vector2dF ScrollDelta() const;
@@ -504,8 +495,6 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
 
   bool user_scrollable(ScrollbarOrientation orientation) const;
 
-  void ApplySentScrollDeltasFromAbortedCommit();
-
   void set_main_thread_scrolling_reasons(
       uint32_t main_thread_scrolling_reasons);
   uint32_t main_thread_scrolling_reasons() const {
@@ -634,7 +623,8 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
   }
   void GatherFrameTimingRequestIds(std::vector<int64_t>* request_ids);
 
-  SyncedScrollOffset* synced_scroll_offset() { return scroll_offset_.get(); }
+  const SyncedScrollOffset* synced_scroll_offset() const;
+  SyncedScrollOffset* synced_scroll_offset();
 
   // Get the correct invalidation region instead of conservative Rect
   // for layers that provide it.
@@ -684,6 +674,7 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
   }
 
   void NoteLayerPropertyChanged();
+  void DidUpdateScrollOffset();
 
   void PushLayerPropertyChangedForSubtree();
 
@@ -712,8 +703,6 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
  private:
   void ValidateQuadResourcesInternal(DrawQuad* quad) const;
 
-  void PushScrollOffset(const gfx::ScrollOffset* scroll_offset);
-  void DidUpdateScrollOffset();
   void NoteLayerPropertyChangedForDescendantsInternal();
   void PushLayerPropertyChangedForSubtreeInternal();
 
@@ -743,8 +732,6 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
   int layer_id_;
   LayerTreeImpl* layer_tree_impl_;
 
-  // Properties dynamically changeable on active tree.
-  scoped_refptr<SyncedScrollOffset> scroll_offset_;
   gfx::Vector2dF bounds_delta_;
 
   // Properties synchronized from the associated Layer.
diff --git a/cc/layers/layer_impl_unittest.cc b/cc/layers/layer_impl_unittest.cc
index d804c57..a8336d8 100644
--- a/cc/layers/layer_impl_unittest.cc
+++ b/cc/layers/layer_impl_unittest.cc
@@ -337,8 +337,7 @@ TEST(LayerImplTest, VerifyNeedsUpdateDrawProperties) {
       layer->SetScrollDelta(arbitrary_vector2d));
   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->PushScrollOffsetFromMainThread(
       gfx::ScrollOffset(arbitrary_vector2d)));
-  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->PushScrollOffsetFromMainThread(
-      gfx::ScrollOffset(arbitrary_vector2d)));
+  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->DidUpdateScrollOffset());
 
   // Unrelated functions, always set to new values, always set needs update.
   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
@@ -570,7 +569,7 @@ TEST_F(LayerImplScrollTest, ApplySentScrollsNoListener) {
 
   layer()->PushScrollOffsetFromMainThread(scroll_offset);
   layer()->ScrollBy(sent_scroll_delta);
-  layer()->PullDeltaForMainThread();
+  layer()->synced_scroll_offset()->PullDeltaForMainThread();
   layer()->SetCurrentScrollOffset(scroll_offset +
                                   gfx::ScrollOffset(scroll_delta));
 
@@ -579,7 +578,7 @@ TEST_F(LayerImplScrollTest, ApplySentScrollsNoListener) {
   EXPECT_VECTOR_EQ(scroll_delta, layer()->ScrollDelta());
   EXPECT_VECTOR_EQ(scroll_offset, layer()->BaseScrollOffset());
 
-  layer()->ApplySentScrollDeltasFromAbortedCommit();
+  layer()->synced_scroll_offset()->AbortCommit();
 
   EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(scroll_offset, scroll_delta),
                    layer()->CurrentScrollOffset());
@@ -612,10 +611,10 @@ TEST_F(LayerImplScrollTest, PushPropertiesToMirrorsCurrentScrollOffset) {
   EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 0), unscrolled);
   EXPECT_VECTOR_EQ(gfx::Vector2dF(22, 23), layer()->CurrentScrollOffset());
 
-  layer()->PullDeltaForMainThread();
+  layer()->synced_scroll_offset()->PullDeltaForMainThread();
 
-  scoped_ptr<LayerImpl> pending_layer = LayerImpl::Create(
-      host_impl().sync_tree(), layer()->id(), layer()->synced_scroll_offset());
+  scoped_ptr<LayerImpl> pending_layer =
+      LayerImpl::Create(host_impl().sync_tree(), layer()->id());
   pending_layer->PushScrollOffsetFromMainThread(layer()->CurrentScrollOffset());
 
   pending_layer->PushPropertiesTo(layer());
diff --git a/cc/layers/layer_iterator_unittest.cc b/cc/layers/layer_iterator_unittest.cc
index b9b3cf3..158dd93 100644
--- a/cc/layers/layer_iterator_unittest.cc
+++ b/cc/layers/layer_iterator_unittest.cc
@@ -35,7 +35,7 @@ class TestLayerImpl : public LayerImpl {
 
  private:
   explicit TestLayerImpl(LayerTreeImpl* tree, int id)
-      : LayerImpl(tree, id, new SyncedScrollOffset),
+      : LayerImpl(tree, id),
         count_representing_target_surface_(-1),
         count_representing_contributing_surface_(-1),
         count_representing_itself_(-1) {
diff --git a/cc/layers/picture_image_layer_impl.cc b/cc/layers/picture_image_layer_impl.cc
index 03ef5ae..c816986 100644
--- a/cc/layers/picture_image_layer_impl.cc
+++ b/cc/layers/picture_image_layer_impl.cc
@@ -14,11 +14,7 @@ namespace cc {
 PictureImageLayerImpl::PictureImageLayerImpl(LayerTreeImpl* tree_impl,
                                              int id,
                                              bool is_mask)
-    : PictureLayerImpl(tree_impl,
-                       id,
-                       is_mask,
-                       new LayerImpl::SyncedScrollOffset) {
-}
+    : PictureLayerImpl(tree_impl, id, is_mask) {}
 
 PictureImageLayerImpl::~PictureImageLayerImpl() {
 }
diff --git a/cc/layers/picture_layer.cc b/cc/layers/picture_layer.cc
index afb62c0..f528516 100644
--- a/cc/layers/picture_layer.cc
+++ b/cc/layers/picture_layer.cc
@@ -45,8 +45,7 @@ PictureLayer::~PictureLayer() {
 }
 
 scoped_ptr<LayerImpl> PictureLayer::CreateLayerImpl(LayerTreeImpl* tree_impl) {
-  return PictureLayerImpl::Create(tree_impl, id(), is_mask_,
-                                  new LayerImpl::SyncedScrollOffset);
+  return PictureLayerImpl::Create(tree_impl, id(), is_mask_);
 }
 
 void PictureLayer::PushPropertiesTo(LayerImpl* base_layer) {
diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index 7688b97..076ee23 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -59,12 +59,10 @@ const int kTileMinimalAlignment = 4;
 
 namespace cc {
 
-PictureLayerImpl::PictureLayerImpl(
-    LayerTreeImpl* tree_impl,
-    int id,
-    bool is_mask,
-    scoped_refptr<SyncedScrollOffset> scroll_offset)
-    : LayerImpl(tree_impl, id, scroll_offset),
+PictureLayerImpl::PictureLayerImpl(LayerTreeImpl* tree_impl,
+                                   int id,
+                                   bool is_mask)
+    : LayerImpl(tree_impl, id),
       twin_layer_(nullptr),
       tilings_(CreatePictureLayerTilingSet()),
       ideal_page_scale_(0.f),
@@ -95,8 +93,7 @@ const char* PictureLayerImpl::LayerTypeAsString() const {
 
 scoped_ptr<LayerImpl> PictureLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
-  return PictureLayerImpl::Create(tree_impl, id(), is_mask_,
-                                  synced_scroll_offset());
+  return PictureLayerImpl::Create(tree_impl, id(), is_mask_);
 }
 
 void PictureLayerImpl::PushPropertiesTo(LayerImpl* base_layer) {
diff --git a/cc/layers/picture_layer_impl.h b/cc/layers/picture_layer_impl.h
index 03316dcd..50abaa8 100644
--- a/cc/layers/picture_layer_impl.h
+++ b/cc/layers/picture_layer_impl.h
@@ -30,13 +30,10 @@ class CC_EXPORT PictureLayerImpl
     : public LayerImpl,
       NON_EXPORTED_BASE(public PictureLayerTilingClient) {
  public:
-  static scoped_ptr<PictureLayerImpl> Create(
-      LayerTreeImpl* tree_impl,
-      int id,
-      bool is_mask,
-      scoped_refptr<SyncedScrollOffset> scroll_offset) {
-    return make_scoped_ptr(
-        new PictureLayerImpl(tree_impl, id, is_mask, scroll_offset));
+  static scoped_ptr<PictureLayerImpl> Create(LayerTreeImpl* tree_impl,
+                                             int id,
+                                             bool is_mask) {
+    return make_scoped_ptr(new PictureLayerImpl(tree_impl, id, is_mask));
   }
   ~PictureLayerImpl() override;
 
@@ -103,10 +100,7 @@ class CC_EXPORT PictureLayerImpl
   friend class LayerRasterTileIterator;
   using TileRequirementCheck = bool (PictureLayerTiling::*)(const Tile*) const;
 
-  PictureLayerImpl(LayerTreeImpl* tree_impl,
-                   int id,
-                   bool is_mask,
-                   scoped_refptr<SyncedScrollOffset> scroll_offset);
+  PictureLayerImpl(LayerTreeImpl* tree_impl, int id, bool is_mask);
   PictureLayerTiling* AddTiling(float contents_scale);
   void RemoveAllTilings();
   void AddTilingsForRasterScale();
diff --git a/cc/layers/picture_layer_impl_unittest.cc b/cc/layers/picture_layer_impl_unittest.cc
index f132b3f..67a00a1 100644
--- a/cc/layers/picture_layer_impl_unittest.cc
+++ b/cc/layers/picture_layer_impl_unittest.cc
@@ -239,6 +239,7 @@ class PictureLayerImplTest : public testing::Test {
       if (!tile_size.IsEmpty())
         pending_layer->set_fixed_tile_size(tile_size);
       pending_layer->SetDrawsContent(true);
+      pending_layer->SetScrollClipLayer(pending_root->id());
     } else {
       pending_layer.reset(static_cast<FakePictureLayerImpl*>(
           pending_root->RemoveChild(pending_root->children()[0].get())
diff --git a/cc/layers/scrollbar_layer_unittest.cc b/cc/layers/scrollbar_layer_unittest.cc
index d7beffb..ee41989 100644
--- a/cc/layers/scrollbar_layer_unittest.cc
+++ b/cc/layers/scrollbar_layer_unittest.cc
@@ -219,6 +219,7 @@ TEST_F(ScrollbarLayerTest, ScrollOffsetSynchronization) {
   layer_tree_root->SavePaintProperties();
   content_layer->SavePaintProperties();
 
+  layer_tree_host_->UpdateLayers();
   LayerImpl* layer_impl_tree_root =
       layer_tree_host_->CommitAndCreateLayerImplTree();
 
@@ -330,6 +331,7 @@ TEST_F(ScrollbarLayerTest, ThumbRect) {
   scrollbar_layer->fake_scrollbar()->set_track_rect(gfx::Rect(30, 10, 50, 10));
   scrollbar_layer->fake_scrollbar()->set_thumb_thickness(10);
   scrollbar_layer->fake_scrollbar()->set_thumb_length(4);
+  layer_tree_host_->UpdateLayers();
   LayerImpl* root_clip_layer_impl = nullptr;
   LayerImpl* root_layer_impl = nullptr;
   PaintedScrollbarLayerImpl* scrollbar_layer_impl = nullptr;