Revert platform and scrolling to ints
authoreae@chromium.org <eae@chromium.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 8 Nov 2011 02:11:06 +0000 (02:11 +0000)
committereae@chromium.org <eae@chromium.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 8 Nov 2011 02:11:06 +0000 (02:11 +0000)
https://bugs.webkit.org/show_bug.cgi?id=71585

Reviewed by Eric Seidel.

Replace all uses of LayoutUnit and related types with ints in platform
and scrolling code.

Source/WebCore:

No new tests.

* page/FrameView.cpp:
* page/FrameView.h:
* platform/PopupMenuClient.h:
* platform/ScrollAnimatorNone.cpp:
* platform/ScrollAnimatorNone.h:
* platform/ScrollView.cpp:
* platform/ScrollView.h:
* platform/ScrollableArea.h:
* rendering/RenderLayer.cpp:
* rendering/RenderLayer.h:
* rendering/RenderListBox.cpp:
* rendering/RenderListBox.h:
* rendering/RenderMenuList.cpp:
* rendering/RenderMenuList.h:
* rendering/RenderTextControlSingleLine.cpp:
* rendering/RenderTextControlSingleLine.h:

Source/WebKit/chromium:

* tests/ScrollAnimatorNoneTest.cpp:
(MockScrollableArea::visibleHeight):
(MockScrollableArea::visibleWidth):

Source/WebKit2:

* WebProcess/Plugins/PDF/BuiltInPDFView.cpp:
(WebKit::BuiltInPDFView::invalidateScrollbarRect):
(WebKit::BuiltInPDFView::visibleHeight):
(WebKit::BuiltInPDFView::visibleWidth):
* WebProcess/Plugins/PDF/BuiltInPDFView.h:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@99511 268f45cc-cd09-0410-ab3c-d52691b4dbfc

22 files changed:
Source/WebCore/ChangeLog
Source/WebCore/page/FrameView.cpp
Source/WebCore/page/FrameView.h
Source/WebCore/platform/PopupMenuClient.h
Source/WebCore/platform/ScrollAnimatorNone.cpp
Source/WebCore/platform/ScrollAnimatorNone.h
Source/WebCore/platform/ScrollView.cpp
Source/WebCore/platform/ScrollView.h
Source/WebCore/platform/ScrollableArea.h
Source/WebCore/rendering/RenderLayer.cpp
Source/WebCore/rendering/RenderLayer.h
Source/WebCore/rendering/RenderListBox.cpp
Source/WebCore/rendering/RenderListBox.h
Source/WebCore/rendering/RenderMenuList.cpp
Source/WebCore/rendering/RenderMenuList.h
Source/WebCore/rendering/RenderTextControlSingleLine.cpp
Source/WebCore/rendering/RenderTextControlSingleLine.h
Source/WebKit/chromium/ChangeLog
Source/WebKit/chromium/tests/ScrollAnimatorNoneTest.cpp
Source/WebKit2/ChangeLog
Source/WebKit2/WebProcess/Plugins/PDF/BuiltInPDFView.cpp
Source/WebKit2/WebProcess/Plugins/PDF/BuiltInPDFView.h

index 2cc285e..bac124d 100644 (file)
@@ -1,3 +1,32 @@
+2011-11-07  Emil A Eklund  <eae@chromium.org>
+
+        Revert platform and scrolling to ints
+        https://bugs.webkit.org/show_bug.cgi?id=71585
+
+        Reviewed by Eric Seidel.
+
+        Replace all uses of LayoutUnit and related types with ints in platform
+        and scrolling code.
+
+        No new tests.
+
+        * page/FrameView.cpp:
+        * page/FrameView.h:
+        * platform/PopupMenuClient.h:
+        * platform/ScrollAnimatorNone.cpp:
+        * platform/ScrollAnimatorNone.h:
+        * platform/ScrollView.cpp:
+        * platform/ScrollView.h:
+        * platform/ScrollableArea.h:
+        * rendering/RenderLayer.cpp:
+        * rendering/RenderLayer.h:
+        * rendering/RenderListBox.cpp:
+        * rendering/RenderListBox.h:
+        * rendering/RenderMenuList.cpp:
+        * rendering/RenderMenuList.h:
+        * rendering/RenderTextControlSingleLine.cpp:
+        * rendering/RenderTextControlSingleLine.h:
+
 2011-11-07  Kentaro Hara  <haraken@chromium.org>
 
         Fixed wrong test results of fast/js/custom-constructors.html
index ad10290..35770d0 100644 (file)
@@ -1357,15 +1357,15 @@ void FrameView::removeFixedObject()
         updateCanBlitOnScrollRecursively();
 }
 
