Pinch/Zoom Infrastructure & Plumbing CL

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 <set>
 #include <string>
 
@@ skipping 338 matching lines @@
 
   void SetScrollOffsetDelegate(
       LayerScrollOffsetDelegate* scroll_offset_delegate);
   bool IsExternalFlingActive() const;
 
   void SetScrollOffset(gfx::Vector2d scroll_offset);
   void SetScrollOffsetAndDelta(gfx::Vector2d scroll_offset,
                                gfx::Vector2dF scroll_delta);
   gfx::Vector2d scroll_offset() const { return scroll_offset_; }
 
-  void SetMaxScrollOffset(gfx::Vector2d max_scroll_offset);
-  gfx::Vector2d max_scroll_offset() const { return max_scroll_offset_; }
+  gfx::Vector2d MaxScrollOffset() const;
+  gfx::Vector2dF ClampScrollToMaxScrollOffset();
+  void SetScrollbarPosition(ScrollbarLayerImplBase* scrollbar_layer,
+                            LayerImpl* scrollbar_clip_layer) const; 
 
   void SetScrollDelta(gfx::Vector2dF scroll_delta);
   gfx::Vector2dF ScrollDelta() const;
 
   gfx::Vector2dF TotalScrollOffset() const;
 
   void SetSentScrollDelta(gfx::Vector2d sent_scroll_delta);
   gfx::Vector2d sent_scroll_delta() const { return sent_scroll_delta_; }
 
   // Returns the delta of the scroll that was outside of the bounds of the
   // initial scroll
   gfx::Vector2dF ScrollBy(gfx::Vector2dF scroll);
 
-  void SetScrollable(bool scrollable) { scrollable_ = scrollable; }
-  bool scrollable() const { return scrollable_; }
+  void SetScrollable(int clip_layer_id);
+  bool scrollable() const { return clip_layer_; }
 
   void set_user_scrollable_horizontal(bool scrollable) {
     user_scrollable_horizontal_ = scrollable;
   }
   void set_user_scrollable_vertical(bool scrollable) {
     user_scrollable_vertical_ = scrollable;
   }
 
   void ApplySentScrollDeltasFromAbortedCommit();
   void ApplyScrollDeltasSinceBeginMainFrame();
@@ skipping 71 matching lines @@
 
   // Indicates that the surface previously used to render this layer
   // was lost and that a new one has been created. Won't be called
   // until the new surface has been created successfully.
   virtual void DidLoseOutputSurface();
 
   ScrollbarAnimationController* scrollbar_animation_controller() const {
     return scrollbar_animation_controller_.get();
   }
 
-  void SetHorizontalScrollbarLayer(ScrollbarLayerImplBase* scrollbar_layer);
-  ScrollbarLayerImplBase* horizontal_scrollbar_layer() {
-    return horizontal_scrollbar_layer_;
-  }
-
-  void SetVerticalScrollbarLayer(ScrollbarLayerImplBase* scrollbar_layer);
-  ScrollbarLayerImplBase* vertical_scrollbar_layer() {
-    return vertical_scrollbar_layer_;
-  }
+  typedef std::set<ScrollbarLayerImplBase*> ScrollbarSet;
+  ScrollbarSet* scrollbars() { return scrollbars_.get(); }
+  void ClearScrollbars();
+  void AddScrollbar(ScrollbarLayerImplBase* layer);
+  void RemoveScrollbar(ScrollbarLayerImplBase* layer);
+  bool HasScrollbar(ScrollbarOrientation orientation) const;
+  void NotifyScrollbars();
+  int clip_height() { return clip_layer_ ? clip_layer_->bounds().height() : 0; }

[enne (OOO), 2013/10/31 18:45:58]

Why just height?

[wjmaclean, 2013/11/13 21:01:29]

There are currently no consumers for width ... this is called in
LayerTreeHostImpl::ScrollVerticallyByPage() which only cares about the clip
height.

 
   gfx::Rect LayerRectToContentRect(const gfx::RectF& layer_rect) const;
 
   virtual skia::RefPtr<SkPicture> GetPicture();
 
   virtual bool AreVisibleResourcesReady() const;
 
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl);
   virtual void PushPropertiesTo(LayerImpl* layer);
 
@@ skipping 21 matching lines @@
 
   virtual void AsValueInto(base::DictionaryValue* dict) const;
 
   void NoteLayerPropertyChanged();
   void NoteLayerPropertyChangedForSubtree();
 
   // Note carefully this does not affect the current layer.
   void NoteLayerPropertyChangedForDescendants();
 
  private:
-  void UpdateScrollbarPositions();
-
   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
@@ skipping 12 matching lines @@
   scoped_ptr<LayerImpl> replica_layer_;
   int layer_id_;
   LayerTreeImpl* layer_tree_impl_;
 
   // Properties synchronized from the associated Layer.
   gfx::PointF anchor_point_;
   float anchor_point_z_;
   gfx::Size bounds_;
   gfx::Vector2d scroll_offset_;
   LayerScrollOffsetDelegate* scroll_offset_delegate_;
-  bool scrollable_;
+  LayerImpl* clip_layer_;
   bool should_scroll_on_main_thread_;
   bool have_wheel_event_handlers_;
   bool user_scrollable_horizontal_;
   bool user_scrollable_vertical_;
   Region non_fast_scrollable_region_;
   Region touch_event_handler_region_;
   SkColor background_color_;
   bool stacking_order_changed_;
 
   // Whether the "back" of this layer should draw.
@@ skipping 19 matching lines @@
   // Set for the layer that other layers are fixed to.
   bool is_container_for_fixed_position_layers_;
   // This property is effective when
   // is_container_for_fixed_position_layers_ == true,
   gfx::Vector2dF fixed_container_size_delta_;
 
   LayerPositionConstraint position_constraint_;
 
   gfx::Vector2dF scroll_delta_;
   gfx::Vector2d sent_scroll_delta_;
-  gfx::Vector2d max_scroll_offset_;
+//  gfx::Vector2d max_scroll_offset_;
   gfx::Vector2dF last_scroll_offset_;
 
   // The global depth value of the center of the layer. This value is used
   // to sort layers from back to front.
   float draw_depth_;
 
   // Debug layer name.
   std::string debug_name_;
   CompositingReasons compositing_reasons_;
 
   FilterOperations filters_;
   FilterOperations background_filters_;
 
  protected:
   DrawMode current_draw_mode_;
 
  private:
   // Rect indicating what was repainted/updated during update.
   // Note that plugin layers bypass this and leave it empty.
   // Uses layer's content space.
   gfx::RectF update_rect_;
 
   // Manages animations for this layer.
   scoped_refptr<LayerAnimationController> layer_animation_controller_;
 
   // Manages scrollbars for this layer
   scoped_ptr<ScrollbarAnimationController> scrollbar_animation_controller_;
 
-  // Weak pointers to this layer's scrollbars, if it has them. Updated during
-  // tree synchronization.
-  ScrollbarLayerImplBase* horizontal_scrollbar_layer_;
-  ScrollbarLayerImplBase* vertical_scrollbar_layer_;
+  scoped_ptr<ScrollbarSet> scrollbars_;
 
   ScopedPtrVector<CopyOutputRequest> copy_requests_;
 
   // Group of properties that need to be computed based on the layer tree
   // hierarchy before layers can be drawn.
   DrawProperties<LayerImpl> draw_properties_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerImpl);
 };
 
 }  // namespace cc
 
 #endif  // CC_LAYERS_LAYER_IMPL_H_