Use float for scroll offset.

third_party/WebKit/Source/core/dom/Element.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Peter Kelly (pmk@post.com)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012, 2013 Apple Inc.
  * All rights reserved.
  *           (C) 2007 Eric Seidel (eric@webkit.org)
  *
@@ skipping 901 matching lines @@
   double top =
       scrollToOptions.hasTop()
           ? ScrollableArea::normalizeNonFiniteScroll(scrollToOptions.top())
           : 0.0;
 
   ScrollBehavior scrollBehavior = ScrollBehaviorAuto;
   ScrollableArea::scrollBehaviorFromString(scrollToOptions.behavior(),
                                            scrollBehavior);
   LayoutBox* box = layoutBox();
   if (box) {
-    double currentScaledLeft = box->scrollLeft();
-    double currentScaledTop = box->scrollTop();
-    double newScaledLeft =
+    float currentScaledLeft = box->scrollLeft().toFloat();
+    float currentScaledTop = box->scrollTop().toFloat();
+    float newScaledLeft =
         left * box->style()->effectiveZoom() + currentScaledLeft;
-    double newScaledTop =
-        top * box->style()->effectiveZoom() + currentScaledTop;
-    box->scrollToOffset(DoubleSize(newScaledLeft, newScaledTop),
-                        scrollBehavior);
+    float newScaledTop = top * box->style()->effectiveZoom() + currentScaledTop;
+    box->scrollToPosition(FloatPoint(newScaledLeft, newScaledTop),
+                          scrollBehavior);
   }
 }
 
 void Element::scrollLayoutBoxTo(const ScrollToOptions& scrollToOptions) {
   ScrollBehavior scrollBehavior = ScrollBehaviorAuto;
   ScrollableArea::scrollBehaviorFromString(scrollToOptions.behavior(),
                                            scrollBehavior);
 
   LayoutBox* box = layoutBox();
   if (box) {
-    double scaledLeft = box->scrollLeft();
-    double scaledTop = box->scrollTop();
+    float scaledLeft = box->scrollLeft().toFloat();
+    float scaledTop = box->scrollTop().toFloat();
     if (scrollToOptions.hasLeft())
       scaledLeft =
           ScrollableArea::normalizeNonFiniteScroll(scrollToOptions.left()) *
           box->style()->effectiveZoom();
     if (scrollToOptions.hasTop())
       scaledTop =
           ScrollableArea::normalizeNonFiniteScroll(scrollToOptions.top()) *
           box->style()->effectiveZoom();
-    box->scrollToOffset(DoubleSize(scaledLeft, scaledTop), scrollBehavior);
+    box->scrollToPosition(FloatPoint(scaledLeft, scaledTop), scrollBehavior);
   }
 }
 
 void Element::scrollFrameBy(const ScrollToOptions& scrollToOptions) {
   double left =
       scrollToOptions.hasLeft()
           ? ScrollableArea::normalizeNonFiniteScroll(scrollToOptions.left())
           : 0.0;
   double top =
       scrollToOptions.hasTop()
           ? ScrollableArea::normalizeNonFiniteScroll(scrollToOptions.top())
           : 0.0;
 
   ScrollBehavior scrollBehavior = ScrollBehaviorAuto;
   ScrollableArea::scrollBehaviorFromString(scrollToOptions.behavior(),
                                            scrollBehavior);
   LocalFrame* frame = document().frame();
   if (!frame)
     return;
   ScrollableArea* viewport =
       frame->view() ? frame->view()->getScrollableArea() : 0;
   if (!viewport)
     return;
 
-  double newScaledLeft =
-      left * frame->pageZoomFactor() + viewport->scrollPositionDouble().x();
-  double newScaledTop =
-      top * frame->pageZoomFactor() + viewport->scrollPositionDouble().y();
-  viewport->setScrollPosition(DoublePoint(newScaledLeft, newScaledTop),
-                              ProgrammaticScroll, scrollBehavior);
+  float newScaledLeft =
+      left * frame->pageZoomFactor() + viewport->scrollOffset().width();
+  float newScaledTop =
+      top * frame->pageZoomFactor() + viewport->scrollOffset().height();
+  viewport->setScrollOffset(ScrollOffset(newScaledLeft, newScaledTop),
+                            ProgrammaticScroll, scrollBehavior);
 }
 
 void Element::scrollFrameTo(const ScrollToOptions& scrollToOptions) {
   ScrollBehavior scrollBehavior = ScrollBehaviorAuto;
   ScrollableArea::scrollBehaviorFromString(scrollToOptions.behavior(),
                                            scrollBehavior);
   LocalFrame* frame = document().frame();
   if (!frame)
     return;
   ScrollableArea* viewport =
       frame->view() ? frame->view()->getScrollableArea() : 0;
   if (!viewport)
     return;
 
-  double scaledLeft = viewport->scrollPositionDouble().x();
-  double scaledTop = viewport->scrollPositionDouble().y();
+  float scaledLeft = viewport->scrollOffset().width();
+  float scaledTop = viewport->scrollOffset().height();
   if (scrollToOptions.hasLeft())
     scaledLeft =
         ScrollableArea::normalizeNonFiniteScroll(scrollToOptions.left()) *
         frame->pageZoomFactor();
   if (scrollToOptions.hasTop())
     scaledTop =
         ScrollableArea::normalizeNonFiniteScroll(scrollToOptions.top()) *
         frame->pageZoomFactor();
-  viewport->setScrollPosition(DoublePoint(scaledLeft, scaledTop),
-                              ProgrammaticScroll, scrollBehavior);
+  viewport->setScrollOffset(ScrollOffset(scaledLeft, scaledTop),
+                            ProgrammaticScroll, scrollBehavior);
 }
 
 bool Element::hasCompositorProxy() const {
   return hasRareData() && elementRareData()->proxiedPropertyCounts();
 }
 
 void Element::incrementCompositorProxiedProperties(uint32_t mutableProperties) {
   ElementRareData& rareData = ensureElementRareData();
   if (!rareData.proxiedPropertyCounts())
     setNeedsStyleRecalc(LocalStyleChange,
@@ skipping 585 matching lines @@
               false);
     }
   }
 
   if (Fullscreen* fullscreen = Fullscreen::fromIfExists(document()))
     fullscreen->elementRemoved(*this);
 
   if (document().page())
     document().page()->pointerLockController().elementRemoved(this);
 