-LayoutUnit FrameView::scrollXForFixedPosition() const
+int FrameView::scrollXForFixedPosition() const
 {
-    LayoutUnit visibleContentWidth = visibleContentRect().width();
-    LayoutUnit maxX = contentsWidth() - visibleContentWidth;
+    int visibleContentWidth = visibleContentRect().width();
+    int maxX = contentsWidth() - visibleContentWidth;
 
     if (maxX == 0)
         return 0;
 
-    LayoutUnit x = scrollX();
+    int x = scrollX();
 
     if (!scrollOrigin().x()) {
         if (x < 0)
@@ -1392,15 +1392,15 @@ LayoutUnit FrameView::scrollXForFixedPosition() const
     return x * dragFactor / frameScaleFactor;
 }
 
-LayoutUnit FrameView::scrollYForFixedPosition() const
+int FrameView::scrollYForFixedPosition() const
 {
-    LayoutUnit visibleContentHeight = visibleContentRect().height();
+    int visibleContentHeight = visibleContentRect().height();
 
-    LayoutUnit maxY = contentsHeight() - visibleContentHeight;
+    int maxY = contentsHeight() - visibleContentHeight;
     if (maxY == 0)
         return 0;
 
-    LayoutUnit y = scrollY();
+    int y = scrollY();
 
     if (!scrollOrigin().y()) {
         if (y < 0)
@@ -1423,12 +1423,12 @@ LayoutUnit FrameView::scrollYForFixedPosition() const
     return y * dragFactor / frameScaleFactor;
 }
 
-LayoutSize FrameView::scrollOffsetForFixedPosition() const
+IntSize FrameView::scrollOffsetForFixedPosition() const
 {
-    return LayoutSize(scrollXForFixedPosition(), scrollYForFixedPosition());
+    return IntSize(scrollXForFixedPosition(), scrollYForFixedPosition());
 }
 
-LayoutPoint FrameView::currentMousePosition() const
+IntPoint FrameView::currentMousePosition() const
 {
     return m_frame ? m_frame->eventHandler()->currentMousePosition() : IntPoint();
 }
index 2c02949..8113353 100644 (file)
@@ -27,6 +27,7 @@
 
 #include "AdjustViewSizeOrNot.h"
 #include "Color.h"
+#include "LayoutTypes.h"
 #include "PaintPhase.h"
 #include "ScrollView.h"
 #include <wtf/Forward.h>
@@ -64,8 +65,8 @@ public:
 
     virtual HostWindow* hostWindow() const;
     
-    virtual void invalidateRect(const LayoutRect&);
-    virtual void setFrameRect(const LayoutRect&);
+    virtual void invalidateRect(const IntRect&);
+    virtual void setFrameRect(const IntRect&);
 
 #if ENABLE(REQUEST_ANIMATION_FRAME)
     void scheduleAnimation();
@@ -88,7 +89,7 @@ public:
     virtual void didAddHorizontalScrollbar(Scrollbar*);
     virtual void willRemoveHorizontalScrollbar(Scrollbar*);
 
-    virtual void setContentsSize(const LayoutSize&);
+    virtual void setContentsSize(const IntSize&);
 
     void layout(bool allowSubtree = true);
     bool didFirstLayout() const;
@@ -166,7 +167,7 @@ public:
     virtual IntRect windowResizerRect() const;
 
     virtual void setFixedVisibleContentRect(const IntRect&) OVERRIDE;
-    void setScrollPosition(const LayoutPoint&);
+    void setScrollPosition(const IntPoint&);
     void scrollPositionChangedViaPlatformWidget();
     virtual void repaintFixedElementsAfterScrolling();
     virtual bool shouldRubberBandInDirection(ScrollDirection) const;
@@ -191,9 +192,9 @@ public:
 
     // Functions for querying the current scrolled position, negating the effects of overhang
     // and adjusting for page scale.
-    LayoutUnit scrollXForFixedPosition() const;
-    LayoutUnit scrollYForFixedPosition() const;
-    LayoutSize scrollOffsetForFixedPosition() const;
+    int scrollXForFixedPosition() const;
+    int scrollYForFixedPosition() const;
+    IntSize scrollOffsetForFixedPosition() const;
 
     void beginDeferredRepaints();
     void endDeferredRepaints();
@@ -267,10 +268,10 @@ public:
     void scrollElementToRect(Element*, const IntRect&);
 
     // Methods to convert points and rects between the coordinate space of the renderer, and this view.
-    virtual LayoutRect convertFromRenderer(const RenderObject*, const LayoutRect&) const;
-    virtual LayoutRect convertToRenderer(const RenderObject*, const LayoutRect&) const;
-    virtual LayoutPoint convertFromRenderer(const RenderObject*, const LayoutPoint&) const;
-    virtual LayoutPoint convertToRenderer(const RenderObject*, const LayoutPoint&) const;
+    virtual IntRect convertFromRenderer(const RenderObject*, const IntRect&) const;
+    virtual IntRect convertToRenderer(const RenderObject*, const IntRect&) const;
+    virtual IntPoint convertFromRenderer(const RenderObject*, const IntPoint&) const;
+    virtual IntPoint convertToRenderer(const RenderObject*, const IntPoint&) const;
 
     bool isFrameViewScrollCorner(RenderScrollbarPart* scrollCorner) const { return m_scrollCorner == scrollCorner; }
 
@@ -285,7 +286,7 @@ public:
     // On each repaint the delay increses by this amount
     static void setRepaintThrottlingDeferredRepaintDelayIncrementDuringLoading(double p);
 
-    virtual LayoutPoint currentMousePosition() const;
+    virtual IntPoint currentMousePosition() const;
 
     // FIXME: Remove this method once plugin loading is decoupled from layout.
     void flushAnyPendingPostLayoutTasks();
@@ -301,7 +302,7 @@ public:
     void setTracksRepaints(bool);
     bool isTrackingRepaints() const { return m_isTrackingRepaints; }
     void resetTrackedRepaints() { m_trackedRepaintRects.clear(); }
-    const Vector<LayoutRect>& trackedRepaintRects() const { return m_trackedRepaintRects; }
+    const Vector<IntRect>& trackedRepaintRects() const { return m_trackedRepaintRects; }
 
 protected:
     virtual bool scrollContentsFastPath(const IntSize& scrollDelta, const IntRect& rectToScroll, const IntRect& clipRect);
@@ -341,21 +342,21 @@ private:
 
     // Override ScrollView methods to do point conversion via renderers, in order to
     // take transforms into account.
-    virtual LayoutRect convertToContainingView(const LayoutRect&) const;
-    virtual LayoutRect convertFromContainingView(const LayoutRect&) const;
-    virtual LayoutPoint convertToContainingView(const LayoutPoint&) const;
-    virtual LayoutPoint convertFromContainingView(const LayoutPoint&) const;
+    virtual IntRect convertToContainingView(const IntRect&) const;
+    virtual IntRect convertFromContainingView(const IntRect&) const;
+    virtual IntPoint convertToContainingView(const IntPoint&) const;
+    virtual IntPoint convertFromContainingView(const IntPoint&) const;
 
     // ScrollableArea interface
-    virtual void invalidateScrollbarRect(Scrollbar*, const LayoutRect&);
+    virtual void invalidateScrollbarRect(Scrollbar*, const IntRect&);
     virtual bool isActive() const;
-    virtual void getTickmarks(Vector<LayoutRect>&) const;
+    virtual void getTickmarks(Vector<IntRect>&) const;
     virtual void scrollTo(const IntSize&);
     virtual void didStartRubberBand(const IntSize&) const;
     virtual void didCompleteRubberBand(const IntSize&) const;
     virtual void didStartAnimatedScroll() const;
     virtual void didCompleteAnimatedScroll() const;
-    virtual void setVisibleScrollerThumbRect(const LayoutRect&);
+    virtual void setVisibleScrollerThumbRect(const IntRect&);
     virtual bool isOnActivePage() const;
     virtual ScrollableArea* enclosingScrollableArea() const;
 
@@ -456,7 +457,7 @@ private:
     double m_lastPaintTime;
     
     bool m_isTrackingRepaints; // Used for testing.
-    Vector<LayoutRect> m_trackedRepaintRects;
+    Vector<IntRect> m_trackedRepaintRects;
 
     bool m_shouldUpdateWhileOffscreen;
 
index 60d5715..f33b9e2 100644 (file)
@@ -22,7 +22,6 @@
 #ifndef PopupMenuClient_h
 #define PopupMenuClient_h
 
-#include "LayoutTypes.h"
 #include "PopupMenuStyle.h"
 #include "ScrollTypes.h"
 #include <wtf/Forward.h>
@@ -52,8 +51,8 @@ public:
     virtual PopupMenuStyle menuStyle() const = 0;
     virtual int clientInsetLeft() const = 0;
     virtual int clientInsetRight() const = 0;
-    virtual LayoutUnit clientPaddingLeft() const = 0;
-    virtual LayoutUnit clientPaddingRight() const = 0;
+    virtual int clientPaddingLeft() const = 0;
+    virtual int clientPaddingRight() const = 0;
     virtual int listSize() const = 0;
     virtual int selectedIndex() const = 0;
     virtual void popupDidHide() = 0;
index 26238c7..5cbebb5 100644 (file)
@@ -202,7 +202,7 @@ double ScrollAnimatorNone::PerAxisData::releaseArea(Curve curve, double startT,
     return endValue - startValue;
 }
 
-ScrollAnimatorNone::PerAxisData::PerAxisData(ScrollAnimatorNone* parent, float* currentPosition, LayoutUnit visibleLength)
+ScrollAnimatorNone::PerAxisData::PerAxisData(ScrollAnimatorNone* parent, float* currentPosition, int visibleLength)
     : m_currentPosition(currentPosition)
     , m_visibleLength(visibleLength)
 {
@@ -366,7 +366,7 @@ bool ScrollAnimatorNone::PerAxisData::animateScroll(double currentTime)
     return true;
 }
 
-void ScrollAnimatorNone::PerAxisData::updateVisibleLength(LayoutUnit visibleLength)
+void ScrollAnimatorNone::PerAxisData::updateVisibleLength(int visibleLength)
 {
     m_visibleLength = visibleLength;
 }
index 4f1dc5f..f94d523 100644 (file)
@@ -33,7 +33,6 @@
 
 #if ENABLE(SMOOTH_SCROLLING)
 
-#include "LayoutTypes.h"
 #include "ScrollAnimator.h"
 #include "Timer.h"
 
@@ -93,11 +92,11 @@ protected:
     friend class ::ScrollAnimatorNoneTest;
 
     struct PerAxisData {
-        PerAxisData(ScrollAnimatorNone* parent, float* currentPos, LayoutUnit visibleLength);
+        PerAxisData(ScrollAnimatorNone* parent, float* currentPos, int visibleLength);
         void reset();
         bool updateDataFromParameters(float step, float multiplier, float scrollableSize, double currentTime, Parameters*);
         bool animateScroll(double currentTime);
-        void updateVisibleLength(LayoutUnit visibleLength);
+        void updateVisibleLength(int visibleLength);
 
         static double curveAt(Curve, double t);
         static double attackCurve(Curve, double deltaT, double curveT, double startPos, double attackPos);
@@ -129,7 +128,7 @@ protected:
         double m_releaseTime;
         Curve m_releaseCurve;
 
-        LayoutUnit m_visibleLength;
+        int m_visibleLength;
     };
 
     // While zooming, scale, posX and posY need to stay tightly coupled, so use a separate
index 2a25da1..a783934 100644 (file)
@@ -231,34 +231,34 @@ IntRect ScrollView::visibleContentRect(bool includeScrollbars) const
     if (!m_fixedVisibleContentRect.isEmpty())
         return m_fixedVisibleContentRect;
 
-    LayoutUnit verticalScrollbarWidth = verticalScrollbar() && !verticalScrollbar()->isOverlayScrollbar()
+    int verticalScrollbarWidth = verticalScrollbar() && !verticalScrollbar()->isOverlayScrollbar()
         && !includeScrollbars ? verticalScrollbar()->width() : 0;
-    LayoutUnit horizontalScrollbarHeight = horizontalScrollbar() && !horizontalScrollbar()->isOverlayScrollbar()
+    int horizontalScrollbarHeight = horizontalScrollbar() && !horizontalScrollbar()->isOverlayScrollbar()
         && !includeScrollbars ? horizontalScrollbar()->height() : 0;
 
-    return LayoutRect(LayoutPoint(m_scrollOffset.width(), m_scrollOffset.height()),
-                      LayoutSize(max<LayoutUnit>(0, width() - verticalScrollbarWidth), 
-                                 max<LayoutUnit>(0, height() - horizontalScrollbarHeight)));
-
+    return IntRect(m_scrollOffset.width(),
+                   m_scrollOffset.height(),
+                   max(0, width() - verticalScrollbarWidth), 
+                   max(0, height() - horizontalScrollbarHeight));
 }
 #endif
 
-LayoutUnit ScrollView::layoutWidth() const
+int ScrollView::layoutWidth() const
 {
     return m_fixedLayoutSize.isEmpty() || !m_useFixedLayout ? visibleWidth() : m_fixedLayoutSize.width();
 }
 
-LayoutUnit ScrollView::layoutHeight() const
+int ScrollView::layoutHeight() const
 {
     return m_fixedLayoutSize.isEmpty() || !m_useFixedLayout ? visibleHeight() : m_fixedLayoutSize.height();
 }
 
-LayoutSize ScrollView::fixedLayoutSize() const
+IntSize ScrollView::fixedLayoutSize() const
 {
     return m_fixedLayoutSize;
 }
 
-void ScrollView::setFixedLayoutSize(const LayoutSize& newSize)
+void ScrollView::setFixedLayoutSize(const IntSize& newSize)
 {
     if (fixedLayoutSize() == newSize)
         return;
@@ -279,12 +279,12 @@ void ScrollView::setUseFixedLayout(bool enable)
     updateScrollbars(scrollOffset());
 }
 
-LayoutSize ScrollView::contentsSize() const
+IntSize ScrollView::contentsSize() const
 {
     return m_contentsSize;
 }
 
-void ScrollView::setContentsSize(const LayoutSize& newSize)
+void ScrollView::setContentsSize(const IntSize& newSize)
 {
     if (contentsSize() == newSize)
         return;
@@ -405,17 +405,17 @@ bool ScrollView::logicalScroll(ScrollLogicalDirection direction, ScrollGranulari
     return scroll(logicalToPhysical(direction, isVerticalDocument(), isFlippedDocument()), granularity);
 }
 
-LayoutSize ScrollView::overhangAmount() const
+IntSize ScrollView::overhangAmount() const
 {
-    LayoutSize stretch;
+    IntSize stretch;
 
-    LayoutUnit physicalScrollY = scrollPosition().y() + scrollOrigin().y();
+    int physicalScrollY = scrollPosition().y() + scrollOrigin().y();
     if (physicalScrollY < 0)
         stretch.setHeight(physicalScrollY);
     else if (contentsHeight() && physicalScrollY > contentsHeight() - visibleHeight())
         stretch.setHeight(physicalScrollY - (contentsHeight() - visibleHeight()));
 
-    LayoutUnit physicalScrollX = scrollPosition().x() + scrollOrigin().x();
+    int physicalScrollX = scrollPosition().x() + scrollOrigin().x();
     if (physicalScrollX < 0)
         stretch.setWidth(physicalScrollX);
     else if (contentsWidth() && physicalScrollX > contentsWidth() - visibleWidth())
@@ -448,7 +448,7 @@ void ScrollView::updateScrollbars(const IntSize& desiredOffset)
         m_inUpdateScrollbars = false;
     }
 
-    LayoutRect oldScrollCornerRect = scrollCornerRect();
+    IntRect oldScrollCornerRect = scrollCornerRect();
 
     bool hasHorizontalScrollbar = m_horizontalScrollbar;
     bool hasVerticalScrollbar = m_verticalScrollbar;
@@ -472,8 +472,8 @@ void ScrollView::updateScrollbars(const IntSize& desiredOffset)
     } else {
         bool sendContentResizedNotification = false;
         
-        LayoutSize docSize = contentsSize();
-        LayoutSize frameSize = frameRect().size();
+        IntSize docSize = contentsSize();
+        IntSize frameSize = frameRect().size();
 
         if (hScroll == ScrollbarAuto) {
             newHasHorizontalScrollbar = docSize.width() > visibleWidth();
@@ -515,7 +515,7 @@ void ScrollView::updateScrollbars(const IntSize& desiredOffset)
             m_updateScrollbarsPass++;
             contentsResized();
             visibleContentsResized();
-            LayoutSize newDocSize = contentsSize();
+            IntSize newDocSize = contentsSize();
             if (newDocSize == docSize) {
                 // The layout with the new scroll state had no impact on
                 // the document's overall size, so updateScrollbars didn't get called.
@@ -535,12 +535,12 @@ void ScrollView::updateScrollbars(const IntSize& desiredOffset)
 
     if (m_horizontalScrollbar) {
         int clientWidth = visibleWidth();
-        LayoutUnit pageStep = max<LayoutUnit>(max<LayoutUnit>(clientWidth * Scrollbar::minFractionToStepWhenPaging(), clientWidth - Scrollbar::maxOverlapBetweenPages()), 1);
-        LayoutRect oldRect(m_horizontalScrollbar->frameRect());
-        LayoutRect hBarRect = LayoutRect(0,
-                                         height() - m_horizontalScrollbar->height(),
-                                         width() - (m_verticalScrollbar ? m_verticalScrollbar->width() : 0),
-                                         m_horizontalScrollbar->height());
+        int pageStep = max(max<int>(clientWidth * Scrollbar::minFractionToStepWhenPaging(), clientWidth - Scrollbar::maxOverlapBetweenPages()), 1);
+        IntRect oldRect(m_horizontalScrollbar->frameRect());
+        IntRect hBarRect(0,
+                        height() - m_horizontalScrollbar->height(),
+                        width() - (m_verticalScrollbar ? m_verticalScrollbar->width() : 0),
+                        m_horizontalScrollbar->height());
         m_horizontalScrollbar->setFrameRect(hBarRect);
         if (!m_scrollbarsSuppressed && oldRect != m_horizontalScrollbar->frameRect())
             m_horizontalScrollbar->invalidate();
@@ -556,12 +556,12 @@ void ScrollView::updateScrollbars(const IntSize& desiredOffset)
 
     if (m_verticalScrollbar) {
         int clientHeight = visibleHeight();
-        LayoutUnit pageStep = max<LayoutUnit>(max<LayoutUnit>(clientHeight * Scrollbar::minFractionToStepWhenPaging(), clientHeight - Scrollbar::maxOverlapBetweenPages()), 1);
-        LayoutRect oldRect(m_verticalScrollbar->frameRect());
-        LayoutRect vBarRect = LayoutRect(width() - m_verticalScrollbar->width(), 
-            0,
-            m_verticalScrollbar->width(),
-            height() - (m_horizontalScrollbar ? m_horizontalScrollbar->height() : 0));
+        int pageStep = max(max<int>(clientHeight * Scrollbar::minFractionToStepWhenPaging(), clientHeight - Scrollbar::maxOverlapBetweenPages()), 1);
+        IntRect oldRect(m_verticalScrollbar->frameRect());
+        IntRect vBarRect(width() - m_verticalScrollbar->width(), 
+                         0,
+                         m_verticalScrollbar->width(),
+                         height() - (m_horizontalScrollbar ? m_horizontalScrollbar->height() : 0));
         m_verticalScrollbar->setFrameRect(vBarRect);
         if (!m_scrollbarsSuppressed && oldRect != m_verticalScrollbar->frameRect())
             m_verticalScrollbar->invalidate();
@@ -603,8 +603,8 @@ IntRect ScrollView::rectToCopyOnScroll() const
 {
     IntRect scrollViewRect = convertToContainingWindow(IntRect(0, 0, visibleWidth(), visibleHeight()));
     if (hasOverlayScrollbars()) {
-        LayoutUnit verticalScrollbarWidth = (verticalScrollbar() && !hasLayerForVerticalScrollbar()) ? verticalScrollbar()->width() : 0;
-        LayoutUnit horizontalScrollbarHeight = (horizontalScrollbar() && !hasLayerForHorizontalScrollbar()) ? horizontalScrollbar()->height() : 0;
+        int verticalScrollbarWidth = (verticalScrollbar() && !hasLayerForVerticalScrollbar()) ? verticalScrollbar()->width() : 0;
+        int horizontalScrollbarHeight = (horizontalScrollbar() && !hasLayerForHorizontalScrollbar()) ? horizontalScrollbar()->height() : 0;
         
         scrollViewRect.setWidth(scrollViewRect.width() - verticalScrollbarWidth);
         scrollViewRect.setHeight(scrollViewRect.height() - horizontalScrollbarHeight);
@@ -630,9 +630,9 @@ void ScrollView::scrollContents(const IntSize& scrollDelta)
     if (m_drawPanScrollIcon) {
         // FIXME: the pan icon is broken when accelerated compositing is on, since it will draw under the compositing layers.
         // https://bugs.webkit.org/show_bug.cgi?id=47837
-        LayoutUnit panIconDirtySquareSizeLength = 2 * (panIconSizeLength + max(abs(scrollDelta.width()), abs(scrollDelta.height()))); // We only want to repaint what's necessary
-        LayoutPoint panIconDirtySquareLocation = LayoutPoint(m_panScrollIconPoint.x() - (panIconDirtySquareSizeLength / 2), m_panScrollIconPoint.y() - (panIconDirtySquareSizeLength / 2));
-        LayoutRect panScrollIconDirtyRect = LayoutRect(panIconDirtySquareLocation , LayoutSize(panIconDirtySquareSizeLength, panIconDirtySquareSizeLength));
+        int panIconDirtySquareSizeLength = 2 * (panIconSizeLength + max(abs(scrollDelta.width()), abs(scrollDelta.height()))); // We only want to repaint what's necessary
+        IntPoint panIconDirtySquareLocation = IntPoint(m_panScrollIconPoint.x() - (panIconDirtySquareSizeLength / 2), m_panScrollIconPoint.y() - (panIconDirtySquareSizeLength / 2));
+        IntRect panScrollIconDirtyRect = IntRect(panIconDirtySquareLocation, IntSize(panIconDirtySquareSizeLength, panIconDirtySquareSizeLength));
         panScrollIconDirtyRect.intersect(clipRect);
         hostWindow()->invalidateContentsAndWindow(panScrollIconDirtyRect, false /*immediate*/);
     }
@@ -648,8 +648,8 @@ void ScrollView::scrollContents(const IntSize& scrollDelta)
     }
 
     // Invalidate the overhang areas if they are visible.
-    LayoutRect horizontalOverhangRect;
-    LayoutRect verticalOverhangRect;
+    IntRect horizontalOverhangRect;
+    IntRect verticalOverhangRect;
     calculateOverhangAreasForPainting(horizontalOverhangRect, verticalOverhangRect);
 #if USE(ACCELERATED_COMPOSITING) && PLATFORM(CHROMIUM) && ENABLE(RUBBER_BANDING)
     if (GraphicsLayer* overhangLayer = layerForOverhangAreas()) {
@@ -722,7 +722,7 @@ IntPoint ScrollView::contentsToWindow(const IntPoint& contentsPoint) const
 
 IntRect ScrollView::windowToContents(const IntRect& windowRect) const
 {
-    LayoutRect viewRect = convertFromContainingWindow(windowRect);
+    IntRect viewRect = convertFromContainingWindow(windowRect);
     viewRect.move(scrollOffset());
     return viewRect;
 }
@@ -743,12 +743,12 @@ IntRect ScrollView::contentsToScreen(const IntRect& rect) const
     return hostWindow()->windowToScreen(contentsToWindow(rect));
 }
 
-LayoutPoint ScrollView::screenToContents(const IntPoint& point) const
+IntPoint ScrollView::screenToContents(const IntPoint& point) const
 {
     if (platformWidget())
         return platformScreenToContents(point);
     if (!hostWindow())
-        return LayoutPoint();
+        return IntPoint();
     return windowToContents(hostWindow()->screenToWindow(point));
 }
 
@@ -812,7 +812,7 @@ Scrollbar* ScrollView::scrollbarAtPoint(const IntPoint& windowPoint)
     if (platformWidget())
         return 0;
 
-    LayoutPoint viewPoint = convertFromContainingWindow(windowPoint);
+    IntPoint viewPoint = convertFromContainingWindow(windowPoint);
     if (m_horizontalScrollbar && m_horizontalScrollbar->frameRect().contains(viewPoint))
         return m_horizontalScrollbar.get();
     if (m_verticalScrollbar && m_verticalScrollbar->frameRect().contains(viewPoint))
@@ -850,9 +850,9 @@ void ScrollView::gestureEvent(const PlatformGestureEvent& gestureEvent)
 }
 #endif
 
-void ScrollView::setFrameRect(const LayoutRect& newRect)
+void ScrollView::setFrameRect(const IntRect& newRect)
 {
-    LayoutRect oldRect = frameRect();
+    IntRect oldRect = frameRect();
     
     if (newRect == oldRect)
         return;
@@ -883,14 +883,14 @@ static void positionScrollbarLayer(GraphicsLayer* graphicsLayer, Scrollbar* scro
     if (!graphicsLayer || !scrollbar)
         return;
     graphicsLayer->setDrawsContent(true);
-    LayoutRect scrollbarRect = scrollbar->frameRect();
+    IntRect scrollbarRect = scrollbar->frameRect();
     graphicsLayer->setPosition(scrollbarRect.location());
     if (scrollbarRect.size() != graphicsLayer->size())
         graphicsLayer->setNeedsDisplay();
     graphicsLayer->setSize(scrollbarRect.size());
 }
 
-static void positionScrollCornerLayer(GraphicsLayer* graphicsLayer, const LayoutRect& cornerRect)
+static void positionScrollCornerLayer(GraphicsLayer* graphicsLayer, const IntRect& cornerRect)
 {
     if (!graphicsLayer)
         return;
@@ -912,9 +912,9 @@ void ScrollView::positionScrollbarLayers()
 #endif
 }
 
-void ScrollView::repaintContentRectangle(const LayoutRect& rect, bool now)
+void ScrollView::repaintContentRectangle(const IntRect& rect, bool now)
 {
-    LayoutRect paintRect = rect;
+    IntRect paintRect = rect;
     if (clipsRepaints() && !paintsEntireContents())
         paintRect.intersect(visibleContentRect());
     if (paintRect.isEmpty())
@@ -930,25 +930,25 @@ void ScrollView::repaintContentRectangle(const LayoutRect& rect, bool now)
         hostWindow()->invalidateContentsAndWindow(contentsToWindow(paintRect), now /*immediate*/);
 }
 
-LayoutRect ScrollView::scrollCornerRect() const
+IntRect ScrollView::scrollCornerRect() const
 {
-    LayoutRect cornerRect;
+    IntRect cornerRect;
 
     if (hasOverlayScrollbars())
         return cornerRect;
 
     if (m_horizontalScrollbar && width() - m_horizontalScrollbar->width() > 0) {
-        cornerRect.unite(LayoutRect(m_horizontalScrollbar->width(),
-                                    height() - m_horizontalScrollbar->height(),
-                                    width() - m_horizontalScrollbar->width(),
-                                    m_horizontalScrollbar->height()));
+        cornerRect.unite(IntRect(m_horizontalScrollbar->width(),
+                                 height() - m_horizontalScrollbar->height(),
+                                 width() - m_horizontalScrollbar->width(),
+                                 m_horizontalScrollbar->height()));
     }
 
     if (m_verticalScrollbar && height() - m_verticalScrollbar->height() > 0) {
-        cornerRect.unite(LayoutRect(width() - m_verticalScrollbar->width(),
-                                    m_verticalScrollbar->height(),
-                                    m_verticalScrollbar->width(),
-                                    height() - m_verticalScrollbar->height()));
+        cornerRect.unite(IntRect(width() - m_verticalScrollbar->width(),
+                                 m_verticalScrollbar->height(),
+                                 m_verticalScrollbar->width(),
+                                 height() - m_verticalScrollbar->height()));
     }
     
     return cornerRect;
@@ -969,17 +969,17 @@ void ScrollView::updateScrollCorner()
 {
 }
 
-void ScrollView::paintScrollCorner(GraphicsContext* context, const LayoutRect& cornerRect)
+void ScrollView::paintScrollCorner(GraphicsContext* context, const IntRect& cornerRect)
 {
     ScrollbarTheme::theme()->paintScrollCorner(this, context, cornerRect);
 }
 
-void ScrollView::invalidateScrollCornerRect(const LayoutRect& rect)
+void ScrollView::invalidateScrollCornerRect(const IntRect& rect)
 {
     invalidateRect(rect);
 }
 
-void ScrollView::paintScrollbars(GraphicsContext* context, const LayoutRect& rect)
+void ScrollView::paintScrollbars(GraphicsContext* context, const IntRect& rect)
 {
     if (m_horizontalScrollbar
 #if USE(ACCELERATED_COMPOSITING)
@@ -1007,7 +1007,7 @@ void ScrollView::paintPanScrollIcon(GraphicsContext* context)
     context->drawImage(panScrollIcon, ColorSpaceDeviceRGB, m_panScrollIconPoint);
 }
 
-void ScrollView::paint(GraphicsContext* context, const LayoutRect& rect)
+void ScrollView::paint(GraphicsContext* context, const IntRect& rect)
 {
     if (platformWidget()) {
         Widget::paint(context, rect);
@@ -1022,13 +1022,13 @@ void ScrollView::paint(GraphicsContext* context, const LayoutRect& rect)
     // If we encounter any overlay scrollbars as we paint, this will be set to true.
     m_containsScrollableAreaWithOverlayScrollbars = false;
 
-    LayoutRect clipRect = frameRect();
+    IntRect clipRect = frameRect();
     if (verticalScrollbar() && !verticalScrollbar()->isOverlayScrollbar())
         clipRect.setWidth(clipRect.width() - verticalScrollbar()->width());
     if (horizontalScrollbar() && !horizontalScrollbar()->isOverlayScrollbar())
         clipRect.setHeight(clipRect.height() - horizontalScrollbar()->height());
 
-    LayoutRect documentDirtyRect = rect;
+    IntRect documentDirtyRect = rect;
     documentDirtyRect.intersect(clipRect);
 
     if (!documentDirtyRect.isEmpty()) {
@@ -1057,7 +1057,7 @@ void ScrollView::paint(GraphicsContext* context, const LayoutRect& rect)
     // Now paint the scrollbars.
     if (!m_scrollbarsSuppressed && (m_horizontalScrollbar || m_verticalScrollbar)) {
         GraphicsContextStateSaver stateSaver(*context);
-        LayoutRect scrollViewDirtyRect = rect;
+        IntRect scrollViewDirtyRect = rect;
         scrollViewDirtyRect.intersect(frameRect());
         context->translate(x(), y());
         scrollViewDirtyRect.moveBy(-location());
@@ -1070,25 +1070,25 @@ void ScrollView::paint(GraphicsContext* context, const LayoutRect& rect)
         paintPanScrollIcon(context);
 }
 
-void ScrollView::calculateOverhangAreasForPainting(LayoutRect& horizontalOverhangRect, LayoutRect& verticalOverhangRect)
+void ScrollView::calculateOverhangAreasForPainting(IntRect& horizontalOverhangRect, IntRect& verticalOverhangRect)
 {
-    LayoutUnit verticalScrollbarWidth = (verticalScrollbar() && !verticalScrollbar()->isOverlayScrollbar())
+    int verticalScrollbarWidth = (verticalScrollbar() && !verticalScrollbar()->isOverlayScrollbar())
         ? verticalScrollbar()->width() : 0;
-    LayoutUnit horizontalScrollbarHeight = (horizontalScrollbar() && !horizontalScrollbar()->isOverlayScrollbar())
+    int horizontalScrollbarHeight = (horizontalScrollbar() && !horizontalScrollbar()->isOverlayScrollbar())
         ? horizontalScrollbar()->height() : 0;
 
-    LayoutUnit physicalScrollY = scrollPosition().y() + scrollOrigin().y();
+    int physicalScrollY = scrollPosition().y() + scrollOrigin().y();
     if (physicalScrollY < 0) {
         horizontalOverhangRect = frameRect();
         horizontalOverhangRect.setHeight(-physicalScrollY);
     } else if (contentsHeight() && physicalScrollY > contentsHeight() - visibleHeight()) {
-        LayoutUnit height = physicalScrollY - (contentsHeight() - visibleHeight());
+        int height = physicalScrollY - (contentsHeight() - visibleHeight());
         horizontalOverhangRect = frameRect();
         horizontalOverhangRect.setY(frameRect().maxY() - height - horizontalScrollbarHeight);
         horizontalOverhangRect.setHeight(height);
     }
 
-    LayoutUnit physicalScrollX = scrollPosition().x() + scrollOrigin().x();
+    int physicalScrollX = scrollPosition().x() + scrollOrigin().x();
     if (physicalScrollX < 0) {
         verticalOverhangRect.setWidth(-physicalScrollX);
         verticalOverhangRect.setHeight(frameRect().height() - horizontalOverhangRect.height());
@@ -1098,7 +1098,7 @@ void ScrollView::calculateOverhangAreasForPainting(LayoutRect& horizontalOverhan
         else
             verticalOverhangRect.setY(frameRect().y());
     } else if (contentsWidth() && physicalScrollX > contentsWidth() - visibleWidth()) {
-        LayoutUnit width = physicalScrollX - (contentsWidth() - visibleWidth());
+        int width = physicalScrollX - (contentsWidth() - visibleWidth());
         verticalOverhangRect.setWidth(width);
         verticalOverhangRect.setHeight(frameRect().height() - horizontalOverhangRect.height());
         verticalOverhangRect.setX(frameRect().maxX() - width - verticalScrollbarWidth);
@@ -1109,15 +1109,15 @@ void ScrollView::calculateOverhangAreasForPainting(LayoutRect& horizontalOverhan
     }
 }
 
-void ScrollView::paintOverhangAreas(GraphicsContext* context, const LayoutRect& horizontalOverhangRect, const LayoutRect& verticalOverhangRect, const LayoutRect& dirtyRect)
+void ScrollView::paintOverhangAreas(GraphicsContext* context, const IntRect& horizontalOverhangRect, const IntRect& verticalOverhangRect, const IntRect& dirtyRect)
 {
     ScrollbarTheme::theme()->paintOverhangAreas(this, context, horizontalOverhangRect, verticalOverhangRect, dirtyRect);
 }
 
-void ScrollView::calculateAndPaintOverhangAreas(GraphicsContext* context, const LayoutRect& dirtyRect)
+void ScrollView::calculateAndPaintOverhangAreas(GraphicsContext* context, const IntRect& dirtyRect)
 {
-    LayoutRect horizontalOverhangRect;
-    LayoutRect verticalOverhangRect;
+    IntRect horizontalOverhangRect;
+    IntRect verticalOverhangRect;
     calculateOverhangAreasForPainting(horizontalOverhangRect, verticalOverhangRect);
 
     if (dirtyRect.intersects(horizontalOverhangRect) || dirtyRect.intersects(verticalOverhangRect))
@@ -1129,19 +1129,19 @@ bool ScrollView::isPointInScrollbarCorner(const IntPoint& windowPoint)
     if (!scrollbarCornerPresent())
         return false;
 
-    LayoutPoint viewPoint = convertFromContainingWindow(windowPoint);
+    IntPoint viewPoint = convertFromContainingWindow(windowPoint);
 
     if (m_horizontalScrollbar) {
-        LayoutUnit horizontalScrollbarYMin = m_horizontalScrollbar->frameRect().y();
-        LayoutUnit horizontalScrollbarYMax = m_horizontalScrollbar->frameRect().y() + m_horizontalScrollbar->frameRect().height();
-        LayoutUnit horizontalScrollbarXMin = m_horizontalScrollbar->frameRect().x() + m_horizontalScrollbar->frameRect().width();
+        int horizontalScrollbarYMin = m_horizontalScrollbar->frameRect().y();
+        int horizontalScrollbarYMax = m_horizontalScrollbar->frameRect().y() + m_horizontalScrollbar->frameRect().height();
+        int horizontalScrollbarXMin = m_horizontalScrollbar->frameRect().x() + m_horizontalScrollbar->frameRect().width();
 
         return viewPoint.y() > horizontalScrollbarYMin && viewPoint.y() < horizontalScrollbarYMax && viewPoint.x() > horizontalScrollbarXMin;
     }
 
-    LayoutUnit verticalScrollbarXMin = m_verticalScrollbar->frameRect().x();
-    LayoutUnit verticalScrollbarXMax = m_verticalScrollbar->frameRect().x() + m_verticalScrollbar->frameRect().width();
-    LayoutUnit verticalScrollbarYMin = m_verticalScrollbar->frameRect().y() + m_verticalScrollbar->frameRect().height();
+    int verticalScrollbarXMin = m_verticalScrollbar->frameRect().x();
+    int verticalScrollbarXMax = m_verticalScrollbar->frameRect().x() + m_verticalScrollbar->frameRect().width();
+    int verticalScrollbarYMin = m_verticalScrollbar->frameRect().y() + m_verticalScrollbar->frameRect().height();
     
     return viewPoint.x() > verticalScrollbarXMin && viewPoint.x() < verticalScrollbarXMax && viewPoint.y() > verticalScrollbarYMin;
 }
@@ -1152,34 +1152,34 @@ bool ScrollView::scrollbarCornerPresent() const
         || (m_verticalScrollbar && height() - m_verticalScrollbar->height() > 0);
 }
 
-LayoutRect ScrollView::convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const LayoutRect& localRect) const
+IntRect ScrollView::convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const IntRect& localRect) const
 {
     // Scrollbars won't be transformed within us
-    LayoutRect newRect = localRect;
+    IntRect newRect = localRect;
     newRect.moveBy(scrollbar->location());
     return newRect;
 }
 
-LayoutRect ScrollView::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const LayoutRect& parentRect) const
+IntRect ScrollView::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const IntRect& parentRect) const
 {
-    LayoutRect newRect = parentRect;
+    IntRect newRect = parentRect;
     // Scrollbars won't be transformed within us
     newRect.moveBy(-scrollbar->location());
     return newRect;
 }
 
 // FIXME: test these on windows
-LayoutPoint ScrollView::convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const LayoutPoint& localPoint) const
+IntPoint ScrollView::convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const IntPoint& localPoint) const
 {
     // Scrollbars won't be transformed within us
-    LayoutPoint newPoint = localPoint;
+    IntPoint newPoint = localPoint;
     newPoint.moveBy(scrollbar->location());
     return newPoint;
 }
 
-LayoutPoint ScrollView::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const LayoutPoint& parentPoint) const
+IntPoint ScrollView::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const IntPoint& parentPoint) const
 {
-    LayoutPoint newPoint = parentPoint;
+    IntPoint newPoint = parentPoint;
     // Scrollbars won't be transformed within us
     newPoint.moveBy(-scrollbar->location());
     return newPoint;
@@ -1242,7 +1242,7 @@ bool ScrollView::isOffscreen() const
 }
 
 
-void ScrollView::addPanScrollIcon(const LayoutPoint& iconPosition)
+void ScrollView::addPanScrollIcon(const IntPoint& iconPosition)
 {
     if (!hostWindow())
         return;
@@ -1346,12 +1346,12 @@ void ScrollView::platformSetContentsSize()
 {
 }
 
-IntRect ScrollView::platformContentsToScreen(const LayoutRect& rect) const
+IntRect ScrollView::platformContentsToScreen(const IntRect& rect) const
 {
     return rect;
 }
 
-LayoutPoint ScrollView::platformScreenToContents(const IntPoint& point) const
+IntPoint ScrollView::platformScreenToContents(const IntPoint& point) const
 {
     return point;
 }
@@ -1365,7 +1365,7 @@ bool ScrollView::platformScroll(ScrollDirection, ScrollGranularity)
     return true;
 }
 
-void ScrollView::platformRepaintContentRectangle(const LayoutRect&, bool /*now*/)
+void ScrollView::platformRepaintContentRectangle(const IntRect&, bool /*now*/)
 {
 }
 
index 1a39bac..3a7b8a9 100644 (file)
@@ -146,8 +146,8 @@ public:
     // which usually will happen when panning, pinching and rotation ends, or when scale or position are changed manually.
     virtual IntRect visibleContentRect(bool includeScrollbars = false) const;
     virtual void setFixedVisibleContentRect(const IntRect& visibleContentRect) { m_fixedVisibleContentRect = visibleContentRect; }
-    LayoutUnit visibleWidth() const { return visibleContentRect().width(); }
-    LayoutUnit visibleHeight() const { return visibleContentRect().height(); }
+    int visibleWidth() const { return visibleContentRect().width(); }
+    int visibleHeight() const { return visibleContentRect().height(); }
 
     // Functions for getting/setting the size webkit should use to layout the contents. By default this is the same as the visible
     // content size. Explicitly setting a layout size value will cause webkit to layout the contents using this size instead.
@@ -279,7 +279,7 @@ public:
 
     virtual bool isPointInScrollbarCorner(const IntPoint&);
     virtual bool scrollbarCornerPresent() const;
-    virtual LayoutRect scrollCornerRect() const;
+    virtual IntRect scrollCornerRect() const;
     virtual void paintScrollCorner(GraphicsContext*, const IntRect& cornerRect);
 
     virtual IntRect convertFromScrollbarToContainingView(const Scrollbar*, const IntRect&) const;
index 6749a3a..cbfb2b0 100644 (file)
@@ -26,7 +26,6 @@
 #ifndef ScrollableArea_h
 #define ScrollableArea_h
 
-#include "LayoutTypes.h"
 #include "Scrollbar.h"
 #include <wtf/Vector.h>
 
@@ -92,7 +91,7 @@ public:
     virtual int scrollPosition(Scrollbar*) const = 0;
     void invalidateScrollbar(Scrollbar*, const IntRect&);
     virtual bool isScrollCornerVisible() const = 0;
-    virtual LayoutRect scrollCornerRect() const = 0;
+    virtual IntRect scrollCornerRect() const = 0;
     void invalidateScrollCorner(const IntRect&);
     virtual void getTickmarks(Vector<IntRect>&) const { }
 
@@ -127,8 +126,8 @@ public:
     virtual IntPoint minimumScrollPosition() const { ASSERT_NOT_REACHED(); return IntPoint(); }
     virtual IntPoint maximumScrollPosition() const { ASSERT_NOT_REACHED(); return IntPoint(); }
     virtual IntRect visibleContentRect(bool /*includeScrollbars*/ = false) const { ASSERT_NOT_REACHED(); return IntRect(); }
-    virtual LayoutUnit visibleHeight() const { ASSERT_NOT_REACHED(); return 0; }
-    virtual LayoutUnit visibleWidth() const { ASSERT_NOT_REACHED(); return 0; }
+    virtual int visibleHeight() const { ASSERT_NOT_REACHED(); return 0; }
+    virtual int visibleWidth() const { ASSERT_NOT_REACHED(); return 0; }
     virtual IntSize contentsSize() const { ASSERT_NOT_REACHED(); return IntSize(); }
     virtual IntSize overhangAmount() const { ASSERT_NOT_REACHED(); return IntSize(); }
     virtual IntPoint currentMousePosition() const { return IntPoint(); }
index 90e4ae0..ca3df8d 100644 (file)
@@ -1297,17 +1297,17 @@ void RenderLayer::panScrollFromPoint(const LayoutPoint& sourcePoint)
     if (!frame)
         return;
     
-    LayoutPoint currentMousePosition = frame->eventHandler()->currentMousePosition();
+    IntPoint currentMousePosition = frame->eventHandler()->currentMousePosition();
     
     // We need to check if the current mouse position is out of the window. When the mouse is out of the window, the position is incoherent
-    static LayoutPoint previousMousePosition;
+    static IntPoint previousMousePosition;
     if (currentMousePosition.x() < 0 || currentMousePosition.y() < 0)
         currentMousePosition = previousMousePosition;
     else
         previousMousePosition = currentMousePosition;
 
-    LayoutUnit xDelta = currentMousePosition.x() - sourcePoint.x();
-    LayoutUnit yDelta = currentMousePosition.y() - sourcePoint.y();
+    int xDelta = currentMousePosition.x() - sourcePoint.x();
+    int yDelta = currentMousePosition.y() - sourcePoint.y();
 
     if (abs(xDelta) <= ScrollView::noPanScrollRadius) // at the center we let the space for the icon
         xDelta = 0;
@@ -1345,7 +1345,7 @@ void RenderLayer::scrollByRecursively(LayoutUnit xDelta, LayoutUnit yDelta, Scro
     } else if (renderer()->view()->frameView()) {
         // If we are here, we were called on a renderer that can be programmatically scrolled, but doesn't
         // have an overflow clip. Which means that it is a document node that can be scrolled.
-        renderer()->view()->frameView()->scrollBy(LayoutSize(xDelta, yDelta));
+        renderer()->view()->frameView()->scrollBy(IntSize(xDelta, yDelta));
         // FIXME: If we didn't scroll the whole way, do we want to try looking at the frames ownerElement? 
         // https://bugs.webkit.org/show_bug.cgi?id=28237
     }
@@ -1368,7 +1368,7 @@ void RenderLayer::scrollToOffset(LayoutUnit x, LayoutUnit y, ScrollOffsetClampin
     ScrollableArea::scrollToOffsetWithoutAnimation(LayoutPoint(x, y));
 }
 
-void RenderLayer::scrollTo(LayoutUnit x, LayoutUnit y)
+void RenderLayer::scrollTo(int x, int y)
 {
     RenderBox* box = renderBox();
     if (!box)
@@ -1385,7 +1385,7 @@ void RenderLayer::scrollTo(LayoutUnit x, LayoutUnit y)
     // complicated (since it will involve testing whether our layer
     // is either occluded by another layer or clipped by an enclosing
     // layer or contains fixed backgrounds, etc.).
-    LayoutSize newScrollOffset = LayoutSize(x - scrollOrigin().x(), y - scrollOrigin().y());
+    IntSize newScrollOffset = IntSize(x - scrollOrigin().x(), y - scrollOrigin().y());
     if (m_scrollOffset == newScrollOffset)
         return;
     m_scrollOffset = newScrollOffset;
@@ -1501,7 +1501,7 @@ void RenderLayer::scrollRectToVisible(const LayoutRect& rect, const ScrollAlignm
                 xOffset = max<LayoutUnit>(0, min(frameView->contentsWidth(), xOffset));
                 yOffset = max<LayoutUnit>(0, min(frameView->contentsHeight(), yOffset));
 
-                frameView->setScrollPosition(LayoutPoint(xOffset, yOffset));
+                frameView->setScrollPosition(IntPoint(xOffset, yOffset));
                 parentLayer = renderer()->document()->ownerElement()->renderer()->enclosingLayer();
                 newRect.setX(rect.x() - frameView->scrollX() + frameView->x());
                 newRect.setY(rect.y() - frameView->scrollY() + frameView->y());
@@ -1618,7 +1618,7 @@ void RenderLayer::autoscroll()
     frame->eventHandler()->updateSelectionForMouseDrag();
 #endif
 
-    LayoutPoint currentDocumentPosition = frameView->windowToContents(frame->eventHandler()->currentMousePosition());
+    IntPoint currentDocumentPosition = frameView->windowToContents(frame->eventHandler()->currentMousePosition());
     scrollRectToVisible(LayoutRect(currentDocumentPosition, LayoutSize(1, 1)), ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignToEdgeIfNeeded);
 }
 
@@ -1687,18 +1687,18 @@ void RenderLayer::resize(const PlatformMouseEvent& evt, const LayoutSize& oldOff
     // FIXME (Radar 4118564): We should also autoscroll the window as necessary to keep the point under the cursor in view.
 }
 
-LayoutUnit RenderLayer::scrollSize(ScrollbarOrientation orientation) const
+int RenderLayer::scrollSize(ScrollbarOrientation orientation) const
 {
     Scrollbar* scrollbar = ((orientation == HorizontalScrollbar) ? m_hBar : m_vBar).get();
     return scrollbar ? (scrollbar->totalSize() - scrollbar->visibleSize()) : 0;
 }
 
-void RenderLayer::setScrollOffset(const LayoutPoint& offset)
+void RenderLayer::setScrollOffset(const IntPoint& offset)
 {
     scrollTo(offset.x(), offset.y());
 }
 
-LayoutUnit RenderLayer::scrollPosition(Scrollbar* scrollbar) const
+int RenderLayer::scrollPosition(Scrollbar* scrollbar) const
 {
     if (scrollbar->orientation() == HorizontalScrollbar)
         return scrollXOffset();
@@ -1707,17 +1707,17 @@ LayoutUnit RenderLayer::scrollPosition(Scrollbar* scrollbar) const
     return 0;
 }
 
-LayoutPoint RenderLayer::scrollPosition() const
+IntPoint RenderLayer::scrollPosition() const
 {
     return scrollOrigin() + m_scrollOffset;
 }
 
-LayoutPoint RenderLayer::minimumScrollPosition() const
+IntPoint RenderLayer::minimumScrollPosition() const
 {
     return scrollOrigin();
 }
 
-LayoutPoint RenderLayer::maximumScrollPosition() const
+IntPoint RenderLayer::maximumScrollPosition() const
 {
     // FIXME: m_scrollSize may not be up-to-date if m_scrollDimensionsDirty is true.
     return scrollOrigin() + m_scrollSize - visibleContentRect(true).size();
@@ -1737,12 +1737,12 @@ IntRect RenderLayer::visibleContentRect(bool includeScrollbars) const
                            max(0, m_layerSize.height() - horizontalScrollbarHeight)));
 }
 
-LayoutSize RenderLayer::overhangAmount() const
+IntSize RenderLayer::overhangAmount() const
 {
-    return LayoutSize();
+    return IntSize();
 }
 
-void RenderLayer::didCompleteRubberBand(const LayoutSize&) const
+void RenderLayer::didCompleteRubberBand(const IntSize&) const
 {
 }
 
@@ -1752,7 +1752,7 @@ bool RenderLayer::isActive() const
     return page && page->focusController()->isActive();
 }
 
-static LayoutRect cornerRect(const RenderLayer* layer, const LayoutRect& bounds)
+static IntRect cornerRect(const RenderLayer* layer, const IntRect& bounds)
 {
     int horizontalThickness;
     int verticalThickness;
@@ -1771,12 +1771,12 @@ static LayoutRect cornerRect(const RenderLayer* layer, const LayoutRect& bounds)
         horizontalThickness = layer->verticalScrollbar()->width();
         verticalThickness = layer->horizontalScrollbar()->height();
     }
-    return LayoutRect(bounds.maxX() - horizontalThickness - layer->renderer()->style()->borderRightWidth(), 
-                      bounds.maxY() - verticalThickness - layer->renderer()->style()->borderBottomWidth(),
-                      horizontalThickness, verticalThickness);
+    return IntRect(bounds.maxX() - horizontalThickness - layer->renderer()->style()->borderRightWidth(), 
+                   bounds.maxY() - verticalThickness - layer->renderer()->style()->borderBottomWidth(),
+                   horizontalThickness, verticalThickness);
 }
 
-LayoutRect RenderLayer::scrollCornerRect() const
+IntRect RenderLayer::scrollCornerRect() const
 {
     // We have a scrollbar corner when a scrollbar is visible and not filling the entire length of the box.
     // This happens when:
@@ -1787,23 +1787,23 @@ LayoutRect RenderLayer::scrollCornerRect() const
     bool hasResizer = renderer()->style()->resize() != RESIZE_NONE;
     if ((hasHorizontalBar && hasVerticalBar) || (hasResizer && (hasHorizontalBar || hasVerticalBar)))
         return cornerRect(this, renderBox()->borderBoxRect());
-    return LayoutRect();
+    return IntRect();
 }
 
-static LayoutRect resizerCornerRect(const RenderLayer* layer, const LayoutRect& bounds)
+static IntRect resizerCornerRect(const RenderLayer* layer, const IntRect& bounds)
 {
     ASSERT(layer->renderer()->isBox());
     if (layer->renderer()->style()->resize() == RESIZE_NONE)
-        return LayoutRect();
+        return IntRect();
     return cornerRect(layer, bounds);
 }
 
-LayoutRect RenderLayer::scrollCornerAndResizerRect() const
+IntRect RenderLayer::scrollCornerAndResizerRect() const
 {
     RenderBox* box = renderBox();
     if (!box)
-        return LayoutRect();
-    LayoutRect scrollCornerAndResizer = scrollCornerRect();
+        return IntRect();
+    IntRect scrollCornerAndResizer = scrollCornerRect();
     if (scrollCornerAndResizer.isEmpty())
         scrollCornerAndResizer = resizerCornerRect(this, box->borderBoxRect());
     return scrollCornerAndResizer;
@@ -1815,63 +1815,63 @@ bool RenderLayer::isScrollCornerVisible() const
     return !scrollCornerRect().isEmpty();
 }
 
-LayoutRect RenderLayer::convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const LayoutRect& scrollbarRect) const
+IntRect RenderLayer::convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const IntRect& scrollbarRect) const
 {
     RenderView* view = renderer()->view();
     if (!view)
         return scrollbarRect;
 
-    LayoutRect rect = scrollbarRect;
+    IntRect rect = scrollbarRect;
     rect.move(scrollbarOffset(scrollbar));
 
     return view->frameView()->convertFromRenderer(renderer(), rect);
 }
 
