cc: Move SyncedScrollOffset to scroll tree

cc/layers/layer.cc

 // Copyright 2010 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/layer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 866 matching lines @@
 void Layer::SetScrollOffset(const gfx::ScrollOffset& scroll_offset) {
   DCHECK(IsPropertyChangeAllowed());
 
   if (scroll_offset_ == scroll_offset)
     return;
   scroll_offset_ = 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())) {
     if (transform_node->owner_id == id()) {
       transform_node->data.scroll_offset = CurrentScrollOffset();
       transform_node->data.needs_local_transform_update = true;
       layer_tree_host_->property_trees()->transform_tree.set_needs_update(true);
       SetNeedsCommitNoRebuild();
       return;
     }
@@ skipping 19 matching lines @@
   DCHECK(IsPropertyChangeAllowed());
   // This function only gets called during a BeginMainFrame, so there
   // is no need to call SetNeedsUpdate here.
   DCHECK(layer_tree_host_ && layer_tree_host_->CommitRequested());
   if (scroll_offset_ == scroll_offset)
     return;
   scroll_offset_ = scroll_offset;
   SetNeedsPushProperties();
 
   bool needs_rebuild = true;
+
+  if (scroll_tree_index() != -1 && scrollable())
+    layer_tree_host_->property_trees()
+        ->scroll_tree.synced_scroll_offset(id())
+        ->PushFromMainThread(scroll_offset);

[ajuma, 2016/03/02 18:43:09]

How about calling ScrollTree::SetScrollOffset here?

[sunxd, 2016/03/02 20:52:55]

Done.

+
   if (TransformNode* transform_node =
           layer_tree_host_->property_trees()->transform_tree.Node(
               transform_tree_index())) {
     if (transform_node->owner_id == id()) {
       transform_node->data.scroll_offset = CurrentScrollOffset();
       transform_node->data.needs_local_transform_update = true;
       layer_tree_host_->property_trees()->transform_tree.set_needs_update(true);
       needs_rebuild = false;
     }
   }
@@ skipping 394 matching lines @@
     layer->SetClipChildren(clip_children);
   } else {
     layer->SetClipChildren(nullptr);
   }
 
   // When a scroll offset animation is interrupted the new scroll position on
   // the pending tree will clobber any impl-side scrolling occuring on the
   // 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());
 
   {
     TRACE_EVENT0("cc", "Layer::PushPropertiesTo::CopyOutputRequests");
     // Wrap the copy_requests_ in a PostTask to the main thread.
     std::vector<scoped_ptr<CopyOutputRequest>> main_thread_copy_requests;
     for (auto it = copy_requests_.begin(); it != copy_requests_.end(); ++it) {
       scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner =
           layer_tree_host()->task_runner_provider()->MainThreadTaskRunner();
       scoped_ptr<CopyOutputRequest> original_request = std::move(*it);
@@ skipping 340 matching lines @@
   }
 
   scroll_offset_ = ProtoToScrollOffset(base.scroll_offset());
   scroll_compensation_adjustment_ =
       ProtoToVector2dF(base.scroll_compensation_adjustment());
 
   update_rect_.Union(ProtoToRect(base.update_rect()));
 }
 
 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_, new SyncedScrollOffset);
 }
 
 bool Layer::DrawsContent() const {
   return draws_content_;
 }
 
 bool Layer::HasDrawableContent() const {
   return is_drawable_;
 }
 
@@ skipping 361 matching lines @@
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 gfx::Transform Layer::screen_space_transform() const {
   DCHECK_NE(transform_tree_index_, -1);
   return ScreenSpaceTransformFromPropertyTrees(
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 }  // namespace cc