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) {
@@ skipping 25 matching lines @@
   // 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_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 118 matching lines @@
   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());
+  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 518 matching lines @@
   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::Vector2dF& scroll_offset) {
   SetScrollOffsetAndDelta(scroll_offset, ScrollDelta());
 }
 
-void LayerImpl::SetScrollOffsetAndDelta(const gfx::Vector2d& scroll_offset,
+void LayerImpl::SetScrollOffsetAndDelta(const gfx::Vector2dF& 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 444 matching lines @@
 }
 
 void LayerImpl::NotifyAnimationFinished(
     base::TimeTicks monotonic_time,
     Animation::TargetProperty target_property) {
   if (target_property == Animation::ScrollOffset)
     layer_tree_impl_->InputScrollAnimationFinished();
 }
 
 }  // namespace cc