-LayoutRect RenderLayer::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const LayoutRect& parentRect) const
+IntRect RenderLayer::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const IntRect& parentRect) const
 {
     RenderView* view = renderer()->view();
     if (!view)
         return parentRect;
 
-    LayoutRect rect = view->frameView()->convertToRenderer(renderer(), parentRect);
+    IntRect rect = view->frameView()->convertToRenderer(renderer(), parentRect);
     rect.move(-scrollbarOffset(scrollbar));
     return rect;
 }
 
-LayoutPoint RenderLayer::convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const LayoutPoint& scrollbarPoint) const
+IntPoint RenderLayer::convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const IntPoint& scrollbarPoint) const
 {
     RenderView* view = renderer()->view();
     if (!view)
         return scrollbarPoint;
 
-    LayoutPoint point = scrollbarPoint;
+    IntPoint point = scrollbarPoint;
     point.move(scrollbarOffset(scrollbar));
     return view->frameView()->convertFromRenderer(renderer(), point);
 }
 
-LayoutPoint RenderLayer::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const LayoutPoint& parentPoint) const
+IntPoint RenderLayer::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const IntPoint& parentPoint) const
 {
     RenderView* view = renderer()->view();
     if (!view)
         return parentPoint;
 
-    LayoutPoint point = view->frameView()->convertToRenderer(renderer(), parentPoint);
+    IntPoint point = view->frameView()->convertToRenderer(renderer(), parentPoint);
 
     point.move(-scrollbarOffset(scrollbar));
     return point;
 }
 
