Make scroll offset type of float in cc

cc/layers/layer_impl.cc

Index: cc/layers/layer_impl.cc
diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc
index 5c9eada05addd2181ad8ea1a5d9a46a83d15bff2..d50c64f0b15fde73d4d10e2365b1b886e046455a 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc
@@ -354,7 +354,7 @@ ResourceProvider::ResourceId LayerImpl::ContentsResourceId() const {
   return 0;
 }
 
-void LayerImpl::SetSentScrollDelta(const gfx::Vector2d& sent_scroll_delta) {
+void LayerImpl::SetSentScrollDelta(const gfx::ScrollOffset& sent_scroll_delta) {
   // Pending tree never has sent scroll deltas
   DCHECK(layer_tree_impl()->IsActiveTree());
 
@@ -366,8 +366,8 @@ void LayerImpl::SetSentScrollDelta(const gfx::Vector2d& 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 = -ToVector2dF(scroll_offset_);
+  gfx::Vector2dF max_delta = MaxScrollOffset() - ToVector2dF(scroll_offset_);

[danakj, 2014/09/25 15:13:30]

to ToVector2dF after the subtraction - MaxScrollOffset should be a ScrollOffset
type..

[Yufeng Shen (Slow to review), 2014/09/25 20:06:23]

Done.

   // Clamp new_delta so that position + delta stays within scroll bounds.
   gfx::Vector2dF new_delta = (ScrollDelta() + scroll);
   new_delta.SetToMax(min_delta);
@@ -399,8 +399,8 @@ void LayerImpl::ApplySentScrollDeltasFromAbortedCommit() {
   // leave the total scroll offset unchanged on this layer regardless of
   // whether a delegate is being used.
   scroll_offset_ += sent_scroll_delta_;
-  scroll_delta_ -= sent_scroll_delta_;
-  sent_scroll_delta_ = gfx::Vector2d();
+  scroll_delta_ -= ToVector2dF(sent_scroll_delta_);
+  sent_scroll_delta_ = gfx::ScrollOffset();
 }
 
 void LayerImpl::ApplyScrollDeltasSinceBeginMainFrame() {
@@ -418,7 +418,7 @@ void LayerImpl::ApplyScrollDeltasSinceBeginMainFrame() {
     // comes from) and commit need to be applied to the pending tree
     // so that it is up to date with the total scroll.
     SetScrollDelta(active_twin->ScrollDelta() -
-                   active_twin->sent_scroll_delta());
+                   ToVector2dF(active_twin->sent_scroll_delta()));
   }
 }
 
@@ -538,8 +538,9 @@ void LayerImpl::PushPropertiesTo(LayerImpl* layer) {
   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() - ToVector2dF(layer->sent_scroll_delta()));
+  layer->SetSentScrollDelta(gfx::ScrollOffset());
   layer->Set3dSortingContextId(sorting_context_id_);
   layer->SetNumDescendantsThatDrawContent(num_descendants_that_draw_content_);
 
@@ -759,7 +760,7 @@ void LayerImpl::OnScrollOffsetAnimated(const gfx::Vector2dF& scroll_offset) {
   if (!IsActive())
     return;
 
-  SetScrollDelta(scroll_offset - scroll_offset_);
+  SetScrollDelta(scroll_offset - ToVector2dF(scroll_offset_));
 
   layer_tree_impl_->DidAnimateScrollOffset();
 }
@@ -1064,8 +1065,8 @@ void LayerImpl::SetScrollOffsetDelegate(
   // 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_ = scroll_offset_delegate_->GetTotalScrollOffset() -
+                    ToVector2dF(scroll_offset_);
   }
   gfx::Vector2dF total_offset = TotalScrollOffset();
   scroll_offset_delegate_ = scroll_offset_delegate;
@@ -1078,15 +1079,15 @@ bool LayerImpl::IsExternalFlingActive() const {
          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;
+  last_scroll_offset_ = ToVector2dF(scroll_offset);
 
   if (scroll_offset_ != scroll_offset) {
     changed = true;
@@ -1108,13 +1109,14 @@ void LayerImpl::SetScrollOffsetAndDelta(const gfx::Vector2d& scroll_offset,
         // 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());
+        pending_twin->SetScrollDelta(scroll_delta -
+                                     ToVector2dF(sent_scroll_delta()));
       }
     }
 
     if (scroll_offset_delegate_) {
-      scroll_offset_delegate_->SetTotalScrollOffset(scroll_offset_ +
-                                                    scroll_delta);
+      scroll_offset_delegate_->SetTotalScrollOffset(
+          ToVector2dF(scroll_offset_) + scroll_delta);
     } else {
       scroll_delta_ = scroll_delta;
     }
@@ -1127,8 +1129,10 @@ void LayerImpl::SetScrollOffsetAndDelta(const gfx::Vector2d& scroll_offset,
 }
 
 gfx::Vector2dF LayerImpl::ScrollDelta() const {
-  if (scroll_offset_delegate_)
-    return scroll_offset_delegate_->GetTotalScrollOffset() - scroll_offset_;
+  if (scroll_offset_delegate_) {
+    return scroll_offset_delegate_->GetTotalScrollOffset() -
+           ToVector2dF(scroll_offset_);
+  }
   return scroll_delta_;
 }
 
@@ -1137,7 +1141,7 @@ void LayerImpl::SetScrollDelta(const gfx::Vector2dF& scroll_delta) {
 }
 
 gfx::Vector2dF LayerImpl::TotalScrollOffset() const {
-  return scroll_offset_ + ScrollDelta();
+  return ToVector2dF(scroll_offset_) + ScrollDelta();
 }
 
 void LayerImpl::SetDoubleSided(bool double_sided) {
@@ -1260,8 +1264,8 @@ void LayerImpl::SetScrollbarPosition(ScrollbarLayerImplBase* scrollbar_layer,
       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::Vector2dF new_offset = ToVector2dF(current_layer->scroll_offset()) +
+                                  current_layer->ScrollDelta();
       new_offset.Scale(layer_scale.x(), layer_scale.y());
       current_offset += new_offset;
     }