-  setSavedLayerScrollOffset(IntSize());
+  setSavedLayerScrollOffset(ScrollOffset());
 
   if (insertionPoint->isInTreeScope() && treeScope() == document()) {
     const AtomicString& idValue = getIdAttribute();
     if (!idValue.isNull())
       updateId(insertionPoint->treeScope(), idValue, nullAtom);
 
     const AtomicString& nameValue = getNameAttribute();
     if (!nameValue.isNull())
       updateName(nameValue, nullAtom);
   }
@@ skipping 1986 matching lines @@
     toHTMLDocument(document()).removeExtraNamedItem(oldId);
 
   if (!newId.isEmpty())
     toHTMLDocument(document()).addExtraNamedItem(newId);
 }
 
 void Element::scheduleSVGFilterLayerUpdateHack() {
   document().scheduleSVGFilterLayerUpdateHack(*this);
 }
 
-IntSize Element::savedLayerScrollOffset() const {
+ScrollOffset Element::savedLayerScrollOffset() const {
   return hasRareData() ? elementRareData()->savedLayerScrollOffset()
-                       : IntSize();
+                       : ScrollOffset();
 }
 
-void Element::setSavedLayerScrollOffset(const IntSize& size) {
+void Element::setSavedLayerScrollOffset(const ScrollOffset& size) {
   if (size.isZero() && !hasRareData())
     return;
   ensureElementRareData().setSavedLayerScrollOffset(size);
 }
 
 Attr* Element::attrIfExists(const QualifiedName& name) {
   if (AttrNodeList* attrNodeList = this->attrNodeList()) {
     bool shouldIgnoreCase = shouldIgnoreAttributeCase();
     for (const auto& attr : *attrNodeList) {
       if (attr->getQualifiedName().matchesPossiblyIgnoringCase(
@@ skipping 448 matching lines @@
 }
 
 DEFINE_TRACE_WRAPPERS(Element) {
   if (hasRareData()) {
     visitor->traceWrappers(elementRareData());
   }
   ContainerNode::traceWrappers(visitor);
 }
 
 }  // namespace blink