-LayoutSize RenderLayer::contentsSize() const
+IntSize RenderLayer::contentsSize() const
 {
-    return LayoutSize(const_cast<RenderLayer*>(this)->scrollWidth(), const_cast<RenderLayer*>(this)->scrollHeight());
+    return IntSize(const_cast<RenderLayer*>(this)->scrollWidth(), const_cast<RenderLayer*>(this)->scrollHeight());
 }
 
-LayoutUnit RenderLayer::visibleHeight() const
+int RenderLayer::visibleHeight() const
 {
     return m_layerSize.height();
 }
 
-LayoutUnit RenderLayer::visibleWidth() const
+int RenderLayer::visibleWidth() const
 {
     return m_layerSize.width();
 }
@@ -1889,26 +1889,26 @@ bool RenderLayer::isOnActivePage() const
     return !m_renderer->document()->inPageCache();
 }
 
-LayoutPoint RenderLayer::currentMousePosition() const
+IntPoint RenderLayer::currentMousePosition() const
 {
-    return renderer()->frame() ? renderer()->frame()->eventHandler()->currentMousePosition() : LayoutPoint();
+    return renderer()->frame() ? renderer()->frame()->eventHandler()->currentMousePosition() : IntPoint();
 }
 
-LayoutSize RenderLayer::scrollbarOffset(const Scrollbar* scrollbar) const
+IntSize RenderLayer::scrollbarOffset(const Scrollbar* scrollbar) const
 {
     RenderBox* box = renderBox();
 
     if (scrollbar == m_vBar.get())
-        return LayoutSize(box->width() - box->borderRight() - scrollbar->width(), box->borderTop());
+        return IntSize(box->width() - box->borderRight() - scrollbar->width(), box->borderTop());
 
     if (scrollbar == m_hBar.get())
-        return LayoutSize(box->borderLeft(), box->height() - box->borderBottom() - scrollbar->height());
+        return IntSize(box->borderLeft(), box->height() - box->borderBottom() - scrollbar->height());
     
     ASSERT_NOT_REACHED();
-    return LayoutSize();
+    return IntSize();
 }
 
