Make scroll offset type of float in cc

cc/trees/layer_tree_host_impl.cc

 // 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.
 
 #include "cc/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
@@ skipping 415 matching lines @@
 }
 
 void LayerTreeHostImpl::StartPageScaleAnimation(
     const gfx::Vector2d& target_offset,
     bool anchor_point,
     float page_scale,
     base::TimeDelta duration) {
   if (!InnerViewportScrollLayer())
     return;
 
-  gfx::Vector2dF scroll_total = active_tree_->TotalScrollOffset();
+  gfx::ScrollOffset scroll_total = active_tree_->TotalScrollOffset();
   gfx::SizeF scaled_scrollable_size = active_tree_->ScrollableSize();
   gfx::SizeF viewport_size =
       active_tree_->InnerViewportContainerLayer()->bounds();
 
   // Easing constants experimentally determined.
   scoped_ptr<TimingFunction> timing_function =
       CubicBezierTimingFunction::Create(.8, 0, .3, .9).PassAs<TimingFunction>();
 
   page_scale_animation_ =
-      PageScaleAnimation::Create(scroll_total,
+      PageScaleAnimation::Create(scroll_total.ToVector2dF(),

[danakj, 2014/09/25 22:01:27]

TODO to pass a ScrollOffset?

[Yufeng Shen (Slow to review), 2014/09/26 20:19:08]

Done.

                                  active_tree_->total_page_scale_factor(),
                                  viewport_size,
                                  scaled_scrollable_size,
                                  timing_function.Pass());
 
   if (anchor_point) {
     gfx::Vector2dF anchor(target_offset);
     page_scale_animation_->ZoomWithAnchor(anchor,
                                           page_scale,
                                           duration.InSecondsF());
@@ skipping 1019 matching lines @@
     metadata.location_bar_content_translation =
         gfx::Vector2dF(0.f, top_controls_manager_->ContentTopOffset());
   }
 
   active_tree_->GetViewportSelection(&metadata.selection_start,
                                      &metadata.selection_end);
 
   if (!InnerViewportScrollLayer())
     return metadata;
 
-  metadata.root_scroll_offset = active_tree_->TotalScrollOffset();
+  metadata.root_scroll_offset = active_tree_->TotalScrollOffset().ToVector2dF();

[danakj, 2014/09/25 22:01:27]

TODO to change the IPC to hold a ScrollOffset?

[Yufeng Shen (Slow to review), 2014/09/26 20:19:08]

Done.

 
   return metadata;
 }
 
 static void LayerTreeHostImplDidBeginTracingCallback(LayerImpl* layer) {
   layer->DidBeginTracing();
 }
 
 void LayerTreeHostImpl::DrawLayers(FrameData* frame,
                                    base::TimeTicks frame_begin_time) {
@@ skipping 871 matching lines @@
   if (LayerImpl* layer_impl = CurrentlyScrollingLayer()) {
     Animation* animation =
         layer_impl->layer_animation_controller()->GetAnimation(
             Animation::ScrollOffset);
     if (!animation)
       return ScrollIgnored;
 
     ScrollOffsetAnimationCurve* curve =
         animation->curve()->ToScrollOffsetAnimationCurve();
 
     gfx::Vector2dF new_target = curve->target_value() + scroll_delta;

[danakj, 2014/09/25 22:01:27]

target_value should be a ScrollOffset? So a bunch of things here should be?

[Yufeng Shen (Slow to review), 2014/09/26 20:19:08]

Done.

     new_target.SetToMax(gfx::Vector2dF());
-    new_target.SetToMin(layer_impl->MaxScrollOffset());
+    new_target.SetToMin(layer_impl->MaxScrollOffset().ToVector2dF());
 
     curve->UpdateTarget(animation->TrimTimeToCurrentIteration(
                             CurrentBeginFrameArgs().frame_time),
                         new_target);

[danakj, 2014/09/25 22:01:27]

UpdateTarget should be a ScrollOffset?

[Yufeng Shen (Slow to review), 2014/09/26 20:19:07]

Done.

 
     return ScrollStarted;
   }
   // ScrollAnimated is only used for wheel scrolls. We use the same bubbling
   // behavior as ScrollBy to determine which layer to animate, but we do not
   // do the Android-specific things in ScrollBy like showing top controls.
   InputHandler::ScrollStatus scroll_status = ScrollBegin(viewport_point, Wheel);
   if (scroll_status == ScrollStarted) {
     gfx::Vector2dF pending_delta = scroll_delta;
     for (LayerImpl* layer_impl = CurrentlyScrollingLayer(); layer_impl;
          layer_impl = layer_impl->parent()) {
       if (!layer_impl->scrollable())
         continue;
 
-      gfx::Vector2dF current_offset = layer_impl->TotalScrollOffset();
-      gfx::Vector2dF target_offset = current_offset + pending_delta;
-      target_offset.SetToMax(gfx::Vector2dF());
+      gfx::ScrollOffset current_offset = layer_impl->TotalScrollOffset();
+      gfx::ScrollOffset target_offset =
+          current_offset + gfx::ScrollOffset(pending_delta);
+      target_offset.SetToMax(gfx::ScrollOffset());
       target_offset.SetToMin(layer_impl->MaxScrollOffset());
-      gfx::Vector2dF actual_delta = target_offset - current_offset;
+      gfx::Vector2dF actual_delta =
+          (target_offset - current_offset).ToVector2dF();
 
       const float kEpsilon = 0.1f;
       bool can_layer_scroll = (std::abs(actual_delta.x()) > kEpsilon ||
                                std::abs(actual_delta.y()) > kEpsilon);
 
       if (!can_layer_scroll) {
         layer_impl->ScrollBy(actual_delta);
         pending_delta -= actual_delta;
         continue;
       }
 
       active_tree_->SetCurrentlyScrollingLayer(layer_impl);
 
       scoped_ptr<ScrollOffsetAnimationCurve> curve =
-          ScrollOffsetAnimationCurve::Create(target_offset,
+          ScrollOffsetAnimationCurve::Create(target_offset.ToVector2dF(),

[danakj, 2014/09/25 22:01:26]

should just pass a ScrollOffset?

[Yufeng Shen (Slow to review), 2014/09/26 20:19:08]

Done.

                                              EaseInOutTimingFunction::Create());
-      curve->SetInitialValue(current_offset);
+      curve->SetInitialValue(current_offset.ToVector2dF());

[danakj, 2014/09/25 22:01:27]

and here?

[Yufeng Shen (Slow to review), 2014/09/26 20:19:08]

Done.

 
       scoped_ptr<Animation> animation =
           Animation::Create(curve.PassAs<AnimationCurve>(),
                             AnimationIdProvider::NextAnimationId(),
                             AnimationIdProvider::NextGroupId(),
                             Animation::ScrollOffset);
       animation->set_is_impl_only(true);
 
       layer_impl->layer_animation_controller()->AddAnimation(animation.Pass());
 
@@ skipping 183 matching lines @@
       active_tree_->SetCurrentlyScrollingLayer(layer_impl);
       break;
     }
 
     // If the applied delta is within 45 degrees of the input delta, bail out to
     // make it easier to scroll just one layer in one direction without
     // affecting any of its parents.
     float angle_threshold = 45;
     if (MathUtil::SmallestAngleBetweenVectors(
             applied_delta, pending_delta) < angle_threshold) {
-      pending_delta = gfx::Vector2d();
+      pending_delta = gfx::Vector2dF();
       break;
     }
 
     // Allow further movement only on an axis perpendicular to the direction in
     // which the layer moved.
     gfx::Vector2dF perpendicular_axis(-applied_delta.y(), applied_delta.x());
     pending_delta = MathUtil::ProjectVector(pending_delta, perpendicular_axis);
 
     if (gfx::ToRoundedVector2d(pending_delta).IsZero())
       break;
@@ skipping 239 matching lines @@
   page_scale_delta = active_tree_->page_scale_delta();
   gfx::PointF new_scale_anchor =
       gfx::ScalePoint(anchor, 1.f / page_scale_delta);
   gfx::Vector2dF move = previous_scale_anchor - new_scale_anchor;
 
   previous_pinch_anchor_ = anchor;
 
   move.Scale(1 / active_tree_->page_scale_factor());
   // If clamping the inner viewport scroll offset causes a change, it should
   // be accounted for from the intended move.
-  move -= InnerViewportScrollLayer()->ClampScrollToMaxScrollOffset();
+  gfx::ScrollOffset max_offset =

[danakj, 2014/09/25 22:01:26]

This would become Vector2dF based on other comments

[Yufeng Shen (Slow to review), 2014/09/26 20:19:08]

Done.

+      InnerViewportScrollLayer()->ClampScrollToMaxScrollOffset();
+  move -= max_offset.ToVector2dF();
 
   // We manually manage the bubbling behaviour here as it is different to that
   // implemented in LayerTreeHostImpl::ScrollBy(). Specifically:
   // 1) we want to explicit limit the bubbling to the outer/inner viewports,
   // 2) we don't want the directional limitations on the unused parts that
   //    ScrollBy() implements, and
   // 3) pinching should not engage the top controls manager.
   gfx::Vector2dF unused = OuterViewportScrollLayer()
                               ? OuterViewportScrollLayer()->ScrollBy(move)
                               : move;
@@ skipping 20 matching lines @@
   if (top_controls_manager_)
     top_controls_manager_->PinchEnd();
   client_->SetNeedsCommitOnImplThread();
 }
 
 static void CollectScrollDeltas(ScrollAndScaleSet* scroll_info,
                                 LayerImpl* layer_impl) {
   if (!layer_impl)
     return;
 
-  gfx::Vector2d scroll_delta =
-      gfx::ToFlooredVector2d(layer_impl->ScrollDelta());
+  gfx::Vector2dF scroll_delta = layer_impl->ScrollDelta();
   if (!scroll_delta.IsZero()) {
     LayerTreeHostCommon::ScrollUpdateInfo scroll;
     scroll.layer_id = layer_impl->id();
     scroll.scroll_delta = scroll_delta;
     scroll_info->scrolls.push_back(scroll);
     layer_impl->SetSentScrollDelta(scroll_delta);
   }
 
   for (size_t i = 0; i < layer_impl->children().size(); ++i)
     CollectScrollDeltas(scroll_info, layer_impl->children()[i]);
@@ skipping 25 matching lines @@
   gfx::Vector2dF unused_delta = scroll_layer->ScrollBy(scroll_delta);
 
   if (!unused_delta.IsZero() && (scroll_layer == OuterViewportScrollLayer()))
     InnerViewportScrollLayer()->ScrollBy(unused_delta);
 }
 
 void LayerTreeHostImpl::AnimatePageScale(base::TimeTicks monotonic_time) {
   if (!page_scale_animation_)
     return;
 
-  gfx::Vector2dF scroll_total = active_tree_->TotalScrollOffset();
+  gfx::ScrollOffset scroll_total = active_tree_->TotalScrollOffset();
 
   if (!page_scale_animation_->IsAnimationStarted())
     page_scale_animation_->StartAnimation(monotonic_time);
 
   active_tree_->SetPageScaleDelta(
       page_scale_animation_->PageScaleFactorAtTime(monotonic_time) /
       active_tree_->page_scale_factor());
   gfx::Vector2dF next_scroll =

[danakj, 2014/09/25 22:01:27]

ScrollOffset

[Yufeng Shen (Slow to review), 2014/09/26 20:19:07]

Done.

       page_scale_animation_->ScrollOffsetAtTime(monotonic_time);
 
-  ScrollViewportBy(next_scroll - scroll_total);
+  ScrollViewportBy(next_scroll - scroll_total.ToVector2dF());

[danakj, 2014/09/25 22:01:26]

convert after subtracting

[Yufeng Shen (Slow to review), 2014/09/26 20:19:08]

Done.

   SetNeedsRedraw();
 
   if (page_scale_animation_->IsAnimationCompleteAtTime(monotonic_time)) {
     page_scale_animation_.reset();
     client_->SetNeedsCommitOnImplThread();
     client_->RenewTreePriority();
   } else {
     SetNeedsAnimate();
   }
 }
@@ skipping 389 matching lines @@
 }
 
 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
   std::vector<PictureLayerImpl*>::iterator it =
       std::find(picture_layers_.begin(), picture_layers_.end(), layer);
   DCHECK(it != picture_layers_.end());
   picture_layers_.erase(it);
 }
 
 }  // namespace cc