Remove grow box rect support, renderer part.

third_party/WebKit/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 159 matching lines @@
       m_needsUpdateWidgetGeometries(false),
       m_needsUpdateViewportIntersection(true),
       m_needsUpdateViewportIntersectionInSubtree(true),
 #if ENABLE(ASSERT)
       m_hasBeenDisposed(false),
 #endif
       m_horizontalScrollbarMode(ScrollbarAuto),
       m_verticalScrollbarMode(ScrollbarAuto),
       m_horizontalScrollbarLock(false),
       m_verticalScrollbarLock(false),
-      m_scrollbarsAvoidingResizer(0),
       m_scrollbarsSuppressed(false),
       m_inUpdateScrollbars(false),
       m_frameTimingRequestsDirty(true),
       m_viewportIntersectionValid(false),
       m_hiddenForThrottling(false),
       m_crossOriginForThrottling(false),
       m_subtreeThrottled(false),
       m_currentUpdateLifecyclePhasesTargetState(
           DocumentLifecycle::Uninitialized),
       m_scrollAnchor(this),
@@ skipping 2113 matching lines @@
 }
 
 void FrameView::getTickmarks(Vector<IntRect>& tickmarks) const {
   if (!m_tickmarks.isEmpty())
     tickmarks = m_tickmarks;
   else
     tickmarks = frame().document()->markers().renderedRectsForMarkers(
         DocumentMarker::TextMatch);
 }
 
-IntRect FrameView::windowResizerRect() const {
-  if (Page* page = frame().page())
-    return page->chromeClient().windowResizerRect(frame());
-  return IntRect();
-}
-
 void FrameView::setInputEventsTransformForEmulation(const IntSize& offset,
                                                     float contentScaleFactor) {
   m_inputEventsOffsetForEmulation = offset;
   m_inputEventsScaleFactorForEmulation = contentScaleFactor;
 }
 
 IntSize FrameView::inputEventsOffsetForEmulation() const {
   return m_inputEventsOffsetForEmulation;
 }
 
@@ skipping 1011 matching lines @@
 void FrameView::removeAnimatingScrollableArea(ScrollableArea* scrollableArea) {
   if (!m_animatingScrollableAreas)
     return;
   m_animatingScrollableAreas->remove(scrollableArea);
 }
 
 void FrameView::setParent(Widget* parentView) {
   if (parentView == parent())
     return;
 
-  if (m_scrollbarsAvoidingResizer && parent())
-    toFrameView(parent())->adjustScrollbarsAvoidingResizerCount(
-        -m_scrollbarsAvoidingResizer);
-
   Widget::setParent(parentView);
 
-  if (m_scrollbarsAvoidingResizer && parent())
-    toFrameView(parent())->adjustScrollbarsAvoidingResizerCount(
-        m_scrollbarsAvoidingResizer);
-
   updateScrollableAreaSet();
   setNeedsUpdateViewportIntersection();
 }
 
 void FrameView::removeChild(Widget* child) {
   ASSERT(child->parent() == this);
 
   if (child->isFrameView())
     removeScrollableArea(toFrameView(child));
 
@@ skipping 68 matching lines @@
   if (hasBar == !!m_horizontalScrollbar)
     return;
 
   if (hasBar) {
     m_horizontalScrollbar = createScrollbar(HorizontalScrollbar);
     addChild(m_horizontalScrollbar.get());
     didAddScrollbar(*m_horizontalScrollbar, HorizontalScrollbar);
     m_horizontalScrollbar->styleChanged();
   } else {
     willRemoveScrollbar(*m_horizontalScrollbar, HorizontalScrollbar);
-    // If the scrollbar has been marked as overlapping the window resizer,
-    // then its removal should reduce the count.
-    if (m_horizontalScrollbar->overlapsResizer())
-      adjustScrollbarsAvoidingResizerCount(-1);
     removeChild(m_horizontalScrollbar.get());
     m_horizontalScrollbar->disconnectFromScrollableArea();
     m_horizontalScrollbar = nullptr;
   }
 
   setScrollCornerNeedsPaintInvalidation();
 }
 
 void FrameView::setHasVerticalScrollbar(bool hasBar) {
   if (hasBar == !!m_verticalScrollbar)
     return;
 
   if (hasBar) {
     m_verticalScrollbar = createScrollbar(VerticalScrollbar);
     addChild(m_verticalScrollbar.get());
     didAddScrollbar(*m_verticalScrollbar, VerticalScrollbar);
     m_verticalScrollbar->styleChanged();
   } else {
     willRemoveScrollbar(*m_verticalScrollbar, VerticalScrollbar);
-    // If the scrollbar has been marked as overlapping the window resizer,
-    // then its removal should reduce the count.
-    if (m_verticalScrollbar->overlapsResizer())
-      adjustScrollbarsAvoidingResizerCount(-1);
     removeChild(m_verticalScrollbar.get());
     m_verticalScrollbar->disconnectFromScrollableArea();
     m_verticalScrollbar = nullptr;
   }
 
   setScrollCornerNeedsPaintInvalidation();
 }
 
 void FrameView::setScrollbarModes(ScrollbarMode horizontalMode,
                                   ScrollbarMode verticalMode,
@@ skipping 161 matching lines @@
   if (frame().isMainFrame())
     frame().host()->chromeClient().mainFrameScrollOffsetChanged();
 }
 
 void FrameView::clearScrollAnchor() {
   if (!RuntimeEnabledFeatures::scrollAnchoringEnabled())
     return;
   m_scrollAnchor.clear();
 }
 