-void RenderLayer::invalidateScrollbarRect(Scrollbar* scrollbar, const LayoutRect& rect)
+void RenderLayer::invalidateScrollbarRect(Scrollbar* scrollbar, const IntRect& rect)
 {
 #if USE(ACCELERATED_COMPOSITING)
     if (scrollbar == m_vBar.get()) {
@@ -1923,7 +1923,7 @@ void RenderLayer::invalidateScrollbarRect(Scrollbar* scrollbar, const LayoutRect
         }
     }
 #endif
-    LayoutRect scrollRect = rect;
+    IntRect scrollRect = rect;
     RenderBox* box = renderBox();
     ASSERT(box);
     if (scrollbar == m_vBar.get())
@@ -1933,7 +1933,7 @@ void RenderLayer::invalidateScrollbarRect(Scrollbar* scrollbar, const LayoutRect
     renderer()->repaintRectangle(scrollRect);
 }
 
-void RenderLayer::invalidateScrollCornerRect(const LayoutRect& rect)
+void RenderLayer::invalidateScrollCornerRect(const IntRect& rect)
 {
 #if USE(ACCELERATED_COMPOSITING)
     if (GraphicsLayer* layer = layerForScrollCorner()) {
@@ -2103,20 +2103,20 @@ void RenderLayer::positionOverflowControls(const LayoutSize& offsetFromLayer)
     if (!box)
         return;
 
-    const LayoutRect& borderBox = box->borderBoxRect();
-    const LayoutRect& scrollCorner = scrollCornerRect();
-    LayoutRect absBounds(borderBox.location() + offsetFromLayer, borderBox.size());
+    const IntRect borderBox = box->borderBoxRect();
+    const IntRect& scrollCorner = scrollCornerRect();
+    IntRect absBounds(borderBox.location() + offsetFromLayer, borderBox.size());
     if (m_vBar)
-        m_vBar->setFrameRect(LayoutRect(absBounds.maxX() - box->borderRight() - m_vBar->width(),
-                                        absBounds.y() + box->borderTop(),
-                                        m_vBar->width(),
-                                        absBounds.height() - (box->borderTop() + box->borderBottom()) - scrollCorner.height()));
+        m_vBar->setFrameRect(IntRect(absBounds.maxX() - box->borderRight() - m_vBar->width(),
+                                     absBounds.y() + box->borderTop(),
+                                     m_vBar->width(),
+                                     absBounds.height() - (box->borderTop() + box->borderBottom()) - scrollCorner.height()));
 
     if (m_hBar)
-        m_hBar->setFrameRect(LayoutRect(absBounds.x() + box->borderLeft(),
-                                        absBounds.maxY() - box->borderBottom() - m_hBar->height(),
-                                        absBounds.width() - (box->borderLeft() + box->borderRight()) - scrollCorner.width(),
-                                        m_hBar->height()));
+        m_hBar->setFrameRect(IntRect(absBounds.x() + box->borderLeft(),
+                                     absBounds.maxY() - box->borderBottom() - m_hBar->height(),
+                                     absBounds.width() - (box->borderLeft() + box->borderRight()) - scrollCorner.width(),
+                                     m_hBar->height()));
 
 #if USE(ACCELERATED_COMPOSITING)
     if (GraphicsLayer* layer = layerForHorizontalScrollbar()) {
@@ -2207,7 +2207,7 @@ void RenderLayer::computeScrollDimensions(bool* needHBar, bool* needVBar)
     m_scrollSize.setWidth(overflowRight() - overflowLeft());
     m_scrollSize.setHeight(overflowBottom() - overflowTop());
     
-    setScrollOrigin(LayoutPoint(-m_scrollOverflow.width(), -m_scrollOverflow.height()));
+    setScrollOrigin(IntPoint(-m_scrollOverflow.width(), -m_scrollOverflow.height()));
 
     if (needHBar)
         *needHBar = m_scrollSize.width() > box->clientWidth();
@@ -2252,8 +2252,8 @@ void RenderLayer::updateScrollInfoAfterLayout()
     if (box->style()->overflowX() != OMARQUEE) {
         // Layout may cause us to be in an invalid scroll position.  In this case we need
         // to pull our scroll offsets back to the max (or push them up to the min).
-        LayoutUnit newX = max<LayoutUnit>(0, min(scrollXOffset(), scrollWidth() - box->clientWidth()));
-        LayoutUnit newY = max<LayoutUnit>(0, min(scrollYOffset(), scrollHeight() - box->clientHeight()));
+        int newX = max(0, min(scrollXOffset(), scrollWidth() - box->clientWidth()));
+        int newY = max(0, min(scrollYOffset(), scrollHeight() - box->clientHeight()));
         if (newX != scrollXOffset() || newY != scrollYOffset())
             scrollToOffset(newX, newY);
     }
@@ -2502,14 +2502,14 @@ bool RenderLayer::hitTestOverflowControls(HitTestResult& result, const LayoutPoi
     RenderBox* box = renderBox();
     ASSERT(box);
     
-    LayoutRect resizeControlRect;
+    IntRect resizeControlRect;
     if (renderer()->style()->resize() != RESIZE_NONE) {
         resizeControlRect = resizerCornerRect(this, box->borderBoxRect());
         if (resizeControlRect.contains(localPoint))
             return true;
     }
 
-    LayoutUnit resizeControlSize = max<LayoutUnit>(resizeControlRect.height(), 0);
+    int resizeControlSize = max(resizeControlRect.height(), 0);
 
     if (m_vBar) {
         LayoutRect vBarRect(box->width() - box->borderRight() - m_vBar->width(), 
@@ -2522,7 +2522,7 @@ bool RenderLayer::hitTestOverflowControls(HitTestResult& result, const LayoutPoi
         }
     }
 
-    resizeControlSize = max<LayoutUnit>(resizeControlRect.width(), 0);
+    resizeControlSize = max(resizeControlRect.width(), 0);
     if (m_hBar) {
         LayoutRect hBarRect(box->borderLeft(),
                             box->height() - box->borderBottom() - m_hBar->height(),
index 91ec8c7..355cbe2 100644 (file)
@@ -259,8 +259,8 @@ public:
     const LayoutPoint& location() const { return m_topLeft; }
     void setLocation(LayoutUnit x, LayoutUnit y) { m_topLeft = LayoutPoint(x, y); }
 
-    const LayoutSize& size() const { return m_layerSize; }
-    void setSize(const LayoutSize& size) { m_layerSize = size; }
+    const IntSize& size() const { return m_layerSize; }
+    void setSize(const IntSize& size) { m_layerSize = size; }
 
     LayoutRect rect() const { return LayoutRect(location(), size()); }
 
@@ -279,9 +279,9 @@ public:
 
     LayoutSize scrolledContentOffset() const { return scrollOffset() + m_scrollOverflow; }
 
-    LayoutUnit scrollXOffset() const { return m_scrollOffset.width() + scrollOrigin().x(); }
-    LayoutUnit scrollYOffset() const { return m_scrollOffset.height() + scrollOrigin().y(); }
-    LayoutSize scrollOffset() const { return LayoutSize(scrollXOffset(), scrollYOffset()); }
+    int scrollXOffset() const { return m_scrollOffset.width() + scrollOrigin().x(); }
+    int scrollYOffset() const { return m_scrollOffset.height() + scrollOrigin().y(); }
+    IntSize scrollOffset() const { return IntSize(scrollXOffset(), scrollYOffset()); }
 
     void scrollToOffset(LayoutUnit, LayoutUnit, ScrollOffsetClamping = ScrollOffsetUnclamped);
     void scrollToXOffset(LayoutUnit x, ScrollOffsetClamping clamp = ScrollOffsetUnclamped) { scrollToOffset(x, scrollYOffset(), clamp); }
@@ -592,42 +592,42 @@ private:
 
     bool shouldBeNormalFlowOnly() const; 
 
-    LayoutUnit scrollPosition(Scrollbar*) const;
+    int scrollPosition(Scrollbar*) const;
     
     // ScrollableArea interface
-    virtual void invalidateScrollbarRect(Scrollbar*, const LayoutRect&);
-    virtual void invalidateScrollCornerRect(const LayoutRect&);
+    virtual void invalidateScrollbarRect(Scrollbar*, const IntRect&);
+    virtual void invalidateScrollCornerRect(const IntRect&);
     virtual bool isActive() const;
     virtual bool isScrollCornerVisible() const;
-    virtual LayoutRect scrollCornerRect() const;
-    virtual LayoutRect convertFromScrollbarToContainingView(const Scrollbar*, const LayoutRect&) const;
-    virtual LayoutRect convertFromContainingViewToScrollbar(const Scrollbar*, const LayoutRect&) const;
-    virtual LayoutPoint convertFromScrollbarToContainingView(const Scrollbar*, const LayoutPoint&) const;
-    virtual LayoutPoint convertFromContainingViewToScrollbar(const Scrollbar*, const LayoutPoint&) const;
-    virtual LayoutUnit scrollSize(ScrollbarOrientation) const;
-    virtual void setScrollOffset(const LayoutPoint&);
-    virtual LayoutPoint scrollPosition() const;
-    virtual LayoutPoint minimumScrollPosition() const;
-    virtual LayoutPoint maximumScrollPosition() const;
+    virtual IntRect scrollCornerRect() const;
+    virtual IntRect convertFromScrollbarToContainingView(const Scrollbar*, const IntRect&) const;
+    virtual IntRect convertFromContainingViewToScrollbar(const Scrollbar*, const IntRect&) const;
+    virtual IntPoint convertFromScrollbarToContainingView(const Scrollbar*, const IntPoint&) const;
+    virtual IntPoint convertFromContainingViewToScrollbar(const Scrollbar*, const IntPoint&) const;
+    virtual int scrollSize(ScrollbarOrientation) const;
+    virtual void setScrollOffset(const IntPoint&);
+    virtual IntPoint scrollPosition() const;
+    virtual IntPoint minimumScrollPosition() const;
+    virtual IntPoint maximumScrollPosition() const;
     virtual IntRect visibleContentRect(bool includeScrollbars) const;
-    virtual LayoutUnit visibleHeight() const;
-    virtual LayoutUnit visibleWidth() const;
-    virtual LayoutSize contentsSize() const;
-    virtual LayoutSize overhangAmount() const;
-    virtual LayoutPoint currentMousePosition() const;
-    virtual void didCompleteRubberBand(const LayoutSize&) const;
+    virtual int visibleHeight() const;
+    virtual int visibleWidth() const;
+    virtual IntSize contentsSize() const;
+    virtual IntSize overhangAmount() const;
+    virtual IntPoint currentMousePosition() const;
+    virtual void didCompleteRubberBand(const IntSize&) const;
     virtual bool shouldSuspendScrollAnimations() const;
     virtual bool isOnActivePage() const;
 
     // Rectangle encompassing the scroll corner and resizer rect.
-    LayoutRect scrollCornerAndResizerRect() const;
+    IntRect scrollCornerAndResizerRect() const;
 
     virtual void disconnectFromPage() { m_scrollableAreaPage = 0; }
 
     // NOTE: This should only be called by the overriden setScrollOffset from ScrollableArea.
-    void scrollTo(LayoutUnit, LayoutUnit);
+    void scrollTo(int, int);
 
-    LayoutSize scrollbarOffset(const Scrollbar*) const;
+    IntSize scrollbarOffset(const Scrollbar*) const;
     
     void updateOverflowStatus(bool horizontalOverflow, bool verticalOverflow);
 
@@ -755,15 +755,15 @@ protected:
     LayoutPoint m_topLeft;
 
     // The layer's width/height
-    LayoutSize m_layerSize;
+    IntSize m_layerSize;
 
     // Our scroll offsets if the view is scrolled.
-    LayoutSize m_scrollOffset;
+    IntSize m_scrollOffset;
 
     LayoutSize m_scrollOverflow;
     
     // The width/height of our scrolled area.
-    LayoutSize m_scrollSize;
+    IntSize m_scrollSize;
 
     // For layers with overflow, we have a pair of scrollbars.
     RefPtr<Scrollbar> m_hBar;
index 9e1e376..04e4d69 100644 (file)
@@ -541,7 +541,7 @@ int RenderListBox::scrollToward(const IntPoint& destination)
 
 void RenderListBox::autoscroll()
 {
-    LayoutPoint pos = frame()->view()->windowToContents(frame()->eventHandler()->currentMousePosition());
+    IntPoint pos = frame()->view()->windowToContents(frame()->eventHandler()->currentMousePosition());
 
     int endIndex = scrollToward(pos);
     if (endIndex >= 0) {
@@ -708,91 +708,91 @@ bool RenderListBox::isActive() const
     return page && page->focusController()->isActive();
 }
 
-void RenderListBox::invalidateScrollbarRect(Scrollbar* scrollbar, const LayoutRect& rect)
+void RenderListBox::invalidateScrollbarRect(Scrollbar* scrollbar, const IntRect& rect)
 {
-    LayoutRect scrollRect = rect;
+    IntRect scrollRect = rect;
     scrollRect.move(width() - borderRight() - scrollbar->width(), borderTop());
     repaintRectangle(scrollRect);
 }
 
-LayoutRect RenderListBox::convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const LayoutRect& scrollbarRect) const
+IntRect RenderListBox::convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const IntRect& scrollbarRect) const
 {
     RenderView* view = this->view();
     if (!view)
         return scrollbarRect;
 
-    LayoutRect rect = scrollbarRect;
+    IntRect rect = scrollbarRect;
 
-    LayoutUnit scrollbarLeft = width() - borderRight() - scrollbar->width();
-    LayoutUnit scrollbarTop = borderTop();
+    int scrollbarLeft = width() - borderRight() - scrollbar->width();
+    int scrollbarTop = borderTop();
     rect.move(scrollbarLeft, scrollbarTop);
 
     return view->frameView()->convertFromRenderer(this, rect);
 }
 
-LayoutRect RenderListBox::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const LayoutRect& parentRect) const
+IntRect RenderListBox::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const IntRect& parentRect) const
 {
     RenderView* view = this->view();
     if (!view)
         return parentRect;
 
-    LayoutRect rect = view->frameView()->convertToRenderer(this, parentRect);
+    IntRect rect = view->frameView()->convertToRenderer(this, parentRect);
 
-    LayoutUnit scrollbarLeft = width() - borderRight() - scrollbar->width();
-    LayoutUnit scrollbarTop = borderTop();
+    int scrollbarLeft = width() - borderRight() - scrollbar->width();
+    int scrollbarTop = borderTop();
     rect.move(-scrollbarLeft, -scrollbarTop);
     return rect;
 }
 
-LayoutPoint RenderListBox::convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const LayoutPoint& scrollbarPoint) const
+IntPoint RenderListBox::convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const IntPoint& scrollbarPoint) const
 {
     RenderView* view = this->view();
     if (!view)
         return scrollbarPoint;
 
-    LayoutPoint point = scrollbarPoint;
+    IntPoint point = scrollbarPoint;
 
-    LayoutUnit scrollbarLeft = width() - borderRight() - scrollbar->width();
-    LayoutUnit scrollbarTop = borderTop();
+    int scrollbarLeft = width() - borderRight() - scrollbar->width();
+    int scrollbarTop = borderTop();
     point.move(scrollbarLeft, scrollbarTop);
 
     return view->frameView()->convertFromRenderer(this, point);
 }
 
-LayoutPoint RenderListBox::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const LayoutPoint& parentPoint) const
+IntPoint RenderListBox::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const IntPoint& parentPoint) const
 {
     RenderView* view = this->view();
     if (!view)
         return parentPoint;
 
-    LayoutPoint point = view->frameView()->convertToRenderer(this, parentPoint);
+    IntPoint point = view->frameView()->convertToRenderer(this, parentPoint);
 
-    LayoutUnit scrollbarLeft = width() - borderRight() - scrollbar->width();
-    LayoutUnit scrollbarTop = borderTop();
+    int scrollbarLeft = width() - borderRight() - scrollbar->width();
+    int scrollbarTop = borderTop();
     point.move(-scrollbarLeft, -scrollbarTop);
     return point;
 }
 
-LayoutSize RenderListBox::contentsSize() const
+IntSize RenderListBox::contentsSize() const
 {
-    return LayoutSize(scrollWidth(), scrollHeight());
+    return IntSize(scrollWidth(), scrollHeight());
 }
 
-LayoutUnit RenderListBox::visibleHeight() const
+int RenderListBox::visibleHeight() const
 {
     return height();
 }
 
-LayoutUnit RenderListBox::visibleWidth() const
+int RenderListBox::visibleWidth() const
 {
     return width();
 }
 
-LayoutPoint RenderListBox::currentMousePosition() const
+IntPoint RenderListBox::currentMousePosition() const
 {
     RenderView* view = this->view();
     if (!view)
-        return LayoutPoint();
+        return IntPoint();
     return view->frameView()->currentMousePosition();
 }
 
index 522c255..3e165ae 100644 (file)
@@ -102,20 +102,20 @@ private:
     virtual LayoutUnit scrollSize(ScrollbarOrientation) const;
     virtual LayoutUnit scrollPosition(Scrollbar*) const;
     virtual void setScrollOffset(const LayoutPoint&);
-    virtual void invalidateScrollbarRect(Scrollbar*, const LayoutRect&);
+    virtual void invalidateScrollbarRect(Scrollbar*, const IntRect&);
     virtual bool isActive() const;
     virtual bool isScrollCornerVisible() const { return false; } // We don't support resize on list boxes yet. If we did these would have to change.
-    virtual LayoutRect scrollCornerRect() const { return LayoutRect(); }
-    virtual void invalidateScrollCornerRect(const LayoutRect&) { }
-    virtual LayoutRect convertFromScrollbarToContainingView(const Scrollbar*, const LayoutRect&) const;
-    virtual LayoutRect convertFromContainingViewToScrollbar(const Scrollbar*, const LayoutRect&) const;
-    virtual LayoutPoint convertFromScrollbarToContainingView(const Scrollbar*, const LayoutPoint&) const;
-    virtual LayoutPoint convertFromContainingViewToScrollbar(const Scrollbar*, const LayoutPoint&) const;
+    virtual IntRect scrollCornerRect() const { return IntRect(); }
+    virtual void invalidateScrollCornerRect(const IntRect&) { }
+    virtual IntRect convertFromScrollbarToContainingView(const Scrollbar*, const IntRect&) const;
+    virtual IntRect convertFromContainingViewToScrollbar(const Scrollbar*, const IntRect&) const;
+    virtual IntPoint convertFromScrollbarToContainingView(const Scrollbar*, const IntPoint&) const;
+    virtual IntPoint convertFromContainingViewToScrollbar(const Scrollbar*, const IntPoint&) const;
     virtual Scrollbar* verticalScrollbar() const { return m_vBar.get(); }
-    virtual LayoutSize contentsSize() const;
-    virtual LayoutUnit visibleHeight() const;
-    virtual LayoutUnit visibleWidth() const;
-    virtual LayoutPoint currentMousePosition() const;
+    virtual IntSize contentsSize() const;
+    virtual int visibleHeight() const;
+    virtual int visibleWidth() const;
+    virtual IntPoint currentMousePosition() const;
     virtual bool shouldSuspendScrollAnimations() const;
     virtual bool isOnActivePage() const;
 
index 6621603..7da2737 100644 (file)
@@ -502,13 +502,13 @@ int RenderMenuList::clientInsetRight() const
     return 0;
 }
 
