Make scroll offset type of float in cc

cc/layers/layer_impl.cc

 // Copyright 2012 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_impl.h"
 
 #include "base/debug/trace_event.h"
 #include "base/debug/trace_event_argument.h"
 #include "base/json/json_reader.h"
 #include "base/strings/stringprintf.h"
@@ skipping 336 matching lines @@
 
 RenderPassId LayerImpl::NextContributingRenderPassId(RenderPassId id) const {
   return RenderPassId(0, 0);
 }
 
 ResourceProvider::ResourceId LayerImpl::ContentsResourceId() const {
   NOTREACHED();
   return 0;
 }
 
-void LayerImpl::SetSentScrollDelta(const gfx::Vector2d& sent_scroll_delta) {
+void LayerImpl::SetSentScrollDelta(const gfx::Vector2dF& sent_scroll_delta) {
   // Pending tree never has sent scroll deltas
   DCHECK(layer_tree_impl()->IsActiveTree());
 
   if (sent_scroll_delta_ == sent_scroll_delta)
     return;
 
   sent_scroll_delta_ = sent_scroll_delta;
 }
 
 gfx::Vector2dF LayerImpl::ScrollBy(const gfx::Vector2dF& scroll) {
   DCHECK(scrollable());
-  gfx::Vector2dF min_delta = -scroll_offset_;
-  gfx::Vector2dF max_delta = MaxScrollOffset() - scroll_offset_;
+  gfx::Vector2dF min_delta = -ScrollOffsetToVector2dF(scroll_offset_);
+  gfx::Vector2dF max_delta =
+      ScrollOffsetToVector2dF(MaxScrollOffset() - scroll_offset_);
   // Clamp new_delta so that position + delta stays within scroll bounds.
   gfx::Vector2dF new_delta = (ScrollDelta() + scroll);
   new_delta.SetToMax(min_delta);
   new_delta.SetToMin(max_delta);
   gfx::Vector2dF unscrolled =
       ScrollDelta() + scroll - new_delta;
   SetScrollDelta(new_delta);
 
   return unscrolled;
 }
@@ skipping 10 matching lines @@
   // main thread had applied them and then committed those values.
   //
   // This function should not change the total scroll offset; it just shifts
   // some of the scroll delta to the scroll offset.  Therefore, adjust these
   // variables directly rather than calling the scroll offset delegate to
   // avoid sending it multiple spurious calls.
   //
   // Because of the way scroll delta is calculated with a delegate, this will
   // leave the total scroll offset unchanged on this layer regardless of
   // whether a delegate is being used.
-  scroll_offset_ += sent_scroll_delta_;
+  scroll_offset_ += gfx::ScrollOffset(sent_scroll_delta_);
   scroll_delta_ -= sent_scroll_delta_;
-  sent_scroll_delta_ = gfx::Vector2d();
+  sent_scroll_delta_ = gfx::Vector2dF();
 }
 
 void LayerImpl::ApplyScrollDeltasSinceBeginMainFrame() {
   // Only the pending tree can have missing scrolls.
   DCHECK(layer_tree_impl()->IsPendingTree());
   if (!scrollable())
     return;
 
   // Pending tree should never have sent scroll deltas.
   DCHECK(sent_scroll_delta().IsZero());
@@ skipping 51 matching lines @@
   if (type == InputHandler::Wheel && have_wheel_event_handlers()) {
     TRACE_EVENT0("cc", "LayerImpl::tryScroll: Failed WheelEventHandlers");
     return InputHandler::ScrollOnMainThread;
   }
 
   if (!scrollable()) {
     TRACE_EVENT0("cc", "LayerImpl::tryScroll: Ignored not scrollable");
     return InputHandler::ScrollIgnored;
   }
 
-  gfx::Vector2d max_scroll_offset = MaxScrollOffset();
+  gfx::ScrollOffset max_scroll_offset = MaxScrollOffset();
   if (max_scroll_offset.x() <= 0 && max_scroll_offset.y() <= 0) {
     TRACE_EVENT0("cc",
                  "LayerImpl::tryScroll: Ignored. Technically scrollable,"
                  " but has no affordance in either direction.");
     return InputHandler::ScrollIgnored;
   }
 
   return InputHandler::ScrollStarted;
 }
 
