Removed redundant rect methods on FrameView

Source/core/frame/FrameView.cpp

 /*
  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
  *                     1999 Lars Knoll <knoll@kde.org>
  *                     1999 Antti Koivisto <koivisto@kde.org>
  *                     2000 Dirk Mueller <mueller@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *           (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
@@ skipping 107 matching lines @@
     , m_postLayoutTasksTimer(this, &FrameView::postLayoutTimerFired)
     , m_updateWidgetsTimer(this, &FrameView::updateWidgetsTimerFired)
     , m_isTransparent(false)
     , m_baseBackgroundColor(Color::white)
     , m_mediaType(MediaTypeNames::screen)
     , m_overflowStatusDirty(true)
     , m_wasScrolledByUser(false)
     , m_safeToPropagateScrollToParent(true)
     , m_isTrackingPaintInvalidations(false)
     , m_scrollCorner(nullptr)
-    , m_visibleContentScaleFactor(1)
     , m_inputEventsScaleFactorForEmulation(1)
     , m_layoutSizeFixedToFrameSize(true)
     , m_didScrollTimer(this, &FrameView::didScrollTimerFired)
     , m_topControlsViewportAdjustment(0)
     , m_needsUpdateWidgetPositions(false)
 #if ENABLE(ASSERT)
     , m_hasBeenDisposed(false)
 #endif
     , m_horizontalScrollbarMode(ScrollbarAuto)
     , m_verticalScrollbarMode(ScrollbarAuto)
@@ skipping 261 matching lines @@
     updateScrollbars(scrollOffsetDouble());
     frameRectsChanged();
 
     updateScrollableAreaSet();
 
     if (LayoutView* layoutView = this->layoutView()) {
         if (layoutView->usesCompositing())
             layoutView->compositor()->frameViewDidChangeSize();
     }
 
-    viewportConstrainedVisibleContentSizeChanged(newRect.width() != oldRect.width(), newRect.height() != oldRect.height());
+    viewportSizeChanged(newRect.width() != oldRect.width(), newRect.height() != oldRect.height());
 
     if (oldRect.size() != newRect.size() && m_frame->isMainFrame())
         page()->frameHost().pinchViewport().mainFrameDidChangeSize();
 }
 
 Page* FrameView::page() const
 {
     return frame().page();
 }
 
@@ skipping 89 matching lines @@
         return;
 
     updateScrollableAreaSet();
 
     page->chrome().contentsSizeChanged(m_frame.get(), size);
 }
 
 IntPoint FrameView::clampOffsetAtScale(const IntPoint& offset, float scale) const
 {
     IntPoint maxScrollExtent(contentsSize().width() - scrollOrigin().x(), contentsSize().height() - scrollOrigin().y());
-    FloatSize scaledSize = unscaledVisibleContentSize();
+    FloatSize scaledSize = visibleContentSize();
     if (scale)
         scaledSize.scale(1 / scale);
 
     IntPoint clampedOffset = offset;
     clampedOffset = clampedOffset.shrunkTo(maxScrollExtent - expandedIntSize(scaledSize));
     clampedOffset = clampedOffset.expandedTo(-scrollOrigin());
 
     return clampedOffset;
 }
 
@@ skipping 737 matching lines @@
 void FrameView::removeViewportConstrainedObject(LayoutObject* object)
 {
     if (m_viewportConstrainedObjects && m_viewportConstrainedObjects->contains(object)) {
         m_viewportConstrainedObjects->remove(object);
 
         if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
             scrollingCoordinator->frameViewFixedObjectsDidChange(this);
     }
 }
 
-LayoutRect FrameView::viewportConstrainedVisibleContentRect() const
-{
-    LayoutRect viewportRect = LayoutRect(visibleContentRect());
-    viewportRect.setLocation(clampScrollPosition(scrollPosition()));
-    return viewportRect;
-}
-
-void FrameView::viewportConstrainedVisibleContentSizeChanged(bool widthChanged, bool heightChanged)
+void FrameView::viewportSizeChanged(bool widthChanged, bool heightChanged)
 {
     if (!hasViewportConstrainedObjects())
         return;
 
     for (const auto& viewportConstrainedObject : *m_viewportConstrainedObjects) {
         LayoutObject* layoutObject = viewportConstrainedObject;
         const ComputedStyle& style = layoutObject->styleRef();
         if (widthChanged) {
             if (style.width().isFixed() && (style.left().isAuto() || style.right().isAuto()))
                 layoutObject->setNeedsPositionedMovementLayout();
             else
                 layoutObject->setNeedsLayoutAndFullPaintInvalidation(LayoutInvalidationReason::SizeChanged);
         }
         if (heightChanged) {
             if (style.height().isFixed() && (style.top().isAuto() || style.bottom().isAuto()))
                 layoutObject->setNeedsPositionedMovementLayout();
             else
                 layoutObject->setNeedsLayoutAndFullPaintInvalidation(LayoutInvalidationReason::SizeChanged);
         }
     }
 }
 
-IntSize FrameView::scrollOffsetForViewportConstrainedObjects() const
-{
-    return roundedIntSize(viewportConstrainedVisibleContentRect().location());
-}
-
 IntPoint FrameView::lastKnownMousePosition() const
 {
     return m_frame->eventHandler().lastKnownMousePosition();
 }
 
 bool FrameView::shouldSetCursor() const
 {
     Page* page = frame().page();
     return page && page->visibilityState() != PageVisibilityStateHidden && page->focusController().isActive() && page->settings().deviceSupportsMouse();
 }
@@ skipping 924 matching lines @@
 }
 
 IntRect FrameView::windowResizerRect() const
 {
     Page* page = frame().page();
     if (!page)
         return IntRect();
     return page->chrome().windowResizerRect();
 }
 
-void FrameView::setVisibleContentScaleFactor(float visibleContentScaleFactor)
-{
-    if (m_visibleContentScaleFactor == visibleContentScaleFactor)
-        return;
-
-    m_visibleContentScaleFactor = visibleContentScaleFactor;
-    updateScrollbars(scrollOffsetDouble());
-}
-
 void FrameView::setInputEventsTransformForEmulation(const IntSize& offset, float contentScaleFactor)
 {
     m_inputEventsOffsetForEmulation = offset;
     m_inputEventsScaleFactorForEmulation = contentScaleFactor;
 }
 
 IntSize FrameView::inputEventsOffsetForEmulation() const
 {
     return m_inputEventsOffsetForEmulation;
 }
@@ skipping 790 matching lines @@
 
 void FrameView::setTopControlsViewportAdjustment(float adjustment)
 {
     m_topControlsViewportAdjustment = adjustment;
 }
 
 IntPoint FrameView::maximumScrollPosition() const
 {
     // Make the same calculation as in CC's LayerImpl::MaxScrollOffset()
     // FIXME: We probably shouldn't be storing the bounds in a float. crbug.com/422331.
-    FloatSize visibleSize = unscaledVisibleContentSize(ExcludeScrollbars);
+    FloatSize visibleSize = visibleContentSize(ExcludeScrollbars);
     visibleSize.expand(0, m_topControlsViewportAdjustment);
 
     FloatSize contentBounds = contentsSize();
-    contentBounds.scale(visibleContentScaleFactor());
     contentBounds = flooredIntSize(contentBounds);
 
     FloatSize maximumOffset = contentBounds - visibleSize - toIntSize(scrollOrigin());
 
-    // Convert back to CSS pixels.
-    maximumOffset.scale(1 / visibleContentScaleFactor());
-
     IntPoint snappedMaximumOffset = flooredIntPoint(maximumOffset);
     snappedMaximumOffset.clampNegativeToZero();
     return snappedMaximumOffset;
 }
 
 void FrameView::addChild(PassRefPtrWillBeRawPtr<Widget> prpChild)
 {
     Widget* child = prpChild.get();
     ASSERT(child != this && !child->parent());
     child->setParent(this);
@@ skipping 90 matching lines @@
     if (!layer)
         return;
     layer->setUserScrollable(userInputScrollable(HorizontalScrollbar), userInputScrollable(VerticalScrollbar));
 }
 
 void FrameView::setClipsRepaints(bool clipsRepaints)
 {
     m_clipsRepaints = clipsRepaints;
 }
 
-IntSize FrameView::unscaledVisibleContentSize(IncludeScrollbarsInRect scrollbarInclusion) const
+IntSize FrameView::visibleContentSize(IncludeScrollbarsInRect scrollbarInclusion) const
 {
     return scrollbarInclusion == ExcludeScrollbars ? excludeScrollbars(frameRect().size()) : frameRect().size();
 }
 
-IntRect FrameView::visibleContentRect(IncludeScrollbarsInRect scollbarInclusion) const
+IntRect FrameView::visibleContentRect(IncludeScrollbarsInRect scrollbarInclusion) const
 {
-    FloatSize visibleContentSize = unscaledVisibleContentSize(scollbarInclusion);
-    visibleContentSize.scale(1 / visibleContentScaleFactor());
-    return IntRect(flooredIntPoint(m_scrollPosition), expandedIntSize(visibleContentSize));
+    return IntRect(flooredIntPoint(m_scrollPosition), visibleContentSize(scrollbarInclusion));
 }
 
 IntSize FrameView::contentsSize() const
 {
     return m_contentsSize;
 }
 
 IntPoint FrameView::minimumScrollPosition() const
 {
     return IntPoint(-scrollOrigin().x(), -scrollOrigin().y());
@@ skipping 218 matching lines @@
 {
     if (scrollbarsDisabled()) {
         setScrollOffsetFromUpdateScrollbars(desiredOffset);
         return;
     }
 
     if (m_inUpdateScrollbars)
         return;
     InUpdateScrollbarsScope inUpdateScrollbarsScope(this);
 
-    IntSize oldVisibleSize = visibleSize();
+    IntSize oldVisibleSize = visibleContentSize();
 
     bool scrollbarExistenceChanged = false;
 
     if (needsScrollbarReconstruction()) {
         setHasHorizontalScrollbar(false);
         setHasVerticalScrollbar(false);
         scrollbarExistenceChanged = true;
     }
 
     int maxUpdateScrollbarsPass = hasOverlayScrollbars() || m_scrollbarsSuppressed ? 1 : 3;
     for (int updateScrollbarsPass = 0; updateScrollbarsPass < maxUpdateScrollbarsPass; updateScrollbarsPass++) {
         if (!adjustScrollbarExistence(updateScrollbarsPass ? Incremental : FirstPass))
             break;
         scrollbarExistenceChanged = true;
     }
 
     updateScrollbarGeometry();
 
     if (scrollbarExistenceChanged) {
         // FIXME: Is frameRectsChanged really necessary here? Have any frame rects changed?
         frameRectsChanged();
         positionScrollbarLayers();
         updateScrollCorner();
     }
 
     // FIXME: We don't need to do this if we are composited.
-    IntSize newVisibleSize = visibleSize();
+    IntSize newVisibleSize = visibleContentSize();
     if (newVisibleSize.width() > oldVisibleSize.width()) {
         if (shouldPlaceVerticalScrollbarOnLeft())
             invalidateRect(IntRect(0, 0, newVisibleSize.width() - oldVisibleSize.width(), newVisibleSize.height()));
         else
             invalidateRect(IntRect(oldVisibleSize.width(), 0, newVisibleSize.width() - oldVisibleSize.width(), newVisibleSize.height()));
     }
     if (newVisibleSize.height() > oldVisibleSize.height())
         invalidateRect(IntRect(0, oldVisibleSize.height(), newVisibleSize.width(), newVisibleSize.height() - oldVisibleSize.height()));
 
     setScrollOffsetFromUpdateScrollbars(desiredOffset);
@@ skipping 566 matching lines @@
 
     if (!graphicsLayer)
         return;
 
     DeprecatedPaintLayer::mapRectToPaintInvalidationBacking(localFrame->contentLayoutObject(), paintInvalidationContainer, viewRect);
 
     graphicsLayerTimingRequests.add(graphicsLayer, Vector<std::pair<int64_t, WebRect>>()).storedValue->value.append(std::make_pair(m_frame->frameID(), enclosingIntRect(viewRect)));
 }
 
 } // namespace blink