cc: Move SyncedScrollOffset to scroll tree

cc/trees/property_tree_builder.cc

 // Copyright 2014 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/property_tree_builder.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <set>
@@ skipping 652 matching lines @@
       main_thread_scrolling_reasons !=
       data_from_ancestor.main_thread_scrolling_reasons;
   bool requires_node =
       scroll_node_uninheritable_criteria ||
       (main_thread_scrolling_reasons !=
            MainThreadScrollingReason::kNotScrollingOnMain &&
        (has_different_main_thread_scrolling_reasons ||
         data_from_ancestor
             .scroll_tree_parent_created_by_uninheritable_criteria));
 
+  // Remove the entry from scroll_offset_map
+  if (!scrollable)
+    data_for_children->scroll_tree->scroll_offset_map().erase(layer->id());
+
   if (!requires_node) {
     data_for_children->scroll_tree_parent = parent_id;
   } else {
     ScrollNode node;
     node.owner_id = layer->id();
     node.data.scrollable = scrollable;
     node.data.main_thread_scrolling_reasons = main_thread_scrolling_reasons;
     node.data.contains_non_fast_scrollable_region =
         contains_non_fast_scrollable_region;
     gfx::Size clip_bounds;
@@ skipping 23 matching lines @@
     node.data.element_id = layer->element_id();
     node.data.transform_id =
         data_for_children->transform_tree_parent->transform_tree_index();
 
     data_for_children->scroll_tree_parent =
         data_for_children->scroll_tree->Insert(node, parent_id);
     data_for_children->main_thread_scrolling_reasons =
         node.data.main_thread_scrolling_reasons;
     data_for_children->scroll_tree_parent_created_by_uninheritable_criteria =
         scroll_node_uninheritable_criteria;
+
+    if (node.data.scrollable) {
+      data_for_children->scroll_tree->synced_scroll_offset(layer->id())
+          ->PushFromMainThread(layer->scroll_offset());
+    }
   }
 
   layer->SetScrollTreeIndex(data_for_children->scroll_tree_parent);
 }
 
 template <typename LayerType>
 void SetBackfaceVisibilityTransform(LayerType* layer,
                                     bool created_transform_node) {
   const bool is_at_boundary_of_3d_rendering_context =
       IsAtBoundaryOf3dRenderingContext(layer);
@@ skipping 207 matching lines @@
     const Layer* page_scale_layer,
     const Layer* inner_viewport_scroll_layer,
     const Layer* outer_viewport_scroll_layer,
     const Layer* overscroll_elasticity_layer,
     const gfx::Vector2dF& elastic_overscroll,
     float page_scale_factor,
     float device_scale_factor,
     const gfx::Rect& viewport,
     const gfx::Transform& device_transform,
     PropertyTrees* property_trees) {
+  property_trees->is_main_thread = true;
+  property_trees->is_active = false;
   BuildPropertyTreesTopLevelInternal(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
       outer_viewport_scroll_layer, overscroll_elasticity_layer,
       elastic_overscroll, page_scale_factor, device_scale_factor, viewport,
       device_transform, property_trees);
 }
 
 void PropertyTreeBuilder::BuildPropertyTrees(
     LayerImpl* root_layer,
     const LayerImpl* page_scale_layer,
     const LayerImpl* inner_viewport_scroll_layer,
     const LayerImpl* outer_viewport_scroll_layer,
     const LayerImpl* overscroll_elasticity_layer,
     const gfx::Vector2dF& elastic_overscroll,
     float page_scale_factor,
     float device_scale_factor,
     const gfx::Rect& viewport,
     const gfx::Transform& device_transform,
     PropertyTrees* property_trees) {
+  property_trees->is_main_thread = false;
+  property_trees->is_active = root_layer->IsActive();
   BuildPropertyTreesTopLevelInternal(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
       outer_viewport_scroll_layer, overscroll_elasticity_layer,
       elastic_overscroll, page_scale_factor, device_scale_factor, viewport,
       device_transform, property_trees);
 }
 
 }  // namespace cc