-LayoutUnit RenderMenuList::clientPaddingLeft() const
+int RenderMenuList::clientPaddingLeft() const
 {
     return paddingLeft() + m_innerBlock->paddingLeft();
 }
 
 const int endOfLinePadding = 2;
-LayoutUnit RenderMenuList::clientPaddingRight() const
+int RenderMenuList::clientPaddingRight() const
 {
     if (style()->appearance() == MenulistPart || style()->appearance() == MenulistButtonPart) {
         // For these appearance values, the theme applies padding to leave room for the
index 8ce18fa..44c95aa 100644 (file)
@@ -92,8 +92,8 @@ private:
     virtual PopupMenuStyle menuStyle() const;
     virtual int clientInsetLeft() const;
     virtual int clientInsetRight() const;
-    virtual LayoutUnit clientPaddingLeft() const;
-    virtual LayoutUnit clientPaddingRight() const;
+    virtual int clientPaddingLeft() const;
+    virtual int clientPaddingRight() const;
     virtual int listSize() const;
     virtual int selectedIndex() const;
     virtual void popupDidHide();
index 9cf89d1..ff90770 100644 (file)
@@ -628,9 +628,9 @@ int RenderTextControlSingleLine::clientInsetRight() const
     return height() / 2;
 }
 
-LayoutUnit RenderTextControlSingleLine::clientPaddingLeft() const
+int RenderTextControlSingleLine::clientPaddingLeft() const
 {
-    LayoutUnit padding = paddingLeft();
+    int padding = paddingLeft();
 
     HTMLElement* resultsButton = resultsButtonElement();
     if (RenderBox* resultsRenderer = resultsButton ? resultsButton->renderBox() : 0)
@@ -639,9 +639,9 @@ LayoutUnit RenderTextControlSingleLine::clientPaddingLeft() const
     return padding;
 }
 
-LayoutUnit RenderTextControlSingleLine::clientPaddingRight() const
+int RenderTextControlSingleLine::clientPaddingRight() const
 {
-    LayoutUnit padding = paddingRight();
+    int padding = paddingRight();
 
     HTMLElement* cancelButton = cancelButtonElement();
     if (RenderBox* cancelRenderer = cancelButton ? cancelButton->renderBox() : 0)
index 6cfcfe3..474d353 100644 (file)
@@ -102,8 +102,8 @@ private:
     virtual PopupMenuStyle menuStyle() const;
     virtual int clientInsetLeft() const;
     virtual int clientInsetRight() const;
-    virtual LayoutUnit clientPaddingLeft() const;
-    virtual LayoutUnit clientPaddingRight() const;
+    virtual int clientPaddingLeft() const;
+    virtual int clientPaddingRight() const;
     virtual int listSize() const;
     virtual int selectedIndex() const;
     virtual void popupDidHide();
index 8751514..749a37a 100644 (file)
@@ -1,3 +1,17 @@
+2011-11-07  Emil A Eklund  <eae@chromium.org>
+
+        Revert platform and scrolling to ints
+        https://bugs.webkit.org/show_bug.cgi?id=71585
+
+        Reviewed by Eric Seidel.
+
+        Replace all uses of LayoutUnit and related types with ints in platform
+        and scrolling code.
+
+        * tests/ScrollAnimatorNoneTest.cpp:
+        (MockScrollableArea::visibleHeight):
+        (MockScrollableArea::visibleWidth):
+
 2011-11-07  Adam Barth  <abarth@webkit.org>
 
         Move DomainRelaxationForbidden scheme registry to SchemeRegistry
index 13c934d..85cca90 100644 (file)
@@ -64,8 +64,8 @@ public:
     MOCK_METHOD1(setScrollOffsetFromAnimation, void(const IntPoint&));
     MOCK_CONST_METHOD0(enclosingScrollableArea, ScrollableArea*());
 
-    virtual LayoutUnit visibleHeight() const { return 768; }
-    virtual LayoutUnit visibleWidth() const { return 1024; }
+    virtual int visibleHeight() const { return 768; }
+    virtual int visibleWidth() const { return 1024; }
 
     bool scrollAnimatorEnabled() const { return m_scrollAnimatorEnabled; }
     bool m_scrollAnimatorEnabled;
index 05066f3..5ad5f4f 100644 (file)
@@ -1,3 +1,19 @@
+2011-11-07  Emil A Eklund  <eae@chromium.org>
+
+        Revert platform and scrolling to ints
+        https://bugs.webkit.org/show_bug.cgi?id=71585
+
+        Reviewed by Eric Seidel.
+
+        Replace all uses of LayoutUnit and related types with ints in platform
+        and scrolling code.
+
+        * WebProcess/Plugins/PDF/BuiltInPDFView.cpp:
+        (WebKit::BuiltInPDFView::invalidateScrollbarRect):
+        (WebKit::BuiltInPDFView::visibleHeight):
+        (WebKit::BuiltInPDFView::visibleWidth):
+        * WebProcess/Plugins/PDF/BuiltInPDFView.h:
+
 2011-11-07  Adam Barth  <abarth@webkit.org>
 
         Move DomainRelaxationForbidden scheme registry to SchemeRegistry
index c0d2b68..88b05af 100644 (file)
@@ -606,7 +606,7 @@ bool BuiltInPDFView::isActive() const
 
 void BuiltInPDFView::invalidateScrollbarRect(Scrollbar* scrollbar, const LayoutRect& rect)
 {
-    LayoutRect dirtyRect = rect;
+    IntRect dirtyRect = rect;
     dirtyRect.moveBy(scrollbar->location());
     dirtyRect.moveBy(-pluginView()->location());
     controller()->invalidate(dirtyRect);
@@ -652,12 +652,12 @@ IntPoint BuiltInPDFView::maximumScrollPosition() const
     return maximumOffset;
 }
 
-LayoutUnit BuiltInPDFView::visibleHeight() const
+int BuiltInPDFView::visibleHeight() const
 {
     return m_pluginSize.height();
 }
 
-LayoutUnit BuiltInPDFView::visibleWidth() const
+int BuiltInPDFView::visibleWidth() const
 {
     return m_pluginSize.width();
 }
index 0d28a98..9960cae 100644 (file)
@@ -126,8 +126,8 @@ private:
     virtual WebCore::IntPoint scrollPosition() const;
     virtual WebCore::IntPoint minimumScrollPosition() const;
     virtual WebCore::IntPoint maximumScrollPosition() const;
-    virtual WebCore::LayoutUnit visibleHeight() const;
-    virtual WebCore::LayoutUnit visibleWidth() const;
+    virtual int visibleHeight() const;
+    virtual int visibleWidth() const;
     virtual WebCore::IntSize contentsSize() const;
     virtual WebCore::Scrollbar* horizontalScrollbar() const  { return m_horizontalScrollbar.get(); }
     virtual WebCore::Scrollbar* verticalScrollbar() const { return m_verticalScrollbar.get(); }