@@ skipping 45 matching lines @@
   layer->SetPositionConstraint(position_constraint_);
   layer->SetShouldFlattenTransform(should_flatten_transform_);
   layer->SetUseParentBackfaceVisibility(use_parent_backface_visibility_);
   layer->SetTransformAndInvertibility(transform_, transform_is_invertible_);
 
   layer->SetScrollClipLayer(scroll_clip_layer_ ? scroll_clip_layer_->id()
                                                : Layer::INVALID_ID);
   layer->set_user_scrollable_horizontal(user_scrollable_horizontal_);
   layer->set_user_scrollable_vertical(user_scrollable_vertical_);
   layer->SetScrollOffsetAndDelta(
-      scroll_offset_, layer->ScrollDelta() - layer->sent_scroll_delta());
-  layer->SetSentScrollDelta(gfx::Vector2d());
+      scroll_offset_,
+      layer->ScrollDelta() - layer->sent_scroll_delta());
+  layer->SetSentScrollDelta(gfx::Vector2dF());
   layer->Set3dSortingContextId(sorting_context_id_);
   layer->SetNumDescendantsThatDrawContent(num_descendants_that_draw_content_);
 
   LayerImpl* scroll_parent = NULL;
   if (scroll_parent_) {
     scroll_parent = layer->layer_tree_impl()->LayerById(scroll_parent_->id());
     DCHECK(scroll_parent);
   }
 
   layer->SetScrollParent(scroll_parent);
@@ skipping 176 matching lines @@
     replica_layer_->ResetAllChangeTrackingForSubtree();
   }
 
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->ResetAllChangeTrackingForSubtree();
 
   needs_push_properties_ = false;
   num_dependents_need_push_properties_ = 0;
 }
 
