third_party/WebKit/Source/core/paint/DeprecatedPaintLayerScrollableArea.cpp

   1 /*
   2  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
   3  *
   4  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
   5  *
   6  * Other contributors:
   7  *   Robert O'Callahan <roc+@cs.cmu.edu>
   8  *   David Baron <dbaron@fas.harvard.edu>
   9  *   Christian Biesinger <cbiesinger@web.de>
  10  *   Randall Jesup <rjesup@wgate.com>
  11  *   Roland Mainz <roland.mainz@informatik.med.uni-giessen.de>
  12  *   Josh Soref <timeless@mac.com>
  13  *   Boris Zbarsky <bzbarsky@mit.edu>
  14  *
  15  * This library is free software; you can redistribute it and/or
  16  * modify it under the terms of the GNU Lesser General Public
  17  * License as published by the Free Software Foundation; either
  18  * version 2.1 of the License, or (at your option) any later version.
  19  *
  20  * This library is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  23  * Lesser General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU Lesser General Public
  26  * License along with this library; if not, write to the Free Software
  27  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  28  *
  29  * Alternatively, the contents of this file may be used under the terms
  30  * of either the Mozilla Public License Version 1.1, found at
  31  * http://www.mozilla.org/MPL/ (the "MPL") or the GNU General Public
  32  * License Version 2.0, found at http://www.fsf.org/copyleft/gpl.html
  33  * (the "GPL"), in which case the provisions of the MPL or the GPL are
  34  * applicable instead of those above.  If you wish to allow use of your
  35  * version of this file only under the terms of one of those two
  36  * licenses (the MPL or the GPL) and not to allow others to use your
  37  * version of this file under the LGPL, indicate your decision by
  38  * deletingthe provisions above and replace them with the notice and
  39  * other provisions required by the MPL or the GPL, as the case may be.
  40  * If you do not delete the provisions above, a recipient may use your
  41  * version of this file under any of the LGPL, the MPL or the GPL.
  42  */
  43
  44 #include "config.h"
  45 #include "core/paint/DeprecatedPaintLayerScrollableArea.h"
  46
  47 #include "core/css/PseudoStyleRequest.h"
  48 #include "core/dom/AXObjectCache.h"
  49 #include "core/dom/Node.h"
  50 #include "core/dom/shadow/ShadowRoot.h"
  51 #include "core/editing/FrameSelection.h"
  52 #include "core/frame/FrameHost.h"
  53 #include "core/frame/FrameView.h"
  54 #include "core/frame/LocalFrame.h"
  55 #include "core/frame/Settings.h"
  56 #include "core/html/HTMLFrameOwnerElement.h"
  57 #include "core/input/EventHandler.h"
  58 #include "core/layout/LayoutGeometryMap.h"
  59 #include "core/layout/LayoutPart.h"
  60 #include "core/layout/LayoutScrollbar.h"
  61 #include "core/layout/LayoutScrollbarPart.h"
  62 #include "core/layout/LayoutTheme.h"
  63 #include "core/layout/LayoutView.h"
  64 #include "core/layout/compositing/CompositedDeprecatedPaintLayerMapping.h"
  65 #include "core/layout/compositing/DeprecatedPaintLayerCompositor.h"
  66 #include "core/page/ChromeClient.h"
  67 #include "core/page/FocusController.h"
  68 #include "core/page/Page.h"
  69 #include "core/page/scrolling/ScrollingCoordinator.h"
  70 #include "core/paint/DeprecatedPaintLayerFragment.h"
  71 #include "platform/PlatformGestureEvent.h"
  72 #include "platform/PlatformMouseEvent.h"
  73 #include "platform/graphics/GraphicsLayer.h"
  74 #include "platform/graphics/paint/DrawingRecorder.h"
  75 #include "platform/scroll/ScrollAnimator.h"
  76 #include "platform/scroll/ScrollbarTheme.h"
  77 #include "public/platform/Platform.h"
  78
  79 namespace blink {
  80
  81 const int ResizerControlExpandRatioForTouch = 2;
  82
  83 DeprecatedPaintLayerScrollableArea::DeprecatedPaintLayerScrollableArea(DeprecatedPaintLayer& layer)
  84     : m_layer(layer)
  85     , m_inResizeMode(false)
  86     , m_scrollsOverflow(false)
  87     , m_inOverflowRelayout(false)
  88     , m_nextTopmostScrollChild(0)
  89     , m_topmostScrollChild(0)
  90     , m_needsCompositedScrolling(false)
  91     , m_scrollCorner(nullptr)
  92     , m_resizer(nullptr)
  93 #if ENABLE(ASSERT)
  94     , m_hasBeenDisposed(false)
  95 #endif
  96 {
  97     Node* node = box().node();
  98     if (node && node->isElementNode()) {
  99         // We save and restore only the scrollOffset as the other scroll values are recalculated.
 100         Element* element = toElement(node);
 101         m_scrollOffset = element->savedLayerScrollOffset();
 102         if (!m_scrollOffset.isZero())
 103             scrollAnimator()->setCurrentPosition(FloatPoint(m_scrollOffset.width(), m_scrollOffset.height()));
 104         element->setSavedLayerScrollOffset(IntSize());
 105     }
 106     updateResizerAreaSet();
 107 }
 108
 109 DeprecatedPaintLayerScrollableArea::~DeprecatedPaintLayerScrollableArea()
 110 {
 111     ASSERT(m_hasBeenDisposed);
 112 }
 113
 114 void DeprecatedPaintLayerScrollableArea::dispose()
 115 {
 116     if (inResizeMode() && !box().documentBeingDestroyed()) {
 117         if (LocalFrame* frame = box().frame())
 118             frame->eventHandler().resizeScrollableAreaDestroyed();
 119     }
 120
 121     if (LocalFrame* frame = box().frame()) {
 122         if (FrameView* frameView = frame->view()) {
 123             frameView->removeScrollableArea(this);
 124             frameView->removeAnimatingScrollableArea(this);
 125         }
 126     }
 127
 128     if (box().frame() && box().frame()->page()) {
 129         if (ScrollingCoordinator* scrollingCoordinator = box().frame()->page()->scrollingCoordinator())
 130             scrollingCoordinator->willDestroyScrollableArea(this);
 131     }
 132
 133     if (!box().documentBeingDestroyed()) {
 134         Node* node = box().node();
 135         // FIXME: Make setSavedLayerScrollOffset take DoubleSize. crbug.com/414283.
 136         if (node && node->isElementNode())
 137             toElement(node)->setSavedLayerScrollOffset(flooredIntSize(m_scrollOffset));
 138     }
 139
 140     if (LocalFrame* frame = box().frame()) {
 141         if (FrameView* frameView = frame->view())
 142             frameView->removeResizerArea(box());
 143     }
 144
 145     destroyScrollbar(HorizontalScrollbar);
 146     destroyScrollbar(VerticalScrollbar);
 147
 148     if (m_scrollCorner)
 149         m_scrollCorner->destroy();
 150     if (m_resizer)
 151         m_resizer->destroy();
 152
 153     clearScrollAnimators();
 154
 155 #if ENABLE(ASSERT)
 156     m_hasBeenDisposed = true;
 157 #endif
 158 }
 159
 160 DEFINE_TRACE(DeprecatedPaintLayerScrollableArea)
 161 {
 162     visitor->trace(m_hBar);
 163     visitor->trace(m_vBar);
 164     ScrollableArea::trace(visitor);
 165 }
 166
 167 HostWindow* DeprecatedPaintLayerScrollableArea::hostWindow() const
 168 {
 169     if (Page* page = box().frame()->page())
 170         return &page->chromeClient();
 171     return nullptr;
 172 }
 173
 174 GraphicsLayer* DeprecatedPaintLayerScrollableArea::layerForScrolling() const
 175 {
 176     return layer()->hasCompositedDeprecatedPaintLayerMapping() ? layer()->compositedDeprecatedPaintLayerMapping()->scrollingContentsLayer() : 0;
 177 }
 178
 179 GraphicsLayer* DeprecatedPaintLayerScrollableArea::layerForHorizontalScrollbar() const
 180 {
 181     // See crbug.com/343132.
 182     DisableCompositingQueryAsserts disabler;
 183
 184     return layer()->hasCompositedDeprecatedPaintLayerMapping() ? layer()->compositedDeprecatedPaintLayerMapping()->layerForHorizontalScrollbar() : 0;
 185 }
 186
 187 GraphicsLayer* DeprecatedPaintLayerScrollableArea::layerForVerticalScrollbar() const
 188 {
 189     // See crbug.com/343132.
 190     DisableCompositingQueryAsserts disabler;
 191
 192     return layer()->hasCompositedDeprecatedPaintLayerMapping() ? layer()->compositedDeprecatedPaintLayerMapping()->layerForVerticalScrollbar() : 0;
 193 }
 194
 195 GraphicsLayer* DeprecatedPaintLayerScrollableArea::layerForScrollCorner() const
 196 {
 197     // See crbug.com/343132.
 198     DisableCompositingQueryAsserts disabler;
 199
 200     return layer()->hasCompositedDeprecatedPaintLayerMapping() ? layer()->compositedDeprecatedPaintLayerMapping()->layerForScrollCorner() : 0;
 201 }
 202
 203 void DeprecatedPaintLayerScrollableArea::invalidateScrollbarRect(Scrollbar* scrollbar, const IntRect& rect)
 204 {
 205     // See crbug.com/343132.
 206     DisableCompositingQueryAsserts disabler;
 207
 208     ASSERT(scrollbar == m_hBar.get() || scrollbar == m_vBar.get());
 209     ASSERT(scrollbar == m_hBar.get() ? !layerForHorizontalScrollbar() : !layerForVerticalScrollbar());
 210
 211     IntRect scrollRect = rect;
 212     // If we are not yet inserted into the tree, there is no need to issue paint invaldiations.
 213     if (!box().isLayoutView() && !box().parent())
 214         return;
 215
 216     if (scrollbar == m_vBar.get())
 217         scrollRect.move(verticalScrollbarStart(0, box().size().width()), box().borderTop());
 218     else
 219         scrollRect.move(horizontalScrollbarStart(0), box().size().height() - box().borderBottom() - scrollbar->height());
 220
 221     if (scrollRect.isEmpty())
 222         return;
 223
 224     box().invalidateDisplayItemClient(*scrollbar);
 225
 226     LayoutRect paintInvalidationRect = LayoutRect(scrollRect);
 227     box().flipForWritingMode(paintInvalidationRect);
 228
 229     IntRect intRect = pixelSnappedIntRect(paintInvalidationRect);
 230
 231     if (box().frameView()->isInPerformLayout()) {
 232         addScrollbarDamage(scrollbar, intRect);
 233     } else {
 234         // FIXME: We should not allow paint invalidation out of paint invalidation state. crbug.com/457415
 235         DisablePaintInvalidationStateAsserts disabler;
 236         // We have invalidated the displayItemClient of the scrollbar, but for now we still need to
 237         // invalidate the rectangles to trigger repaints.
 238         box().invalidatePaintRectangleNotInvalidatingDisplayItemClients(LayoutRect(intRect));
 239     }
 240 }
 241
 242 void DeprecatedPaintLayerScrollableArea::invalidateScrollCornerRect(const IntRect& rect)
 243 {
 244     ASSERT(!layerForScrollCorner());
 245
 246     if (m_scrollCorner) {
 247         // FIXME: We should not allow paint invalidation out of paint invalidation state. crbug.com/457415
 248         DisablePaintInvalidationStateAsserts disabler;
 249         m_scrollCorner->invalidatePaintRectangle(LayoutRect(rect));
 250         box().invalidateDisplayItemClientForNonCompositingDescendantsOf(*m_scrollCorner);
 251     } else {
 252         box().invalidateDisplayItemClient(box());
 253     }
 254     if (m_resizer) {
 255         m_resizer->invalidatePaintRectangle(LayoutRect(rect));
 256         box().invalidateDisplayItemClientForNonCompositingDescendantsOf(*m_resizer);
 257     }
 258 }
 259
 260 bool DeprecatedPaintLayerScrollableArea::shouldUseIntegerScrollOffset() const
 261 {
 262     Frame* frame = box().frame();
 263     if (frame->settings() && !frame->settings()->preferCompositingToLCDTextEnabled())
 264         return true;
 265
 266     return ScrollableArea::shouldUseIntegerScrollOffset();
 267 }
 268
 269 bool DeprecatedPaintLayerScrollableArea::isActive() const
 270 {
 271     Page* page = box().frame()->page();
 272     return page && page->focusController().isActive();
 273 }
 274
 275 bool DeprecatedPaintLayerScrollableArea::isScrollCornerVisible() const
 276 {
 277     return !scrollCornerRect().isEmpty();
 278 }
 279
 280 static int cornerStart(const ComputedStyle& style, int minX, int maxX, int thickness)
 281 {
 282     if (style.shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
 283         return minX + style.borderLeftWidth();
 284     return maxX - thickness - style.borderRightWidth();
 285 }
 286
 287 static IntRect cornerRect(const ComputedStyle& style, const Scrollbar* horizontalScrollbar, const Scrollbar* verticalScrollbar, const IntRect& bounds)
 288 {
 289     int horizontalThickness;
 290     int verticalThickness;
 291     if (!verticalScrollbar && !horizontalScrollbar) {
 292         // FIXME: This isn't right. We need to know the thickness of custom scrollbars
 293         // even when they don't exist in order to set the resizer square size properly.
 294         horizontalThickness = ScrollbarTheme::theme()->scrollbarThickness();
 295         verticalThickness = horizontalThickness;
 296     } else if (verticalScrollbar && !horizontalScrollbar) {
 297         horizontalThickness = verticalScrollbar->width();
 298         verticalThickness = horizontalThickness;
 299     } else if (horizontalScrollbar && !verticalScrollbar) {
 300         verticalThickness = horizontalScrollbar->height();
 301         horizontalThickness = verticalThickness;
 302     } else {
 303         horizontalThickness = verticalScrollbar->width();
 304         verticalThickness = horizontalScrollbar->height();
 305     }
 306     return IntRect(cornerStart(style, bounds.x(), bounds.maxX(), horizontalThickness),
 307         bounds.maxY() - verticalThickness - style.borderBottomWidth(),
 308         horizontalThickness, verticalThickness);
 309 }
 310
 311
 312 IntRect DeprecatedPaintLayerScrollableArea::scrollCornerRect() const
 313 {
 314     // We have a scrollbar corner when a scrollbar is visible and not filling the entire length of the box.
 315     // This happens when:
 316     // (a) A resizer is present and at least one scrollbar is present
 317     // (b) Both scrollbars are present.
 318     bool hasHorizontalBar = horizontalScrollbar();
 319     bool hasVerticalBar = verticalScrollbar();
 320     bool hasResizer = box().style()->resize() != RESIZE_NONE;
 321     if ((hasHorizontalBar && hasVerticalBar) || (hasResizer && (hasHorizontalBar || hasVerticalBar)))
 322         return cornerRect(box().styleRef(), horizontalScrollbar(), verticalScrollbar(), box().pixelSnappedBorderBoxRect());
 323     return IntRect();
 324 }
 325
 326 IntRect DeprecatedPaintLayerScrollableArea::convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const IntRect& scrollbarRect) const
 327 {
 328     LayoutView* view = box().view();
 329     if (!view)
 330         return scrollbarRect;
 331
 332     IntRect rect = scrollbarRect;
 333     rect.move(scrollbarOffset(scrollbar));
 334
 335     return view->frameView()->convertFromLayoutObject(box(), rect);
 336 }
 337
 338 IntRect DeprecatedPaintLayerScrollableArea::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const IntRect& parentRect) const
 339 {
 340     LayoutView* view = box().view();
 341     if (!view)
 342         return parentRect;
 343
 344     IntRect rect = view->frameView()->convertToLayoutObject(box(), parentRect);
 345     rect.move(-scrollbarOffset(scrollbar));
 346     return rect;
 347 }
 348
 349 IntPoint DeprecatedPaintLayerScrollableArea::convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const IntPoint& scrollbarPoint) const
 350 {
 351     LayoutView* view = box().view();
 352     if (!view)
 353         return scrollbarPoint;
 354
 355     IntPoint point = scrollbarPoint;
 356     point.move(scrollbarOffset(scrollbar));
 357     return view->frameView()->convertFromLayoutObject(box(), point);
 358 }
 359
 360 IntPoint DeprecatedPaintLayerScrollableArea::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const IntPoint& parentPoint) const
 361 {
 362     LayoutView* view = box().view();
 363     if (!view)
 364         return parentPoint;
 365
 366     IntPoint point = view->frameView()->convertToLayoutObject(box(), parentPoint);
 367
 368     point.move(-scrollbarOffset(scrollbar));
 369     return point;
 370 }
 371
 372 int DeprecatedPaintLayerScrollableArea::scrollSize(ScrollbarOrientation orientation) const
 373 {
 374     IntSize scrollDimensions = maximumScrollPosition() - minimumScrollPosition();
 375     return (orientation == HorizontalScrollbar) ? scrollDimensions.width() : scrollDimensions.height();
 376 }
 377
 378 void DeprecatedPaintLayerScrollableArea::setScrollOffset(const IntPoint& newScrollOffset, ScrollType scrollType)
 379 {
 380     setScrollOffset(DoublePoint(newScrollOffset), scrollType);
 381 }
 382
 383 void DeprecatedPaintLayerScrollableArea::setScrollOffset(const DoublePoint& newScrollOffset, ScrollType)
 384 {
 385     if (scrollOffset() == toDoubleSize(newScrollOffset))
 386         return;
 387
 388     DoubleSize scrollDelta = scrollOffset() - toDoubleSize(newScrollOffset);
 389     m_scrollOffset = toDoubleSize(newScrollOffset);
 390
 391     LocalFrame* frame = box().frame();
 392     ASSERT(frame);
 393
 394     RefPtrWillBeRawPtr<FrameView> frameView = box().frameView();
 395
 396     TRACE_EVENT1("devtools.timeline", "ScrollLayer", "data", InspectorScrollLayerEvent::data(&box()));
 397
 398     // FIXME(420741): Resolve circular dependency between scroll offset and
 399     // compositing state, and remove this disabler.
 400     DisableCompositingQueryAsserts disabler;
 401
 402     // Update the positions of our child layers (if needed as only fixed layers should be impacted by a scroll).
 403     // We don't update compositing layers, because we need to do a deep update from the compositing ancestor.
 404     if (!frameView->isInPerformLayout()) {
 405         // If we're in the middle of layout, we'll just update layers once layout has finished.
 406         layer()->updateLayerPositionsAfterOverflowScroll(scrollDelta);
 407         // Update regions, scrolling may change the clip of a particular region.
 408         frameView->updateAnnotatedRegions();
 409         frameView->setNeedsUpdateWidgetPositions();
 410         updateCompositingLayersAfterScroll();
 411     }
 412
 413     const LayoutBoxModelObject* paintInvalidationContainer = box().containerForPaintInvalidation();
 414     // The caret rect needs to be invalidated after scrolling
 415     frame->selection().setCaretRectNeedsUpdate();
 416
 417     FloatQuad quadForFakeMouseMoveEvent = FloatQuad(FloatRect(layer()->layoutObject()->previousPaintInvalidationRectIncludingCompositedScrolling(*paintInvalidationContainer)));
 418
 419     quadForFakeMouseMoveEvent = paintInvalidationContainer->localToAbsoluteQuad(quadForFakeMouseMoveEvent);
 420     frame->eventHandler().dispatchFakeMouseMoveEventSoonInQuad(quadForFakeMouseMoveEvent);
 421
 422     bool requiresPaintInvalidation = true;
 423
 424     if (box().view()->compositor()->inCompositingMode()) {
 425         bool onlyScrolledCompositedLayers = scrollsOverflow()
 426             && !layer()->hasVisibleNonLayerContent()
 427             && !layer()->hasNonCompositedChild()
 428             && !layer()->hasBlockSelectionGapBounds()
 429             && box().style()->backgroundLayers().attachment() != LocalBackgroundAttachment;
 430
 431         if (usesCompositedScrolling() || onlyScrolledCompositedLayers)
 432             requiresPaintInvalidation = false;
 433     }
 434
 435     // Only the root layer can overlap non-composited fixed-position elements.
 436     if (!requiresPaintInvalidation && layer()->isRootLayer() && frameView->hasViewportConstrainedObjects()) {
 437         if (!frameView->invalidateViewportConstrainedObjects())
 438             requiresPaintInvalidation = true;
 439     }
 440
 441     // Just schedule a full paint invalidation of our object.
 442     // FIXME: This invalidation will be unnecessary in slimming paint phase 2.
 443     if (requiresPaintInvalidation) {
 444         box().setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants();
 445         frameView->setFrameTimingRequestsDirty(true);
 446     }
 447
 448     // Schedule the scroll DOM event.
 449     if (box().node())
 450         box().node()->document().enqueueScrollEventForNode(box().node());
 451
 452     if (AXObjectCache* cache = box().document().existingAXObjectCache())
 453         cache->handleScrollPositionChanged(&box());
 454     box().view()->clearHitTestCache();
 455
 456     // Inform the FrameLoader of the new scroll position, so it can be restored when navigating back.
 457     if (layer()->isRootLayer())
 458         frameView->frame().loader().saveScrollState();
 459
 460     // All scrolls clear the scroll anchor.
 461     frameView->clearScrollAnchor();
 462 }
 463
 464 IntPoint DeprecatedPaintLayerScrollableArea::scrollPosition() const
 465 {
 466     return IntPoint(flooredIntSize(m_scrollOffset));
 467 }
 468
 469 DoublePoint DeprecatedPaintLayerScrollableArea::scrollPositionDouble() const
 470 {
 471     return DoublePoint(m_scrollOffset);
 472 }
 473
 474 IntPoint DeprecatedPaintLayerScrollableArea::minimumScrollPosition() const
 475 {
 476     return -scrollOrigin();
 477 }
 478
 479 IntPoint DeprecatedPaintLayerScrollableArea::maximumScrollPosition() const
 480 {
 481     IntSize contentSize;
 482     IntSize visibleSize;
 483     if (layer()->isRootLayer()) {
 484         FrameView* frameView = box().frameView();
 485         contentSize = frameView->contentsSize();
 486         visibleSize = frameView->visibleContentSize(ExcludeScrollbars) + frameView->topControlsSize();
 487     } else if (box().hasOverflowClip()) {
 488         contentSize = IntSize(pixelSnappedScrollWidth(), pixelSnappedScrollHeight());
 489         visibleSize = enclosingIntRect(box().clientBoxRect()).size();
 490     }
 491     return -scrollOrigin() + (contentSize - visibleSize);
 492 }
 493
 494 IntRect DeprecatedPaintLayerScrollableArea::visibleContentRect(IncludeScrollbarsInRect scrollbarInclusion) const
 495 {
 496     int verticalScrollbarWidth = 0;
 497     int horizontalScrollbarHeight = 0;
 498     if (scrollbarInclusion == IncludeScrollbars) {
 499         verticalScrollbarWidth = (verticalScrollbar() && !verticalScrollbar()->isOverlayScrollbar()) ? verticalScrollbar()->width() : 0;
 500         horizontalScrollbarHeight = (horizontalScrollbar() && !horizontalScrollbar()->isOverlayScrollbar()) ? horizontalScrollbar()->height() : 0;
 501     }
 502
 503     return IntRect(IntPoint(scrollXOffset(), scrollYOffset()),
 504         IntSize(max(0, layer()->size().width() - verticalScrollbarWidth), max(0, layer()->size().height() - horizontalScrollbarHeight)));
 505 }
 506
 507 int DeprecatedPaintLayerScrollableArea::visibleHeight() const
 508 {
 509     return layer()->size().height();
 510 }
 511
 512 int DeprecatedPaintLayerScrollableArea::visibleWidth() const
 513 {
 514     return layer()->size().width();
 515 }
 516
 517 IntSize DeprecatedPaintLayerScrollableArea::contentsSize() const
 518 {
 519     return IntSize(scrollWidth(), scrollHeight());
 520 }
 521
 522 IntPoint DeprecatedPaintLayerScrollableArea::lastKnownMousePosition() const
 523 {
 524     return box().frame() ? box().frame()->eventHandler().lastKnownMousePosition() : IntPoint();
 525 }
 526
 527 bool DeprecatedPaintLayerScrollableArea::scrollAnimatorEnabled() const
 528 {
 529     if (Settings* settings = box().frame()->settings())
 530         return settings->scrollAnimatorEnabled();
 531     return false;
 532 }
 533
 534 bool DeprecatedPaintLayerScrollableArea::shouldSuspendScrollAnimations() const
 535 {
 536     LayoutView* view = box().view();
 537     if (!view)
 538         return true;
 539     return view->frameView()->shouldSuspendScrollAnimations();
 540 }
 541
 542 void DeprecatedPaintLayerScrollableArea::scrollbarVisibilityChanged()
 543 {
 544     if (LayoutView* view = box().view())
 545         return view->clearHitTestCache();
 546 }
 547
 548 bool DeprecatedPaintLayerScrollableArea::scrollbarsCanBeActive() const
 549 {
 550     LayoutView* view = box().view();
 551     if (!view)
 552         return false;
 553     return view->frameView()->scrollbarsCanBeActive();
 554 }
 555
 556 IntRect DeprecatedPaintLayerScrollableArea::scrollableAreaBoundingBox() const
 557 {
 558     return box().absoluteBoundingBoxRect();
 559 }
 560
 561 void DeprecatedPaintLayerScrollableArea::registerForAnimation()
 562 {
 563     if (LocalFrame* frame = box().frame()) {
 564         if (FrameView* frameView = frame->view())
 565             frameView->addAnimatingScrollableArea(this);
 566     }
 567 }
 568
 569 void DeprecatedPaintLayerScrollableArea::deregisterForAnimation()
 570 {
 571     if (LocalFrame* frame = box().frame()) {
 572         if (FrameView* frameView = frame->view())
 573             frameView->removeAnimatingScrollableArea(this);
 574     }
 575 }
 576
 577 bool DeprecatedPaintLayerScrollableArea::userInputScrollable(ScrollbarOrientation orientation) const
 578 {
 579     if (box().isIntrinsicallyScrollable(orientation))
 580         return true;
 581
 582     EOverflow overflowStyle = (orientation == HorizontalScrollbar) ?
 583         box().style()->overflowX() : box().style()->overflowY();
 584     return (overflowStyle == OSCROLL || overflowStyle == OAUTO || overflowStyle == OOVERLAY);
 585 }
 586
 587 bool DeprecatedPaintLayerScrollableArea::shouldPlaceVerticalScrollbarOnLeft() const
 588 {
 589     return box().style()->shouldPlaceBlockDirectionScrollbarOnLogicalLeft();
 590 }
 591
 592 int DeprecatedPaintLayerScrollableArea::pageStep(ScrollbarOrientation orientation) const
 593 {
 594     int length = (orientation == HorizontalScrollbar) ?
 595         box().pixelSnappedClientWidth() : box().pixelSnappedClientHeight();
 596     int minPageStep = static_cast<float>(length) * ScrollableArea::minFractionToStepWhenPaging();
 597     int pageStep = max(minPageStep, length - ScrollableArea::maxOverlapBetweenPages());
 598
 599     return max(pageStep, 1);
 600 }
 601
 602 LayoutBox& DeprecatedPaintLayerScrollableArea::box() const
 603 {
 604     return *m_layer.layoutBox();
 605 }
 606
 607 DeprecatedPaintLayer* DeprecatedPaintLayerScrollableArea::layer() const
 608 {
 609     return &m_layer;
 610 }
 611
 612 LayoutUnit DeprecatedPaintLayerScrollableArea::scrollWidth() const
 613 {
 614     return m_overflowRect.width();
 615 }
 616
 617 LayoutUnit DeprecatedPaintLayerScrollableArea::scrollHeight() const
 618 {
 619     return m_overflowRect.height();
 620 }
 621
 622 int DeprecatedPaintLayerScrollableArea::pixelSnappedScrollWidth() const
 623 {
 624     return snapSizeToPixel(scrollWidth(), box().clientLeft() + box().location().x());
 625 }
 626
 627 int DeprecatedPaintLayerScrollableArea::pixelSnappedScrollHeight() const
 628 {
 629     return snapSizeToPixel(scrollHeight(), box().clientTop() + box().location().y());
 630 }
 631
 632 void DeprecatedPaintLayerScrollableArea::computeScrollDimensions()
 633 {
 634     m_overflowRect = box().layoutOverflowRect();
 635     box().flipForWritingMode(m_overflowRect);
 636
 637     int scrollableLeftOverflow = m_overflowRect.x() - box().borderLeft() - (box().style()->shouldPlaceBlockDirectionScrollbarOnLogicalLeft() ? box().verticalScrollbarWidth() : 0);
 638     int scrollableTopOverflow = m_overflowRect.y() - box().borderTop();
 639     setScrollOrigin(IntPoint(-scrollableLeftOverflow, -scrollableTopOverflow));
 640 }
 641
 642 void DeprecatedPaintLayerScrollableArea::scrollToPosition(const DoublePoint& scrollPosition, ScrollOffsetClamping clamp, ScrollBehavior scrollBehavior)
 643 {
 644     cancelProgrammaticScrollAnimation();
 645
 646     DoublePoint newScrollPosition = clamp == ScrollOffsetClamped ? clampScrollPosition(scrollPosition) : scrollPosition;
 647     if (newScrollPosition != scrollPositionDouble())
 648         ScrollableArea::setScrollPosition(newScrollPosition, ProgrammaticScroll, scrollBehavior);
 649 }
 650
 651 void DeprecatedPaintLayerScrollableArea::updateScrollDimensions(DoubleSize& scrollOffset, bool& autoHorizontalScrollBarChanged, bool& autoVerticalScrollBarChanged)
 652 {
 653     ASSERT(box().hasOverflowClip());
 654
 655     if (needsScrollbarReconstruction()) {
 656         if (m_hBar)
 657             destroyScrollbar(HorizontalScrollbar);
 658         if (m_vBar)
 659             destroyScrollbar(VerticalScrollbar);
 660     }
 661
 662     scrollOffset = adjustedScrollOffset();
 663     computeScrollDimensions();
 664     bool hasHorizontalOverflow = this->hasHorizontalOverflow();
 665     bool hasVerticalOverflow = this->hasVerticalOverflow();
 666     if (hasOverlayScrollbars()) {
 667         if (!scrollSize(HorizontalScrollbar))
 668             setHasHorizontalScrollbar(false);
 669         if (!scrollSize(VerticalScrollbar))
 670             setHasVerticalScrollbar(false);
 671     }
 672
 673     // overflow:auto may need to lay out again if scrollbars got added/removed.
 674     autoHorizontalScrollBarChanged = (box().hasAutoHorizontalScrollbar() && (hasHorizontalScrollbar() != hasHorizontalOverflow)) || (box().style()->overflowX() == OSCROLL && !horizontalScrollbar());
 675     autoVerticalScrollBarChanged = (box().hasAutoVerticalScrollbar() && (hasVerticalScrollbar() != hasVerticalOverflow)) || (box().style()->overflowY() == OSCROLL && !verticalScrollbar());
 676     if (!visualViewportSuppliesScrollbars() && (autoHorizontalScrollBarChanged || autoVerticalScrollBarChanged)) {
 677         if (box().hasAutoHorizontalScrollbar() || (box().style()->overflowX() == OSCROLL && !horizontalScrollbar()))
 678             setHasHorizontalScrollbar(box().style()->overflowX() == OSCROLL ? true : hasHorizontalOverflow);
 679         if (box().hasAutoVerticalScrollbar() || (box().style()->overflowY() == OSCROLL && !verticalScrollbar()))
 680             setHasVerticalScrollbar(box().style()->overflowY() == OSCROLL ? true : hasVerticalOverflow);
 681     }
 682 }
 683
 684 void DeprecatedPaintLayerScrollableArea::finalizeScrollDimensions(const DoubleSize& originalScrollOffset, bool autoHorizontalScrollBarChanged, bool autoVerticalScrollBarChanged)
 685 {
 686     ASSERT(box().hasOverflowClip());
 687
 688     // Layout may cause us to be at an invalid scroll position. In this case we need
 689     // to pull our scroll offsets back to the max (or push them up to the min).
 690     DoublePoint clampedScrollPosition = clampScrollPosition(scrollPositionDouble());
 691     if (clampedScrollPosition != scrollPositionDouble())
 692         scrollToPosition(clampedScrollPosition);
 693
 694     if (originalScrollOffset != adjustedScrollOffset()) {
 695         DoublePoint origin(scrollOrigin());
 696         scrollPositionChanged(-origin + adjustedScrollOffset(), ProgrammaticScroll);
 697     }
 698
 699     bool hasHorizontalOverflow = this->hasHorizontalOverflow();
 700     bool hasVerticalOverflow = this->hasVerticalOverflow();
 701
 702     {
 703         // Hits in compositing/overflow/automatically-opt-into-composited-scrolling-after-style-change.html.
 704         DisableCompositingQueryAsserts disabler;
 705
 706         // overflow:scroll should just enable/disable.
 707         if (box().style()->overflowX() == OSCROLL && horizontalScrollbar())
 708             horizontalScrollbar()->setEnabled(hasHorizontalOverflow);
 709         if (box().style()->overflowY() == OSCROLL && verticalScrollbar())
 710             verticalScrollbar()->setEnabled(hasVerticalOverflow);
 711     }
 712
 713     if (!visualViewportSuppliesScrollbars() && (autoHorizontalScrollBarChanged || autoVerticalScrollBarChanged)) {
 714         if (hasVerticalOverflow || hasHorizontalOverflow)
 715             updateScrollCornerStyle();
 716
 717         layer()->updateSelfPaintingLayer();
 718
 719         // Force an update since we know the scrollbars have changed things.
 720         if (box().document().hasAnnotatedRegions())
 721             box().document().setAnnotatedRegionsDirty(true);
 722
 723         // Our proprietary overflow: overlay value doesn't trigger a layout.
 724         if ((autoHorizontalScrollBarChanged && box().style()->overflowX() != OOVERLAY) || (autoVerticalScrollBarChanged && box().style()->overflowY() != OOVERLAY)) {
 725             if (!m_inOverflowRelayout) {
 726                 m_inOverflowRelayout = true;
 727                 SubtreeLayoutScope layoutScope(box());
 728                 layoutScope.setNeedsLayout(&box(), LayoutInvalidationReason::ScrollbarChanged);
 729                 if (box().isLayoutBlock()) {
 730                     LayoutBlock& block = toLayoutBlock(box());
 731                     block.scrollbarsChanged(autoHorizontalScrollBarChanged, autoVerticalScrollBarChanged);
 732                     block.layoutBlock(true);
 733                 } else {
 734                     box().layout();
 735                 }
 736                 m_inOverflowRelayout = false;
 737             }
 738         }
 739     }
 740
 741     {
 742         // Hits in compositing/overflow/automatically-opt-into-composited-scrolling-after-style-change.html.
 743         DisableCompositingQueryAsserts disabler;
 744
 745         // Set up the range (and page step/line step).
 746         if (Scrollbar* horizontalScrollbar = this->horizontalScrollbar()) {
 747             int clientWidth = box().pixelSnappedClientWidth();
 748             horizontalScrollbar->setProportion(clientWidth, overflowRect().width());
 749         }
 750         if (Scrollbar* verticalScrollbar = this->verticalScrollbar()) {
 751             int clientHeight = box().pixelSnappedClientHeight();
 752             verticalScrollbar->setProportion(clientHeight, overflowRect().height());
 753         }
 754     }
 755
 756     if (hasOverlayScrollbars()) {
 757         if (!scrollSize(HorizontalScrollbar))
 758             setHasHorizontalScrollbar(false);
 759         if (!scrollSize(VerticalScrollbar))
 760             setHasVerticalScrollbar(false);
 761     }
 762
 763     bool hasOverflow = hasScrollableHorizontalOverflow() || hasScrollableVerticalOverflow();
 764     updateScrollableAreaSet(hasOverflow);
 765
 766     DisableCompositingQueryAsserts disabler;
 767     positionOverflowControls();
 768 }
 769
 770 void DeprecatedPaintLayerScrollableArea::updateAfterLayout()
 771 {
 772     DoubleSize originalScrollOffset;
 773     bool autoHorizontalScrollBarChanged;
 774     bool autoVerticalScrollBarChanged;
 775     updateScrollDimensions(originalScrollOffset, autoHorizontalScrollBarChanged, autoVerticalScrollBarChanged);
 776     finalizeScrollDimensions(originalScrollOffset, autoHorizontalScrollBarChanged, autoVerticalScrollBarChanged);
 777 }
 778
 779 ScrollBehavior DeprecatedPaintLayerScrollableArea::scrollBehaviorStyle() const
 780 {
 781     return box().style()->scrollBehavior();
 782 }
 783
 784 bool DeprecatedPaintLayerScrollableArea::hasHorizontalOverflow() const
 785 {
 786     return pixelSnappedScrollWidth() > box().pixelSnappedClientWidth();
 787 }
 788
 789 bool DeprecatedPaintLayerScrollableArea::hasVerticalOverflow() const
 790 {
 791     return pixelSnappedScrollHeight() > box().pixelSnappedClientHeight();
 792 }
 793
 794 bool DeprecatedPaintLayerScrollableArea::hasScrollableHorizontalOverflow() const
 795 {
 796     return hasHorizontalOverflow() && box().scrollsOverflowX();
 797 }
 798
 799 bool DeprecatedPaintLayerScrollableArea::hasScrollableVerticalOverflow() const
 800 {
 801     return hasVerticalOverflow() && box().scrollsOverflowY();
 802 }
 803
 804 static bool overflowRequiresScrollbar(EOverflow overflow)
 805 {
 806     return overflow == OSCROLL;
 807 }
 808
 809 static bool overflowDefinesAutomaticScrollbar(EOverflow overflow)
 810 {
 811     return overflow == OAUTO || overflow == OOVERLAY;
 812 }
 813
 814 // This function returns true if the given box requires overflow scrollbars (as
 815 // opposed to the 'viewport' scrollbars managed by the DeprecatedPaintLayerCompositor).
 816 // FIXME: we should use the same scrolling machinery for both the viewport and
 817 // overflow. Currently, we need to avoid producing scrollbars here if they'll be
 818 // handled externally in the RLC.
 819 static bool canHaveOverflowScrollbars(const LayoutBox& box)
 820 {
 821     bool rootLayerScrolls = box.document().settings() && box.document().settings()->rootLayerScrolls();
 822     return (rootLayerScrolls || !box.isLayoutView()) && box.document().viewportDefiningElement() != box.node();
 823 }
 824
 825 void DeprecatedPaintLayerScrollableArea::updateAfterStyleChange(const ComputedStyle* oldStyle)
 826 {
 827     // Don't do this on first style recalc, before layout has ever happened.
 828     if (!overflowRect().size().isZero())
 829         updateScrollableAreaSet(hasScrollableHorizontalOverflow() || hasScrollableVerticalOverflow());
 830
 831     if (!canHaveOverflowScrollbars(box()))
 832         return;
 833
 834     // Avoid drawing two sets of scrollbars when one is provided by the visual viewport.
 835     if (visualViewportSuppliesScrollbars()) {
 836         setHasHorizontalScrollbar(false);
 837         setHasVerticalScrollbar(false);
 838         return;
 839     }
 840
 841     EOverflow overflowX = box().style()->overflowX();
 842     EOverflow overflowY = box().style()->overflowY();
 843
 844     // To avoid doing a relayout in updateScrollbarsAfterLayout, we try to keep any automatic scrollbar that was already present.
 845     bool needsHorizontalScrollbar = (hasHorizontalScrollbar() && overflowDefinesAutomaticScrollbar(overflowX)) || overflowRequiresScrollbar(overflowX);
 846     bool needsVerticalScrollbar = (hasVerticalScrollbar() && overflowDefinesAutomaticScrollbar(overflowY)) || overflowRequiresScrollbar(overflowY);
 847     setHasHorizontalScrollbar(needsHorizontalScrollbar);
 848     setHasVerticalScrollbar(needsVerticalScrollbar);
 849
 850     // With overflow: scroll, scrollbars are always visible but may be disabled.
 851     // When switching to another value, we need to re-enable them (see bug 11985).
 852     if (needsHorizontalScrollbar && oldStyle && oldStyle->overflowX() == OSCROLL && overflowX != OSCROLL) {
 853         ASSERT(hasHorizontalScrollbar());
 854         m_hBar->setEnabled(true);
 855     }
 856
 857     if (needsVerticalScrollbar && oldStyle && oldStyle->overflowY() == OSCROLL && overflowY != OSCROLL) {
 858         ASSERT(hasVerticalScrollbar());
 859         m_vBar->setEnabled(true);
 860     }
 861
 862     // FIXME: Need to detect a swap from custom to native scrollbars (and vice versa).
 863     if (m_hBar)
 864         m_hBar->styleChanged();
 865     if (m_vBar)
 866         m_vBar->styleChanged();
 867
 868     updateScrollCornerStyle();
 869     updateResizerAreaSet();
 870     updateResizerStyle();
 871 }
 872
 873 bool DeprecatedPaintLayerScrollableArea::updateAfterCompositingChange()
 874 {
 875     layer()->updateScrollingStateAfterCompositingChange();
 876     const bool layersChanged = m_topmostScrollChild != m_nextTopmostScrollChild;
 877     m_topmostScrollChild = m_nextTopmostScrollChild;
 878     m_nextTopmostScrollChild = nullptr;
 879     return layersChanged;
 880 }
 881
 882 void DeprecatedPaintLayerScrollableArea::updateAfterOverflowRecalc()
 883 {
 884     computeScrollDimensions();
 885     if (Scrollbar* horizontalScrollbar = this->horizontalScrollbar()) {
 886         int clientWidth = box().pixelSnappedClientWidth();
 887         horizontalScrollbar->setProportion(clientWidth, overflowRect().width());
 888     }
 889     if (Scrollbar* verticalScrollbar = this->verticalScrollbar()) {
 890         int clientHeight = box().pixelSnappedClientHeight();
 891         verticalScrollbar->setProportion(clientHeight, overflowRect().height());
 892     }
 893
 894     bool hasHorizontalOverflow = this->hasHorizontalOverflow();
 895     bool hasVerticalOverflow = this->hasVerticalOverflow();
 896     bool autoHorizontalScrollBarChanged = box().hasAutoHorizontalScrollbar() && (hasHorizontalScrollbar() != hasHorizontalOverflow);
 897     bool autoVerticalScrollBarChanged = box().hasAutoVerticalScrollbar() && (hasVerticalScrollbar() != hasVerticalOverflow);
 898     if (autoHorizontalScrollBarChanged || autoVerticalScrollBarChanged)
 899         box().setNeedsLayoutAndFullPaintInvalidation(LayoutInvalidationReason::Unknown);
 900 }
 901
 902 IntRect DeprecatedPaintLayerScrollableArea::rectForHorizontalScrollbar(const IntRect& borderBoxRect) const
 903 {
 904     if (!m_hBar)
 905         return IntRect();
 906
 907     const IntRect& scrollCorner = scrollCornerRect();
 908
 909     return IntRect(horizontalScrollbarStart(borderBoxRect.x()),
 910         borderBoxRect.maxY() - box().borderBottom() - m_hBar->height(),
 911         borderBoxRect.width() - (box().borderLeft() + box().borderRight()) - scrollCorner.width(),
 912         m_hBar->height());
 913 }
 914
 915 IntRect DeprecatedPaintLayerScrollableArea::rectForVerticalScrollbar(const IntRect& borderBoxRect) const
 916 {
 917     if (!m_vBar)
 918         return IntRect();
 919
 920     const IntRect& scrollCorner = scrollCornerRect();
 921
 922     return IntRect(verticalScrollbarStart(borderBoxRect.x(), borderBoxRect.maxX()),
 923         borderBoxRect.y() + box().borderTop(),
 924         m_vBar->width(),
 925         borderBoxRect.height() - (box().borderTop() + box().borderBottom()) - scrollCorner.height());
 926 }
 927
 928 LayoutUnit DeprecatedPaintLayerScrollableArea::verticalScrollbarStart(int minX, int maxX) const
 929 {
 930     if (box().style()->shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
 931         return minX + box().borderLeft();
 932     return maxX - box().borderRight() - m_vBar->width();
 933 }
 934
 935 LayoutUnit DeprecatedPaintLayerScrollableArea::horizontalScrollbarStart(int minX) const
 936 {
 937     int x = minX + box().borderLeft();
 938     if (box().style()->shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
 939         x += m_vBar ? m_vBar->width() : resizerCornerRect(box().pixelSnappedBorderBoxRect(), ResizerForPointer).width();
 940     return x;
 941 }
 942
 943 IntSize DeprecatedPaintLayerScrollableArea::scrollbarOffset(const Scrollbar* scrollbar) const
 944 {
 945     if (scrollbar == m_vBar.get())
 946         return IntSize(verticalScrollbarStart(0, box().size().width()), box().borderTop());
 947
 948     if (scrollbar == m_hBar.get())
 949         return IntSize(horizontalScrollbarStart(0), box().size().height() - box().borderBottom() - scrollbar->height());
 950
 951     ASSERT_NOT_REACHED();
 952     return IntSize();
 953 }
 954
 955 static inline LayoutObject* layoutObjectForScrollbar(LayoutObject& layoutObject)
 956 {
 957     if (Node* node = layoutObject.node()) {
 958         if (layoutObject.isLayoutView()) {
 959             Document& doc = node->document();
 960             if (Settings* settings = doc.settings()) {
 961                 if (!settings->allowCustomScrollbarInMainFrame() && layoutObject.frame() && layoutObject.frame()->isMainFrame())
 962                     return &layoutObject;
 963             }
 964
 965             // Try the <body> element first as a scrollbar source.
 966             Element* body = doc.body();
 967             if (body && body->layoutObject() && body->layoutObject()->style()->hasPseudoStyle(SCROLLBAR))
 968                 return body->layoutObject();
 969
 970             // If the <body> didn't have a custom style, then the root element might.
 971             Element* docElement = doc.documentElement();
 972             if (docElement && docElement->layoutObject() && docElement->layoutObject()->style()->hasPseudoStyle(SCROLLBAR))
 973                 return docElement->layoutObject();
 974
 975             // If we have an owning ipage/LocalFrame element, then it can set the custom scrollbar also.
 976             LayoutPart* frameLayoutObject = node->document().frame()->ownerLayoutObject();
 977             if (frameLayoutObject && frameLayoutObject->style()->hasPseudoStyle(SCROLLBAR))
 978                 return frameLayoutObject;
 979         }
 980         if (ShadowRoot* shadowRoot = node->containingShadowRoot()) {
 981             if (shadowRoot->type() == ShadowRootType::UserAgent)
 982                 return shadowRoot->host()->layoutObject();
 983         }
 984     }
 985
 986     return &layoutObject;
 987 }
 988
 989 bool DeprecatedPaintLayerScrollableArea::needsScrollbarReconstruction() const
 990 {
 991     LayoutObject* actualLayoutObject = layoutObjectForScrollbar(box());
 992     bool shouldUseCustom = actualLayoutObject->isBox() && actualLayoutObject->style()->hasPseudoStyle(SCROLLBAR);
 993     bool hasAnyScrollbar = hasScrollbar();
 994     bool hasCustom = (m_hBar && m_hBar->isCustomScrollbar()) || (m_vBar && m_vBar->isCustomScrollbar());
 995     return hasAnyScrollbar && (shouldUseCustom != hasCustom);
 996 }
 997
 998 PassRefPtrWillBeRawPtr<Scrollbar> DeprecatedPaintLayerScrollableArea::createScrollbar(ScrollbarOrientation orientation)
 999 {
1000     RefPtrWillBeRawPtr<Scrollbar> widget = nullptr;
1001     LayoutObject* actualLayoutObject = layoutObjectForScrollbar(box());
1002     bool hasCustomScrollbarStyle = actualLayoutObject->isBox() && actualLayoutObject->style()->hasPseudoStyle(SCROLLBAR);
1003     if (hasCustomScrollbarStyle) {
1004         widget = LayoutScrollbar::createCustomScrollbar(this, orientation, actualLayoutObject->node());
1005     } else {
1006         ScrollbarControlSize scrollbarSize = RegularScrollbar;
1007         if (actualLayoutObject->style()->hasAppearance())
1008             scrollbarSize = LayoutTheme::theme().scrollbarControlSizeForPart(actualLayoutObject->style()->appearance());
1009         widget = Scrollbar::create(this, orientation, scrollbarSize);
1010         if (orientation == HorizontalScrollbar)
1011             didAddScrollbar(widget.get(), HorizontalScrollbar);
1012         else
1013             didAddScrollbar(widget.get(), VerticalScrollbar);
1014     }
1015     box().document().view()->addChild(widget.get());
1016     return widget.release();
1017 }
1018
1019 void DeprecatedPaintLayerScrollableArea::destroyScrollbar(ScrollbarOrientation orientation)
1020 {
1021     RefPtrWillBeMember<Scrollbar>& scrollbar = orientation == HorizontalScrollbar ? m_hBar : m_vBar;
1022     if (!scrollbar)
1023         return;
1024
1025     if (!scrollbar->isCustomScrollbar())
1026         willRemoveScrollbar(scrollbar.get(), orientation);
1027
1028     toFrameView(scrollbar->parent())->removeChild(scrollbar.get());
1029     scrollbar->disconnectFromScrollableArea();
1030     scrollbar = nullptr;
1031 }
1032
1033 void DeprecatedPaintLayerScrollableArea::setHasHorizontalScrollbar(bool hasScrollbar)
1034 {
1035     if (hasScrollbar == hasHorizontalScrollbar())
1036         return;
1037
1038     if (hasScrollbar) {
1039         // This doesn't hit in any tests, but since the equivalent code in setHasVerticalScrollbar
1040         // does, presumably this code does as well.
1041         DisableCompositingQueryAsserts disabler;
1042         m_hBar = createScrollbar(HorizontalScrollbar);
1043     } else {
1044         if (!layerForHorizontalScrollbar())
1045             m_hBar->invalidate();
1046         // Otherwise we will remove the layer and just need recompositing.
1047
1048         destroyScrollbar(HorizontalScrollbar);
1049     }
1050
1051     // Destroying or creating one bar can cause our scrollbar corner to come and go. We need to update the opposite scrollbar's style.
1052     if (m_hBar)
1053         m_hBar->styleChanged();
1054     if (m_vBar)
1055         m_vBar->styleChanged();
1056
1057     // These are valid because we want to invalidate display item clients on the current backing.
1058     DisablePaintInvalidationStateAsserts paintInvalidationAssertDisabler;
1059     DisableCompositingQueryAsserts compositingAssertDisabler;
1060     invalidateScrollCorner(scrollCornerRect());
1061
1062     // Force an update since we know the scrollbars have changed things.
1063     if (box().document().hasAnnotatedRegions())
1064         box().document().setAnnotatedRegionsDirty(true);
1065 }
1066
1067 void DeprecatedPaintLayerScrollableArea::setHasVerticalScrollbar(bool hasScrollbar)
1068 {
1069     if (hasScrollbar == hasVerticalScrollbar())
1070         return;
1071
1072     if (hasScrollbar) {
1073         // Hits in compositing/overflow/automatically-opt-into-composited-scrolling-after-style-change.html
1074         DisableCompositingQueryAsserts disabler;
1075         m_vBar = createScrollbar(VerticalScrollbar);
1076     } else {
1077         if (!layerForVerticalScrollbar())
1078             m_vBar->invalidate();
1079         // Otherwise we will remove the layer and just need recompositing.
1080
1081         destroyScrollbar(VerticalScrollbar);
1082     }
1083
1084     // Destroying or creating one bar can cause our scrollbar corner to come and go. We need to update the opposite scrollbar's style.
1085     if (m_hBar)
1086         m_hBar->styleChanged();
1087     if (m_vBar)
1088         m_vBar->styleChanged();
1089
1090     // These are valid because we want to invalidate display item clients on the current backing.
1091     DisablePaintInvalidationStateAsserts paintInvalidationAssertDisabler;
1092     DisableCompositingQueryAsserts compositingAssertDisabler;
1093     invalidateScrollCorner(scrollCornerRect());
1094
1095     // Force an update since we know the scrollbars have changed things.
1096     if (box().document().hasAnnotatedRegions())
1097         box().document().setAnnotatedRegionsDirty(true);
1098 }
1099
1100 int DeprecatedPaintLayerScrollableArea::verticalScrollbarWidth(OverlayScrollbarSizeRelevancy relevancy) const
1101 {
1102     if (!m_vBar || (m_vBar->isOverlayScrollbar() && (relevancy == IgnoreOverlayScrollbarSize || !m_vBar->shouldParticipateInHitTesting())))
1103         return 0;
1104     return m_vBar->width();
1105 }
1106
1107 int DeprecatedPaintLayerScrollableArea::horizontalScrollbarHeight(OverlayScrollbarSizeRelevancy relevancy) const
1108 {
1109     if (!m_hBar || (m_hBar->isOverlayScrollbar() && (relevancy == IgnoreOverlayScrollbarSize || !m_hBar->shouldParticipateInHitTesting())))
1110         return 0;
1111     return m_hBar->height();
1112 }
1113
1114 void DeprecatedPaintLayerScrollableArea::positionOverflowControls()
1115 {
1116     if (!hasScrollbar() && !box().canResize())
1117         return;
1118
1119     const IntRect borderBox = box().pixelSnappedBorderBoxRect();
1120     if (Scrollbar* verticalScrollbar = this->verticalScrollbar())
1121         verticalScrollbar->setFrameRect(rectForVerticalScrollbar(borderBox));
1122
1123     if (Scrollbar* horizontalScrollbar = this->horizontalScrollbar())
1124         horizontalScrollbar->setFrameRect(rectForHorizontalScrollbar(borderBox));
1125
1126     const IntRect& scrollCorner = scrollCornerRect();
1127     if (m_scrollCorner)
1128         m_scrollCorner->setFrameRect(LayoutRect(scrollCorner));
1129
1130     if (m_resizer)
1131         m_resizer->setFrameRect(LayoutRect(resizerCornerRect(borderBox, ResizerForPointer)));
1132
1133     // FIXME, this should eventually be removed, once we are certain that composited
1134     // controls get correctly positioned on a compositor update. For now, conservatively
1135     // leaving this unchanged.
1136     if (layer()->hasCompositedDeprecatedPaintLayerMapping())
1137         layer()->compositedDeprecatedPaintLayerMapping()->positionOverflowControlsLayers();
1138 }
1139
1140 void DeprecatedPaintLayerScrollableArea::updateScrollCornerStyle()
1141 {
1142     if (!m_scrollCorner && !hasScrollbar())
1143         return;
1144     if (!m_scrollCorner && hasOverlayScrollbars())
1145         return;
1146
1147     LayoutObject* actualLayoutObject = layoutObjectForScrollbar(box());
1148     RefPtr<ComputedStyle> corner = box().hasOverflowClip() ? actualLayoutObject->getUncachedPseudoStyle(PseudoStyleRequest(SCROLLBAR_CORNER), actualLayoutObject->style()) : PassRefPtr<ComputedStyle>(nullptr);
1149     if (corner) {
1150         if (!m_scrollCorner) {
1151             m_scrollCorner = LayoutScrollbarPart::createAnonymous(&box().document());
1152             m_scrollCorner->setDangerousOneWayParent(&box());
1153         }
1154         m_scrollCorner->setStyle(corner.release());
1155     } else if (m_scrollCorner) {
1156         m_scrollCorner->destroy();
1157         m_scrollCorner = nullptr;
1158     }
1159 }
1160
1161 bool DeprecatedPaintLayerScrollableArea::hitTestOverflowControls(HitTestResult& result, const IntPoint& localPoint)
1162 {
1163     if (!hasScrollbar() && !box().canResize())
1164         return false;
1165
1166     IntRect resizeControlRect;
1167     if (box().style()->resize() != RESIZE_NONE) {
1168         resizeControlRect = resizerCornerRect(box().pixelSnappedBorderBoxRect(), ResizerForPointer);
1169         if (resizeControlRect.contains(localPoint))
1170             return true;
1171     }
1172
1173     int resizeControlSize = max(resizeControlRect.height(), 0);
1174     if (m_vBar && m_vBar->shouldParticipateInHitTesting()) {
1175         LayoutRect vBarRect(verticalScrollbarStart(0, box().size().width()),
1176             box().borderTop(),
1177             m_vBar->width(),
1178             box().size().height() - (box().borderTop() + box().borderBottom()) - (m_hBar ? m_hBar->height() : resizeControlSize));
1179         if (vBarRect.contains(localPoint)) {
1180             result.setScrollbar(m_vBar.get());
1181             return true;
1182         }
1183     }
1184
1185     resizeControlSize = max(resizeControlRect.width(), 0);
1186     if (m_hBar && m_hBar->shouldParticipateInHitTesting()) {
1187         LayoutRect hBarRect(horizontalScrollbarStart(0),
1188             box().size().height() - box().borderBottom() - m_hBar->height(),
1189             box().size().width() - (box().borderLeft() + box().borderRight()) - (m_vBar ? m_vBar->width() : resizeControlSize),
1190             m_hBar->height());
1191         if (hBarRect.contains(localPoint)) {
1192             result.setScrollbar(m_hBar.get());
1193             return true;
1194         }
1195     }
1196
1197     // FIXME: We should hit test the m_scrollCorner and pass it back through the result.
1198
1199     return false;
1200 }
1201
1202 IntRect DeprecatedPaintLayerScrollableArea::resizerCornerRect(const IntRect& bounds, ResizerHitTestType resizerHitTestType) const
1203 {
1204     if (box().style()->resize() == RESIZE_NONE)
1205         return IntRect();
1206     IntRect corner = cornerRect(box().styleRef(), horizontalScrollbar(), verticalScrollbar(), bounds);
1207
1208     if (resizerHitTestType == ResizerForTouch) {
1209         // We make the resizer virtually larger for touch hit testing. With the
1210         // expanding ratio k = ResizerControlExpandRatioForTouch, we first move
1211         // the resizer rect (of width w & height h), by (-w * (k-1), -h * (k-1)),
1212         // then expand the rect by new_w/h = w/h * k.
1213         int expandRatio = ResizerControlExpandRatioForTouch - 1;
1214         corner.move(-corner.width() * expandRatio, -corner.height() * expandRatio);
1215         corner.expand(corner.width() * expandRatio, corner.height() * expandRatio);
1216     }
1217
1218     return corner;
1219 }
1220
1221 IntRect DeprecatedPaintLayerScrollableArea::scrollCornerAndResizerRect() const
1222 {
1223     IntRect scrollCornerAndResizer = scrollCornerRect();
1224     if (scrollCornerAndResizer.isEmpty())
1225         scrollCornerAndResizer = resizerCornerRect(box().pixelSnappedBorderBoxRect(), ResizerForPointer);
1226     return scrollCornerAndResizer;
1227 }
1228
1229 bool DeprecatedPaintLayerScrollableArea::isPointInResizeControl(const IntPoint& absolutePoint, ResizerHitTestType resizerHitTestType) const
1230 {
1231     if (!box().canResize())
1232         return false;
1233
1234     IntPoint localPoint = roundedIntPoint(box().absoluteToLocal(absolutePoint, UseTransforms));
1235     IntRect localBounds(0, 0, box().pixelSnappedWidth(), box().pixelSnappedHeight());
1236     return resizerCornerRect(localBounds, resizerHitTestType).contains(localPoint);
1237 }
1238
1239 bool DeprecatedPaintLayerScrollableArea::hitTestResizerInFragments(const DeprecatedPaintLayerFragments& layerFragments, const HitTestLocation& hitTestLocation) const
1240 {
1241     if (!box().canResize())
1242         return false;
1243
1244     if (layerFragments.isEmpty())
1245         return false;
1246
1247     for (int i = layerFragments.size() - 1; i >= 0; --i) {
1248         const DeprecatedPaintLayerFragment& fragment = layerFragments.at(i);
1249         if (fragment.backgroundRect.intersects(hitTestLocation) && resizerCornerRect(pixelSnappedIntRect(fragment.layerBounds), ResizerForPointer).contains(hitTestLocation.roundedPoint()))
1250             return true;
1251     }
1252
1253     return false;
1254 }
1255
1256 void DeprecatedPaintLayerScrollableArea::updateResizerAreaSet()
1257 {
1258     LocalFrame* frame = box().frame();
1259     if (!frame)
1260         return;
1261     FrameView* frameView = frame->view();
1262     if (!frameView)
1263         return;
1264     if (box().canResize())
1265         frameView->addResizerArea(box());
1266     else
1267         frameView->removeResizerArea(box());
1268 }
1269
1270 void DeprecatedPaintLayerScrollableArea::updateResizerStyle()
1271 {
1272     if (!m_resizer && !box().canResize())
1273         return;
1274
1275     LayoutObject* actualLayoutObject = layoutObjectForScrollbar(box());
1276     RefPtr<ComputedStyle> resizer = box().hasOverflowClip() ? actualLayoutObject->getUncachedPseudoStyle(PseudoStyleRequest(RESIZER), actualLayoutObject->style()) : PassRefPtr<ComputedStyle>(nullptr);
1277     if (resizer) {
1278         if (!m_resizer) {
1279             m_resizer = LayoutScrollbarPart::createAnonymous(&box().document());
1280             m_resizer->setDangerousOneWayParent(&box());
1281         }
1282         m_resizer->setStyle(resizer.release());
1283     } else if (m_resizer) {
1284         m_resizer->destroy();
1285         m_resizer = nullptr;
1286     }
1287 }
1288
1289 IntSize DeprecatedPaintLayerScrollableArea::offsetFromResizeCorner(const IntPoint& absolutePoint) const
1290 {
1291     // Currently the resize corner is either the bottom right corner or the bottom left corner.
1292     // FIXME: This assumes the location is 0, 0. Is this guaranteed to always be the case?
1293     IntSize elementSize = layer()->size();
1294     if (box().style()->shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
1295         elementSize.setWidth(0);
1296     IntPoint resizerPoint = IntPoint(elementSize);
1297     IntPoint localPoint = roundedIntPoint(box().absoluteToLocal(absolutePoint, UseTransforms));
1298     return localPoint - resizerPoint;
1299 }
1300
1301 void DeprecatedPaintLayerScrollableArea::resize(const PlatformEvent& evt, const LayoutSize& oldOffset)
1302 {
1303     // FIXME: This should be possible on generated content but is not right now.
1304     if (!inResizeMode() || !box().canResize() || !box().node())
1305         return;
1306
1307     ASSERT(box().node()->isElementNode());
1308     Element* element = toElement(box().node());
1309
1310     Document& document = element->document();
1311
1312     IntPoint pos;
1313     const PlatformGestureEvent* gevt = 0;
1314
1315     switch (evt.type()) {
1316     case PlatformEvent::MouseMoved:
1317         if (!document.frame()->eventHandler().mousePressed())
1318             return;
1319         pos = static_cast<const PlatformMouseEvent*>(&evt)->position();
1320         break;
1321     case PlatformEvent::GestureScrollUpdate:
1322         pos = static_cast<const PlatformGestureEvent*>(&evt)->position();
1323         gevt = static_cast<const PlatformGestureEvent*>(&evt);
1324         pos = gevt->position();
1325         pos.move(gevt->deltaX(), gevt->deltaY());
1326         break;
1327     default:
1328         ASSERT_NOT_REACHED();
1329     }
1330
1331     float zoomFactor = box().style()->effectiveZoom();
1332
1333     IntSize newOffset = offsetFromResizeCorner(document.view()->rootFrameToContents(pos));
1334     newOffset.setWidth(newOffset.width() / zoomFactor);
1335     newOffset.setHeight(newOffset.height() / zoomFactor);
1336
1337     LayoutSize currentSize = box().size();
1338     currentSize.scale(1 / zoomFactor);
1339     LayoutSize minimumSize = element->minimumSizeForResizing().shrunkTo(currentSize);
1340     element->setMinimumSizeForResizing(minimumSize);
1341
1342     LayoutSize adjustedOldOffset = LayoutSize(oldOffset.width() / zoomFactor, oldOffset.height() / zoomFactor);
1343     if (box().style()->shouldPlaceBlockDirectionScrollbarOnLogicalLeft()) {
1344         newOffset.setWidth(-newOffset.width());
1345         adjustedOldOffset.setWidth(-adjustedOldOffset.width());
1346     }
1347
1348     LayoutSize difference((currentSize + newOffset - adjustedOldOffset).expandedTo(minimumSize) - currentSize);
1349
1350     bool isBoxSizingBorder = box().style()->boxSizing() == BORDER_BOX;
1351
1352     EResize resize = box().style()->resize();
1353     if (resize != RESIZE_VERTICAL && difference.width()) {
1354         if (element->isFormControlElement()) {
1355             // Make implicit margins from the theme explicit (see <http://bugs.webkit.org/show_bug.cgi?id=9547>).
1356             element->setInlineStyleProperty(CSSPropertyMarginLeft, box().marginLeft() / zoomFactor, CSSPrimitiveValue::UnitType::Pixels);
1357             element->setInlineStyleProperty(CSSPropertyMarginRight, box().marginRight() / zoomFactor, CSSPrimitiveValue::UnitType::Pixels);
1358         }
1359         LayoutUnit baseWidth = box().size().width() - (isBoxSizingBorder ? LayoutUnit() : box().borderAndPaddingWidth());
1360         baseWidth = baseWidth / zoomFactor;
1361         element->setInlineStyleProperty(CSSPropertyWidth, roundToInt(baseWidth + difference.width()), CSSPrimitiveValue::UnitType::Pixels);
1362     }
1363
1364     if (resize != RESIZE_HORIZONTAL && difference.height()) {
1365         if (element->isFormControlElement()) {
1366             // Make implicit margins from the theme explicit (see <http://bugs.webkit.org/show_bug.cgi?id=9547>).
1367             element->setInlineStyleProperty(CSSPropertyMarginTop, box().marginTop() / zoomFactor, CSSPrimitiveValue::UnitType::Pixels);
1368             element->setInlineStyleProperty(CSSPropertyMarginBottom, box().marginBottom() / zoomFactor, CSSPrimitiveValue::UnitType::Pixels);
1369         }
1370         LayoutUnit baseHeight = box().size().height() - (isBoxSizingBorder ? LayoutUnit() : box().borderAndPaddingHeight());
1371         baseHeight = baseHeight / zoomFactor;
1372         element->setInlineStyleProperty(CSSPropertyHeight, roundToInt(baseHeight + difference.height()), CSSPrimitiveValue::UnitType::Pixels);
1373     }
1374
1375     document.updateLayout();
1376
1377     // FIXME (Radar 4118564): We should also autoscroll the window as necessary to keep the point under the cursor in view.
1378 }
1379
1380 LayoutRect DeprecatedPaintLayerScrollableArea::scrollIntoView(const LayoutRect& rect, const ScrollAlignment& alignX, const ScrollAlignment& alignY)
1381 {
1382     LayoutRect localExposeRect(box().absoluteToLocalQuad(FloatQuad(FloatRect(rect)), UseTransforms).boundingBox());
1383     localExposeRect.move(-box().borderLeft(), -box().borderTop());
1384     LayoutRect layerBounds(0, 0, box().clientWidth(), box().clientHeight());
1385     LayoutRect r = ScrollAlignment::getRectToExpose(layerBounds, localExposeRect, alignX, alignY);
1386
1387     DoublePoint clampedScrollPosition = clampScrollPosition(scrollPositionDouble() + roundedIntSize(r.location()));
1388     if (clampedScrollPosition == scrollPositionDouble())
1389         return rect;
1390
1391     DoubleSize oldScrollOffset = adjustedScrollOffset();
1392     scrollToPosition(clampedScrollPosition);
1393     DoubleSize scrollOffsetDifference = adjustedScrollOffset() - oldScrollOffset;
1394     localExposeRect.move(-LayoutSize(scrollOffsetDifference));
1395     return LayoutRect(box().localToAbsoluteQuad(FloatQuad(FloatRect(localExposeRect)), UseTransforms).boundingBox());
1396 }
1397
1398 void DeprecatedPaintLayerScrollableArea::updateScrollableAreaSet(bool hasOverflow)
1399 {
1400     LocalFrame* frame = box().frame();
1401     if (!frame)
1402         return;
1403
1404     FrameView* frameView = frame->view();
1405     if (!frameView)
1406         return;
1407
1408     // FIXME: Does this need to be fixed later for OOPI?
1409     bool isVisibleToHitTest = box().visibleToHitTesting();
1410     if (HTMLFrameOwnerElement* owner = frame->deprecatedLocalOwner())
1411         isVisibleToHitTest &= owner->layoutObject() && owner->layoutObject()->visibleToHitTesting();
1412
1413     bool didScrollOverflow = m_scrollsOverflow;
1414
1415     m_scrollsOverflow = hasOverflow && isVisibleToHitTest;
1416     if (didScrollOverflow == scrollsOverflow())
1417         return;
1418
1419     if (m_scrollsOverflow) {
1420         ASSERT(canHaveOverflowScrollbars(box()));
1421         frameView->addScrollableArea(this);
1422     } else {
1423         frameView->removeScrollableArea(this);
1424     }
1425 }
1426
1427 void DeprecatedPaintLayerScrollableArea::updateCompositingLayersAfterScroll()
1428 {
1429     DeprecatedPaintLayerCompositor* compositor = box().view()->compositor();
1430     if (compositor->inCompositingMode()) {
1431         if (usesCompositedScrolling()) {
1432             ASSERT(layer()->hasCompositedDeprecatedPaintLayerMapping());
1433             layer()->compositedDeprecatedPaintLayerMapping()->setNeedsGraphicsLayerUpdate(GraphicsLayerUpdateSubtree);
1434             compositor->setNeedsCompositingUpdate(CompositingUpdateAfterGeometryChange);
1435         } else {
1436             layer()->setNeedsCompositingInputsUpdate();
1437         }
1438     }
1439 }
1440
1441 bool DeprecatedPaintLayerScrollableArea::usesCompositedScrolling() const
1442 {
1443     // Scroll form controls on the main thread so they exhibit correct touch scroll event bubbling
1444     if (box().isIntrinsicallyScrollable(VerticalScrollbar) || box().isIntrinsicallyScrollable(HorizontalScrollbar))
1445         return false;
1446
1447     // See https://codereview.chromium.org/176633003/ for the tests that fail without this disabler.
1448     DisableCompositingQueryAsserts disabler;
1449     return layer()->hasCompositedDeprecatedPaintLayerMapping() && layer()->compositedDeprecatedPaintLayerMapping()->scrollingLayer();
1450 }
1451
1452 static bool layerNeedsCompositedScrolling(DeprecatedPaintLayerScrollableArea::LCDTextMode mode, const DeprecatedPaintLayer* layer)
1453 {
1454     if (mode == DeprecatedPaintLayerScrollableArea::ConsiderLCDText && !layer->compositor()->preferCompositingToLCDTextEnabled())
1455         return false;
1456
1457     return layer->scrollsOverflow()
1458         && !layer->hasDescendantWithClipPath()
1459         && !layer->hasAncestorWithClipPath()
1460         && !layer->layoutObject()->style()->hasBorderRadius();
1461 }
1462
1463 void DeprecatedPaintLayerScrollableArea::updateNeedsCompositedScrolling(LCDTextMode mode)
1464 {
1465     const bool needsCompositedScrolling = layerNeedsCompositedScrolling(mode, layer());
1466     if (static_cast<bool>(m_needsCompositedScrolling) != needsCompositedScrolling) {
1467         m_needsCompositedScrolling = needsCompositedScrolling;
1468         layer()->didUpdateNeedsCompositedScrolling();
1469     }
1470 }
1471
1472 void DeprecatedPaintLayerScrollableArea::setTopmostScrollChild(DeprecatedPaintLayer* scrollChild)
1473 {
1474     // We only want to track the topmost scroll child for scrollable areas with
1475     // overlay scrollbars.
1476     if (!hasOverlayScrollbars())
1477         return;
1478     m_nextTopmostScrollChild = scrollChild;
1479 }
1480
1481 bool DeprecatedPaintLayerScrollableArea::visualViewportSuppliesScrollbars() const
1482 {
1483     if (!layer()->isRootLayer())
1484         return false;
1485
1486     LocalFrame* frame = box().frame();
1487     if (!frame || !frame->isMainFrame() || !frame->settings())
1488         return false;
1489
1490     return frame->settings()->viewportMetaEnabled();
1491 }
1492
1493 } // namespace blink