Don't call into ScrollView from Scrollbar.

Source/platform/scroll/ScrollView.cpp

 /*
  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 57 matching lines @@
 
 void ScrollView::setHasHorizontalScrollbar(bool hasBar)
 {
     if (hasBar && !m_horizontalScrollbar) {
         m_horizontalScrollbar = createScrollbar(HorizontalScrollbar);
         addChild(m_horizontalScrollbar.get());
         didAddScrollbar(m_horizontalScrollbar.get(), HorizontalScrollbar);
         m_horizontalScrollbar->styleChanged();
     } else if (!hasBar && m_horizontalScrollbar) {
         willRemoveScrollbar(m_horizontalScrollbar.get(), HorizontalScrollbar);
+        if (m_horizontalScrollbar->overlapsResizer())

[Ian Vollick, 2014/10/04 01:25:44]

It's not obvious to me how we'll know that
ScrollView::adjustScrollbarRectForResizer will be called before we get here
ensuring that overlapsResizer is up-to-date. Can you please add a comment?

[skobes, 2014/10/06 18:18:53]

Added a comment.  Note that if adjustScrollbarRectForResizer hasn't been called,
then overlapsResizer() returns the default value of false.

+            adjustScrollbarsAvoidingResizerCount(-1);
         removeChild(m_horizontalScrollbar.get());
         m_horizontalScrollbar = nullptr;
     }
 }
 
 void ScrollView::setHasVerticalScrollbar(bool hasBar)
 {
     if (hasBar && !m_verticalScrollbar) {
         m_verticalScrollbar = createScrollbar(VerticalScrollbar);
         addChild(m_verticalScrollbar.get());
         didAddScrollbar(m_verticalScrollbar.get(), VerticalScrollbar);
         m_verticalScrollbar->styleChanged();
     } else if (!hasBar && m_verticalScrollbar) {
         willRemoveScrollbar(m_verticalScrollbar.get(), VerticalScrollbar);
+        if (m_verticalScrollbar->overlapsResizer())
+            adjustScrollbarsAvoidingResizerCount(-1);
         removeChild(m_verticalScrollbar.get());
         m_verticalScrollbar = nullptr;
     }
 }
 
 PassRefPtr<Scrollbar> ScrollView::createScrollbar(ScrollbarOrientation orientation)
 {
     return Scrollbar::create(this, orientation, RegularScrollbar);
 }
 
@@ skipping 277 matching lines @@
 
 void ScrollView::updateScrollbarGeometry()
 {
     if (m_horizontalScrollbar) {
         int clientWidth = visibleWidth();
         IntRect oldRect(m_horizontalScrollbar->frameRect());
         IntRect hBarRect((shouldPlaceVerticalScrollbarOnLeft() && m_verticalScrollbar) ? m_verticalScrollbar->width() : 0,
                         height() - m_horizontalScrollbar->height(),
                         width() - (m_verticalScrollbar ? m_verticalScrollbar->width() : 0),
                         m_horizontalScrollbar->height());
-        m_horizontalScrollbar->setFrameRect(hBarRect);
+        m_horizontalScrollbar->setFrameRect(adjustScrollbarRectForResizer(hBarRect, m_horizontalScrollbar.get()));
         if (!m_scrollbarsSuppressed && oldRect != m_horizontalScrollbar->frameRect())
             m_horizontalScrollbar->invalidate();
 
         if (m_scrollbarsSuppressed)
             m_horizontalScrollbar->setSuppressInvalidation(true);
         m_horizontalScrollbar->setEnabled(contentsWidth() > clientWidth);
         m_horizontalScrollbar->setProportion(clientWidth, contentsWidth());
         m_horizontalScrollbar->offsetDidChange();
         if (m_scrollbarsSuppressed)
             m_horizontalScrollbar->setSuppressInvalidation(false);
     }
 
     if (m_verticalScrollbar) {
         int clientHeight = visibleHeight();
         IntRect oldRect(m_verticalScrollbar->frameRect());
         IntRect vBarRect(shouldPlaceVerticalScrollbarOnLeft() ? 0 : (width() - m_verticalScrollbar->width()),
                          0,
                          m_verticalScrollbar->width(),
                          height() - (m_horizontalScrollbar ? m_horizontalScrollbar->height() : 0));
-        m_verticalScrollbar->setFrameRect(vBarRect);
+        m_verticalScrollbar->setFrameRect(adjustScrollbarRectForResizer(vBarRect, m_verticalScrollbar.get()));
         if (!m_scrollbarsSuppressed && oldRect != m_verticalScrollbar->frameRect())
             m_verticalScrollbar->invalidate();
 
         if (m_scrollbarsSuppressed)
             m_verticalScrollbar->setSuppressInvalidation(true);
         m_verticalScrollbar->setEnabled(contentsHeight() > clientHeight);
         m_verticalScrollbar->setProportion(clientHeight, contentsHeight());
         m_verticalScrollbar->offsetDidChange();
         if (m_scrollbarsSuppressed)
             m_verticalScrollbar->setSuppressInvalidation(false);
     }
 }
 
+IntRect ScrollView::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 = convertFromContainingWindow(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 ScrollView::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 682 matching lines @@
         return;
 
     ScrollableArea::setScrollOrigin(origin);
 
     // Update if the scroll origin changes, since our position will be different if the content size did not change.
     if (updatePositionAtAll && updatePositionSynchronously)
         updateScrollbars(scrollOffset());
 }
 
 } // namespace blink