-gfx::Vector2dF LayerImpl::ScrollOffsetForAnimation() const {
+gfx::ScrollOffset LayerImpl::ScrollOffsetForAnimation() const {
   return TotalScrollOffset();
 }
 
 void LayerImpl::OnFilterAnimated(const FilterOperations& filters) {
   SetFilters(filters);
 }
 
 void LayerImpl::OnOpacityAnimated(float opacity) {
   SetOpacity(opacity);
 }
 
 void LayerImpl::OnTransformAnimated(const gfx::Transform& transform) {
   SetTransform(transform);
 }
 
-void LayerImpl::OnScrollOffsetAnimated(const gfx::Vector2dF& scroll_offset) {
+void LayerImpl::OnScrollOffsetAnimated(const gfx::ScrollOffset& scroll_offset) {
   // Only layers in the active tree should need to do anything here, since
   // layers in the pending tree will find out about these changes as a
   // result of the call to SetScrollDelta.
   if (!IsActive())
     return;
 
-  SetScrollDelta(scroll_offset - scroll_offset_);
+  SetScrollDelta(ScrollOffsetToVector2dF(scroll_offset - scroll_offset_));
 
   layer_tree_impl_->DidAnimateScrollOffset();
 }
 
 void LayerImpl::OnAnimationWaitingForDeletion() {}
 
 bool LayerImpl::IsActive() const {
   return layer_tree_impl_->IsActiveTree();
 }
 
@@ skipping 284 matching lines @@
   draw_properties_.contents_scale_x = contents_scale_x;
   draw_properties_.contents_scale_y = contents_scale_y;
   NoteLayerPropertyChanged();
 }
 
 void LayerImpl::SetScrollOffsetDelegate(
     ScrollOffsetDelegate* scroll_offset_delegate) {
   // Having both a scroll parent and a scroll offset delegate is unsupported.
   DCHECK(!scroll_parent_);
   if (!scroll_offset_delegate && scroll_offset_delegate_) {
-    scroll_delta_ =
-        scroll_offset_delegate_->GetTotalScrollOffset() - scroll_offset_;
+    scroll_delta_ = ScrollOffsetToVector2dF(
+        scroll_offset_delegate_->GetTotalScrollOffset() - scroll_offset_);
   }
-  gfx::Vector2dF total_offset = TotalScrollOffset();
+  gfx::ScrollOffset total_offset = TotalScrollOffset();
   scroll_offset_delegate_ = scroll_offset_delegate;
   if (scroll_offset_delegate_)
     scroll_offset_delegate_->SetTotalScrollOffset(total_offset);
 }
 
 bool LayerImpl::IsExternalFlingActive() const {
   return scroll_offset_delegate_ &&
          scroll_offset_delegate_->IsExternalFlingActive();
 }
 
-void LayerImpl::SetScrollOffset(const gfx::Vector2d& scroll_offset) {
+void LayerImpl::SetScrollOffset(const gfx::ScrollOffset& scroll_offset) {
   SetScrollOffsetAndDelta(scroll_offset, ScrollDelta());
 }
 
-void LayerImpl::SetScrollOffsetAndDelta(const gfx::Vector2d& scroll_offset,
+void LayerImpl::SetScrollOffsetAndDelta(const gfx::ScrollOffset& scroll_offset,
                                         const gfx::Vector2dF& scroll_delta) {
   bool changed = false;
 
   last_scroll_offset_ = scroll_offset;
 
   if (scroll_offset_ != scroll_offset) {
     changed = true;
     scroll_offset_ = scroll_offset;
 
     if (scroll_offset_delegate_)
@@ skipping 10 matching lines @@
         // layer.  Although the delta - sent scroll delta difference is
         // identical for both twins, the sent scroll delta for the pending
         // layer is zero, as anything that has been sent has been baked
         // into the layer's position/scroll offset as a part of commit.
         DCHECK(pending_twin->sent_scroll_delta().IsZero());
         pending_twin->SetScrollDelta(scroll_delta - sent_scroll_delta());
       }
     }
 
     if (scroll_offset_delegate_) {
-      scroll_offset_delegate_->SetTotalScrollOffset(scroll_offset_ +
-                                                    scroll_delta);
+      scroll_offset_delegate_->SetTotalScrollOffset(
+          ScrollOffsetWithDelta(scroll_offset_, scroll_delta));
     } else {
       scroll_delta_ = scroll_delta;
     }
   }
 
   if (changed) {
     NoteLayerPropertyChangedForSubtree();
     ScrollbarParametersDidChange();
   }
 }
 
 gfx::Vector2dF LayerImpl::ScrollDelta() const {
-  if (scroll_offset_delegate_)
-    return scroll_offset_delegate_->GetTotalScrollOffset() - scroll_offset_;
+  if (scroll_offset_delegate_) {
+    return ScrollOffsetToVector2dF(
+        scroll_offset_delegate_->GetTotalScrollOffset() - scroll_offset_);
+  }
   return scroll_delta_;
 }
 
 void LayerImpl::SetScrollDelta(const gfx::Vector2dF& scroll_delta) {
   SetScrollOffsetAndDelta(scroll_offset_, scroll_delta);
 }
 
-gfx::Vector2dF LayerImpl::TotalScrollOffset() const {
-  return scroll_offset_ + ScrollDelta();
+gfx::ScrollOffset LayerImpl::TotalScrollOffset() const {
+  return ScrollOffsetWithDelta(scroll_offset_, ScrollDelta());
 }
 
 void LayerImpl::SetDoubleSided(bool double_sided) {
   if (double_sided_ == double_sided)
     return;
 
   double_sided_ = double_sided;
   NoteLayerPropertyChangedForSubtree();
 }
 
 SimpleEnclosedRegion LayerImpl::VisibleContentOpaqueRegion() const {
   if (contents_opaque())
     return SimpleEnclosedRegion(visible_content_rect());
   return SimpleEnclosedRegion();
 }
 
 void LayerImpl::DidBeginTracing() {}
 
 void LayerImpl::ReleaseResources() {}
 
-gfx::Vector2d LayerImpl::MaxScrollOffset() const {
+gfx::ScrollOffset LayerImpl::MaxScrollOffset() const {
   if (!scroll_clip_layer_ || bounds().IsEmpty())
-    return gfx::Vector2d();
+    return gfx::ScrollOffset();
 
   LayerImpl const* page_scale_layer = layer_tree_impl()->page_scale_layer();
   DCHECK(this != page_scale_layer);
   DCHECK(this != layer_tree_impl()->InnerViewportScrollLayer() ||
          IsContainerForFixedPositionLayers());
 
   gfx::SizeF scaled_scroll_bounds(bounds());
 
   float scale_factor = 1.f;
   for (LayerImpl const* current_layer = this;
@@ skipping 21 matching lines @@
   // turned on in all builds, remove the next two lines. For now however, the
   // page scale layer may coincide with the clip layer, and so this is
   // necessary.
   if (page_scale_layer == scroll_clip_layer_)
     scale_factor *= layer_tree_impl()->total_page_scale_factor();
 
   scaled_scroll_bounds.SetSize(scale_factor * scaled_scroll_bounds.width(),
                                scale_factor * scaled_scroll_bounds.height());
   scaled_scroll_bounds = gfx::ToFlooredSize(scaled_scroll_bounds);
 
-  gfx::Vector2dF max_offset(
+  gfx::ScrollOffset max_offset(
       scaled_scroll_bounds.width() - scroll_clip_layer_->bounds().width(),
       scaled_scroll_bounds.height() - scroll_clip_layer_->bounds().height());
   // We need the final scroll offset to be in CSS coords.
   max_offset.Scale(1 / scale_factor);
-  max_offset.SetToMax(gfx::Vector2dF());
-  return gfx::ToFlooredVector2d(max_offset);
+  max_offset.SetToMax(gfx::ScrollOffset());
+  return max_offset;
 }
 
 gfx::Vector2dF LayerImpl::ClampScrollToMaxScrollOffset() {
-  gfx::Vector2dF max_offset = MaxScrollOffset();
-  gfx::Vector2dF old_offset = TotalScrollOffset();
-  gfx::Vector2dF clamped_offset = old_offset;
+  gfx::ScrollOffset max_offset = MaxScrollOffset();
+  gfx::ScrollOffset old_offset = TotalScrollOffset();
+  gfx::ScrollOffset clamped_offset = old_offset;
 
   clamped_offset.SetToMin(max_offset);
-  clamped_offset.SetToMax(gfx::Vector2d());
-  gfx::Vector2dF delta = clamped_offset - old_offset;
+  clamped_offset.SetToMax(gfx::ScrollOffset());
+  gfx::Vector2dF delta = ScrollOffsetToVector2dF(clamped_offset - old_offset);
   if (!delta.IsZero())
     ScrollBy(delta);
 
   return delta;
 }
 
 void LayerImpl::SetScrollbarPosition(ScrollbarLayerImplBase* scrollbar_layer,
                                      LayerImpl* scrollbar_clip_layer) const {
   DCHECK(scrollbar_layer);
   LayerImpl* page_scale_layer = layer_tree_impl()->page_scale_layer();
 
   DCHECK(this != page_scale_layer);
   DCHECK(scrollbar_clip_layer);
   DCHECK(this != layer_tree_impl()->InnerViewportScrollLayer() ||
          IsContainerForFixedPositionLayers());
   gfx::RectF clip_rect(gfx::PointF(), scrollbar_clip_layer->bounds());
 
   // See comment in MaxScrollOffset() regarding the use of the content layer
   // bounds here.
   gfx::RectF scroll_rect(gfx::PointF(), bounds());
 
   if (scroll_rect.size().IsEmpty())
     return;
 
   // TODO(wjmaclean) This computation is nearly identical to the one in
   // MaxScrollOffset. Find some way to combine these.
-  gfx::Vector2dF current_offset;
+  gfx::ScrollOffset current_offset;
   for (LayerImpl const* current_layer = this;
        current_layer != scrollbar_clip_layer;
        current_layer = current_layer->parent()) {
     DCHECK(current_layer);
     const gfx::Transform& layer_transform = current_layer->transform();
     if (current_layer == page_scale_layer) {
       DCHECK(layer_transform.IsIdentity());
       float scale_factor = layer_tree_impl()->total_page_scale_factor();
       current_offset.Scale(scale_factor);
       scroll_rect.Scale(scale_factor);
     } else {
       DCHECK(layer_transform.IsScale2d());
       gfx::Vector2dF layer_scale = layer_transform.Scale2d();
       DCHECK(layer_scale.x() == layer_scale.y());
-      gfx::Vector2dF new_offset =
-          current_layer->scroll_offset() + current_layer->ScrollDelta();
+      gfx::ScrollOffset new_offset = ScrollOffsetWithDelta(
+          current_layer->scroll_offset(), current_layer->ScrollDelta());
       new_offset.Scale(layer_scale.x(), layer_scale.y());
       current_offset += new_offset;
     }
   }
   // TODO(wjmaclean) Once we move to a model where the two-viewport model is
   // turned on in all builds, remove the next two lines. For now however, the
   // page scale layer may coincide with the clip layer, and so this is
   // necessary.
   if (page_scale_layer == scrollbar_clip_layer) {
     scroll_rect.Scale(layer_tree_impl()->total_page_scale_factor());
@@ skipping 274 matching lines @@
 }
 
 void LayerImpl::NotifyAnimationFinished(
     base::TimeTicks monotonic_time,
     Animation::TargetProperty target_property) {
   if (target_property == Animation::ScrollOffset)
     layer_tree_impl_->InputScrollAnimationFinished();
 }
 
 }  // namespace cc