cc: Move SyncedScrollOffset to scroll tree

cc/layers/layer_impl.h

 // 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.
 
 #ifndef CC_LAYERS_LAYER_IMPL_H_
 #define CC_LAYERS_LAYER_IMPL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 65 matching lines @@
   DRAW_MODE_NONE,
   DRAW_MODE_HARDWARE,
   DRAW_MODE_SOFTWARE,
   DRAW_MODE_RESOURCELESS_SOFTWARE
 };
 
 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));
   }
 
   ~LayerImpl() override;
 
   int id() const { return layer_id_; }
 
   // LayerAnimationValueProvider implementation.
   gfx::ScrollOffset ScrollOffsetForAnimation() const override;
@@ skipping 346 matching lines @@
 
   void SetBounds(const gfx::Size& bounds);
   gfx::Size bounds() const;
   // Like bounds() but doesn't snap to int. Lossy on giant pages (e.g. millions
   // of pixels) due to use of single precision float.
   gfx::SizeF BoundsForScrolling() const;
   void SetBoundsDelta(const gfx::Vector2dF& bounds_delta);
   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;
   void SetScrollDelta(const gfx::Vector2dF& delta);
 
   gfx::ScrollOffset MaxScrollOffset() const;
   gfx::ScrollOffset ClampScrollOffsetToLimits(gfx::ScrollOffset offset) const;
   gfx::Vector2dF ClampScrollToMaxScrollOffset();
   void SetScrollCompensationAdjustment(const gfx::Vector2dF& scroll_offset) {
     scroll_compensation_adjustment_ = scroll_offset;
@@ skipping 17 matching lines @@
   bool user_scrollable_horizontal() const {
     return user_scrollable_horizontal_;
   }
   void set_user_scrollable_vertical(bool scrollable) {
     user_scrollable_vertical_ = scrollable;
   }
   bool user_scrollable_vertical() const { return user_scrollable_vertical_; }
 
   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 {
     return main_thread_scrolling_reasons_;
   }
   bool should_scroll_on_main_thread() const {
     return !!main_thread_scrolling_reasons_;
   }
 
   void SetNonFastScrollableRegion(const Region& region) {
@@ skipping 108 matching lines @@
   void Set3dSortingContextId(int id);
   int sorting_context_id() { return sorting_context_id_; }
 
   void SetFrameTimingRequests(
       const std::vector<FrameTimingRequest>& frame_timing_requests);
   const std::vector<FrameTimingRequest>& frame_timing_requests() const {
     return frame_timing_requests_;
   }
   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.
   virtual Region GetInvalidationRegion();
 
   virtual gfx::Rect GetEnclosingRectInTargetSpace() const;
 
   void set_visited(bool visited) { visited_ = visited; }
 
   bool visited() { return visited_; }
@@ skipping 29 matching lines @@
 
   bool was_ever_ready_since_last_transform_animation() const {
     return was_ever_ready_since_last_transform_animation_;
   }
 
   void set_was_ever_ready_since_last_transform_animation(bool was_ready) {
     was_ever_ready_since_last_transform_animation_ = was_ready;
   }
 
   void NoteLayerPropertyChanged();
+  void DidUpdateScrollOffset();
 
   void PushLayerPropertyChangedForSubtree();
 
  protected:
   LayerImpl(LayerTreeImpl* layer_impl,
             int id,
             scoped_refptr<SyncedScrollOffset> scroll_offset);
   LayerImpl(LayerTreeImpl* layer_impl, int id);
 
   // Get the color and size of the layer's debug border.
   virtual void GetDebugBorderProperties(SkColor* color, float* width) const;
 
   void AppendDebugBorderQuad(RenderPass* render_pass,
                              const gfx::Size& bounds,
                              const SharedQuadState* shared_quad_state,
                              AppendQuadsData* append_quads_data) const;
   void AppendDebugBorderQuad(RenderPass* render_pass,
                              const gfx::Size& bounds,
                              const SharedQuadState* shared_quad_state,
                              AppendQuadsData* append_quads_data,
                              SkColor color,
                              float width) const;
 
   gfx::Rect GetScaledEnclosingRectInTargetSpace(float scale) const;
 
  private:
   void ValidateQuadResourcesInternal(DrawQuad* quad) const;
 
-  void PushScrollOffset(const gfx::ScrollOffset* scroll_offset);
-  void DidUpdateScrollOffset();
   void NoteLayerPropertyChangedForDescendantsInternal();
   void PushLayerPropertyChangedForSubtreeInternal();
 
   virtual const char* LayerTypeAsString() const;
 
   // Properties internal to LayerImpl
   LayerImpl* parent_;
   OwnedLayerImplList children_;
 
   LayerImpl* scroll_parent_;
 
   // Storing a pointer to a set rather than a set since this will be rarely
   // used. If this pointer turns out to be too heavy, we could have this (and
   // the scroll parent above) be stored in a LayerImpl -> scroll_info
   // map somewhere.
   scoped_ptr<std::set<LayerImpl*>> scroll_children_;
 
   LayerImpl* clip_parent_;
   scoped_ptr<std::set<LayerImpl*>> clip_children_;
 
   // mask_layer_ can be temporarily stolen during tree sync, we need this ID to
   // confirm newly assigned layer is still the previous one
   int mask_layer_id_;
   scoped_ptr<LayerImpl> mask_layer_;
   int replica_layer_id_;  // ditto
   scoped_ptr<LayerImpl> replica_layer_;
   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.
   gfx::Point3F transform_origin_;
   gfx::Size bounds_;
   int scroll_clip_layer_id_;
 
   gfx::Vector2dF offset_to_transform_parent_;
   uint32_t main_thread_scrolling_reasons_;
 
@@ skipping 115 matching lines @@
   // If true, the layer or one of its descendants has a touch handler.
   bool layer_or_descendant_has_touch_handler_;
   bool sorted_for_recursion_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerImpl);
 };
 
 }  // namespace cc
 
 #endif  // CC_LAYERS_LAYER_IMPL_H_