-void FrameView::windowResizerRectChanged() {
-  updateScrollbars();
-}
-
 bool FrameView::hasOverlayScrollbars() const {
   return (m_horizontalScrollbar &&
           m_horizontalScrollbar->isOverlayScrollbar()) ||
          (m_verticalScrollbar && m_verticalScrollbar->isOverlayScrollbar());
 }
 
 void FrameView::computeScrollbarExistence(
     bool& newHasHorizontalScrollbar,
     bool& newHasVerticalScrollbar,
     const IntSize& docSize,
@@ skipping 51 matching lines @@
     int thickness = m_horizontalScrollbar->scrollbarThickness();
     int clientWidth = visibleWidth();
     IntRect oldRect(m_horizontalScrollbar->frameRect());
     IntRect hBarRect(
         (shouldPlaceVerticalScrollbarOnLeft() && m_verticalScrollbar)
             ? m_verticalScrollbar->width()
             : 0,
         height() - thickness,
         width() - (m_verticalScrollbar ? m_verticalScrollbar->width() : 0),
         thickness);
-    m_horizontalScrollbar->setFrameRect(
-        adjustScrollbarRectForResizer(hBarRect, *m_horizontalScrollbar));
+    m_horizontalScrollbar->setFrameRect(hBarRect);
     if (oldRect != m_horizontalScrollbar->frameRect())
       setScrollbarNeedsPaintInvalidation(HorizontalScrollbar);
 
     m_horizontalScrollbar->setEnabled(contentsWidth() > clientWidth);
     m_horizontalScrollbar->setProportion(clientWidth, contentsWidth());
     m_horizontalScrollbar->offsetDidChange();
   }
 
   if (m_verticalScrollbar) {
     int thickness = m_verticalScrollbar->scrollbarThickness();
     int clientHeight = visibleHeight();
     IntRect oldRect(m_verticalScrollbar->frameRect());
     IntRect vBarRect(
         shouldPlaceVerticalScrollbarOnLeft() ? 0 : (width() - thickness), 0,
         thickness,
         height() -
             (m_horizontalScrollbar ? m_horizontalScrollbar->height() : 0));
-    m_verticalScrollbar->setFrameRect(
-        adjustScrollbarRectForResizer(vBarRect, *m_verticalScrollbar));
+    m_verticalScrollbar->setFrameRect(vBarRect);
     if (oldRect != m_verticalScrollbar->frameRect())
       setScrollbarNeedsPaintInvalidation(VerticalScrollbar);
 
     m_verticalScrollbar->setEnabled(contentsHeight() > clientHeight);
     m_verticalScrollbar->setProportion(clientHeight, contentsHeight());
     m_verticalScrollbar->offsetDidChange();
   }
 }
 
-IntRect FrameView::adjustScrollbarRectForResizer(const IntRect& rect,
-                                                 Scrollbar& scrollbar) {
-  // Get our window resizer rect and see if we overlap. Adjust to avoid the
-  // overlap if necessary.
-  IntRect adjustedRect(rect);
-  bool overlapsResizer = false;
-  if (!rect.isEmpty() && !windowResizerRect().isEmpty()) {
-    IntRect resizerRect = convertFromRootFrame(windowResizerRect());
-    if (rect.intersects(resizerRect)) {
-      if (scrollbar.orientation() == HorizontalScrollbar) {
-        int overlap = rect.maxX() - resizerRect.x();
-        if (overlap > 0 && resizerRect.maxX() >= rect.maxX()) {
-          adjustedRect.setWidth(rect.width() - overlap);
-          overlapsResizer = true;
-        }
-      } else {
-        int overlap = rect.maxY() - resizerRect.y();
-        if (overlap > 0 && resizerRect.maxY() >= rect.maxY()) {
-          adjustedRect.setHeight(rect.height() - overlap);
-          overlapsResizer = true;
-        }
-      }
-    }
-  }
-  if (overlapsResizer != scrollbar.overlapsResizer()) {
-    scrollbar.setOverlapsResizer(overlapsResizer);
-    adjustScrollbarsAvoidingResizerCount(overlapsResizer ? 1 : -1);
-  }
-  return adjustedRect;
-}
-
 bool FrameView::adjustScrollbarExistence(
     ComputeScrollbarExistenceOption option) {
   ASSERT(m_inUpdateScrollbars);
 
   // If we came in here with the view already needing a layout, then go ahead
   // and do that first.  (This will be the common case, e.g., when the page
   // changes due to window resizing for example).  This layout will not re-enter
   // updateScrollbars and does not count towards our max layout pass total.
   if (!m_scrollbarsSuppressed)
     scrollbarExistenceDidChange();
@@ skipping 229 matching lines @@
 
 IntPoint FrameView::soonToBeRemovedUnscaledViewportToContents(
     const IntPoint& pointInViewport) const {
   IntPoint pointInRootFrame = flooredIntPoint(
       m_frame->host()->visualViewport().viewportCSSPixelsToRootFrame(
           pointInViewport));
   IntPoint pointInThisFrame = convertFromRootFrame(pointInRootFrame);
   return frameToContents(pointInThisFrame);
 }
 
-bool FrameView::containsScrollbarsAvoidingResizer() const {
-  return !m_scrollbarsAvoidingResizer;
-}
-
-void FrameView::adjustScrollbarsAvoidingResizerCount(int overlapDelta) {
-  int oldCount = m_scrollbarsAvoidingResizer;
-  m_scrollbarsAvoidingResizer += overlapDelta;
-  if (parent()) {
-    toFrameView(parent())->adjustScrollbarsAvoidingResizerCount(overlapDelta);
-  } else if (!scrollbarsSuppressed()) {
-    // If we went from n to 0 or from 0 to n and we're the outermost view,
-    // we need to invalidate the windowResizerRect(), since it will now need to
-    // paint differently.
-    if ((oldCount > 0 && m_scrollbarsAvoidingResizer == 0) ||
-        (oldCount == 0 && m_scrollbarsAvoidingResizer > 0))
-      invalidateRect(windowResizerRect());
-  }
-}
-
 Scrollbar* FrameView::scrollbarAtFramePoint(const IntPoint& pointInFrame) {
   if (m_horizontalScrollbar &&
       m_horizontalScrollbar->shouldParticipateInHitTesting() &&
       m_horizontalScrollbar->frameRect().contains(pointInFrame))
     return m_horizontalScrollbar.get();
   if (m_verticalScrollbar &&
       m_verticalScrollbar->shouldParticipateInHitTesting() &&
       m_verticalScrollbar->frameRect().contains(pointInFrame))
     return m_verticalScrollbar.get();
   return nullptr;
@@ skipping 486 matching lines @@
 }
 
 bool FrameView::canThrottleRendering() const {
   if (!RuntimeEnabledFeatures::renderingPipelineThrottlingEnabled())
     return false;
   return m_subtreeThrottled ||
          (m_hiddenForThrottling && m_crossOriginForThrottling);
 }
 
 }  // namespace blink