Update PaintLayer size during layout, not after.

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

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights
  * reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@gmail.com>
@@ skipping 291 matching lines @@
 IntRect PaintLayerScrollableArea::ScrollCornerRect() const {
   // We have a scrollbar corner when a scrollbar is visible and not filling the
   // entire length of the box.
   // This happens when:
   // (a) A resizer is present and at least one scrollbar is present
   // (b) Both scrollbars are present.
   bool has_horizontal_bar = HorizontalScrollbar();
   bool has_vertical_bar = VerticalScrollbar();
   bool has_resizer = Box().Style()->Resize() != RESIZE_NONE;
   if ((has_horizontal_bar && has_vertical_bar) ||
-      (has_resizer && (has_horizontal_bar || has_vertical_bar)))
+      (has_resizer && (has_horizontal_bar || has_vertical_bar))) {
     return CornerRect(Box(), HorizontalScrollbar(), VerticalScrollbar(),
-                      Box().PixelSnappedBorderBoxRect());
+                      IntRect(IntPoint(), layer_.size()));
+  }
   return IntRect();
 }
 
 IntRect PaintLayerScrollableArea::ConvertFromScrollbarToContainingFrameViewBase(
     const Scrollbar& scrollbar,
     const IntRect& scrollbar_rect) const {
   LayoutView* view = Box().View();
   if (!view)
     return scrollbar_rect;
 
@@ skipping 223 matching lines @@
 }
 
 int PaintLayerScrollableArea::VisibleHeight() const {
   return Layer()->size().Height();
 }
 
 int PaintLayerScrollableArea::VisibleWidth() const {
   return Layer()->size().Width();
 }
 
+LayoutSize PaintLayerScrollableArea::ClientSize() const {
+  if (RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
+    bool is_main_frame_root_layer =
+        layer_.IsRootLayer() && Box().GetDocument().GetFrame()->IsMainFrame();
+    if (is_main_frame_root_layer) {
+      return LayoutSize(Box().GetFrameView()->GetLayoutSize());
+    }
+  }
+  return LayoutSize(Box().ClientWidth(), Box().ClientHeight());
+}
+
+IntSize PaintLayerScrollableArea::PixelSnappedClientSize() const {
+  if (RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
+    bool is_main_frame_root_layer =
+        layer_.IsRootLayer() && Box().GetDocument().GetFrame()->IsMainFrame();
+    if (is_main_frame_root_layer) {
+      return Box().GetFrameView()->GetLayoutSize();
+    }
+  }
+  return IntSize(Box().PixelSnappedClientWidth(),
+                 Box().PixelSnappedClientHeight());
+}
+
 IntSize PaintLayerScrollableArea::ContentsSize() const {
   return IntSize(PixelSnappedScrollWidth(), PixelSnappedScrollHeight());
 }
 
 void PaintLayerScrollableArea::ContentsResized() {
   ScrollableArea::ContentsResized();
   // Need to update the bounds of the scroll property.
   Box().SetNeedsPaintPropertyUpdate();
 }
 
@@ skipping 34 matching lines @@
 }
 
 bool PaintLayerScrollableArea::ScrollbarsCanBeActive() const {
   LayoutView* view = Box().View();
   if (!view)
     return false;
   return view->GetFrameView()->ScrollbarsCanBeActive();
 }
 
 IntRect PaintLayerScrollableArea::ScrollableAreaBoundingBox() const {
-  return Box().AbsoluteBoundingBoxRect(kTraverseDocumentBoundaries);
+  FloatQuad quad(FloatRect(FloatPoint(), FloatSize(layer_.size())));
+  quad = Box().LocalToAbsoluteQuad(quad, kTraverseDocumentBoundaries);
+  return quad.EnclosingBoundingBox();
 }
 
 void PaintLayerScrollableArea::RegisterForAnimation() {
   if (LocalFrame* frame = Box().GetFrame()) {
     if (FrameView* frame_view = frame->View())
       frame_view->AddAnimatingScrollableArea(this);
   }
 }
 
 void PaintLayerScrollableArea::DeregisterForAnimation() {
@@ skipping 29 matching lines @@
   return (overflow_style == EOverflow::kScroll ||
           overflow_style == EOverflow::kAuto ||
           overflow_style == EOverflow::kOverlay);
 }
 
 bool PaintLayerScrollableArea::ShouldPlaceVerticalScrollbarOnLeft() const {
   return Box().ShouldPlaceBlockDirectionScrollbarOnLogicalLeft();
 }
 
 int PaintLayerScrollableArea::PageStep(ScrollbarOrientation orientation) const {
+  // Note: For the root layer of the main frame, pageStep() will not be based
+  // on the scrollable area size (which matches the layout viewport), but
+  // instead on the initial containing block size.  It's unclear whether this
+  // is "correct" behavior; there is no spec guidance on the scroll distance
+  // of page scrolling in this circumstance.
   int length = (orientation == kHorizontalScrollbar)
-                   ? Box().PixelSnappedClientWidth()
-                   : Box().PixelSnappedClientHeight();
+                   ? PixelSnappedClientSize().Width()
+                   : PixelSnappedClientSize().Height();
   int min_page_step = static_cast<float>(length) *
                       ScrollableArea::MinFractionToStepWhenPaging();
   int page_step =
       max(min_page_step, length - ScrollableArea::MaxOverlapBetweenPages());
 
   return max(page_step, 1);
 }
 
 LayoutBox& PaintLayerScrollableArea::Box() const {
   return *layer_.GetLayoutBox();
@@ skipping 145 matching lines @@
 
   {
     // Hits in
     // compositing/overflow/automatically-opt-into-composited-scrolling-after-style-change.html.
     DisableCompositingQueryAsserts disabler;
 
     UpdateScrollbarEnabledState();
 
     // Set up the range (and page step/line step).
     if (Scrollbar* horizontal_scrollbar = this->HorizontalScrollbar()) {
-      int client_width = Box().PixelSnappedClientWidth();
+      int client_width = PixelSnappedClientSize().Width();
       horizontal_scrollbar->SetProportion(client_width,
                                           OverflowRect().Width().ToInt());
     }
     if (Scrollbar* vertical_scrollbar = this->VerticalScrollbar()) {
-      int client_height = Box().PixelSnappedClientHeight();
+      int client_height = PixelSnappedClientSize().Height();
       vertical_scrollbar->SetProportion(client_height,
                                         OverflowRect().Height().ToInt());
     }
   }
 
   if (!scrollbars_are_frozen && HasOverlayScrollbars()) {
     if (!ScrollSize(kHorizontalScrollbar))
       SetHasHorizontalScrollbar(false);
     if (!ScrollSize(kVerticalScrollbar))
       SetHasVerticalScrollbar(false);
@@ skipping 76 matching lines @@
 
 bool PaintLayerScrollableArea::HasHorizontalOverflow() const {
   // TODO(szager): Make the algorithm for adding/subtracting overflow:auto
   // scrollbars memoryless (crbug.com/625300).  This clientWidth hack will
   // prevent the spurious horizontal scrollbar, but it can cause a converse
   // problem: it can leave a sliver of horizontal overflow hidden behind the
   // vertical scrollbar without creating a horizontal scrollbar.  This
   // converse problem seems to happen much less frequently in practice, so we
   // bias the logic towards preventing unwanted horizontal scrollbars, which
   // are more common and annoying.
-  int client_width = Box().PixelSnappedClientWidth();
+  int client_width = PixelSnappedClientSize().Width();
   if (NeedsRelayout() && !HadVerticalScrollbarBeforeRelayout())
     client_width += VerticalScrollbarWidth();
   return PixelSnappedScrollWidth() > client_width;
 }
 
 bool PaintLayerScrollableArea::HasVerticalOverflow() const {
-  return PixelSnappedScrollHeight() > Box().PixelSnappedClientHeight();
+  return PixelSnappedScrollHeight() > PixelSnappedClientSize().Height();
 }
 
 bool PaintLayerScrollableArea::HasScrollableHorizontalOverflow() const {
   return HasHorizontalOverflow() && Box().ScrollsOverflowX();
 }
 
 bool PaintLayerScrollableArea::HasScrollableVerticalOverflow() const {
   return HasVerticalOverflow() && Box().ScrollsOverflowY();
 }
 
@@ skipping 87 matching lines @@
   const bool layers_changed =
       topmost_scroll_child_ != next_topmost_scroll_child_;
   topmost_scroll_child_ = next_topmost_scroll_child_;
   next_topmost_scroll_child_ = nullptr;
   return layers_changed;
 }
 
 void PaintLayerScrollableArea::UpdateAfterOverflowRecalc() {
   UpdateScrollDimensions();
   if (Scrollbar* horizontal_scrollbar = this->HorizontalScrollbar()) {
-    int client_width = Box().PixelSnappedClientWidth();
+    int client_width = PixelSnappedClientSize().Width();
     horizontal_scrollbar->SetProportion(client_width,
                                         OverflowRect().Width().ToInt());
   }
   if (Scrollbar* vertical_scrollbar = this->VerticalScrollbar()) {
-    int client_height = Box().PixelSnappedClientHeight();
+    int client_height = PixelSnappedClientSize().Height();
     vertical_scrollbar->SetProportion(client_height,
                                       OverflowRect().Height().ToInt());
   }
 
   bool needs_horizontal_scrollbar;
   bool needs_vertical_scrollbar;
   ComputeScrollbarExistence(needs_horizontal_scrollbar,
                             needs_vertical_scrollbar);
 
   bool horizontal_scrollbar_should_change =
@@ skipping 58 matching lines @@
              ? VerticalScrollbar()->ScrollbarThickness()
              : ResizerCornerRect(Box().PixelSnappedBorderBoxRect(),
                                  kResizerForPointer)
                    .Width();
   return x;
 }
 
 IntSize PaintLayerScrollableArea::ScrollbarOffset(
     const Scrollbar& scrollbar) const {
   if (&scrollbar == VerticalScrollbar()) {
-    return IntSize(VerticalScrollbarStart(0, Box().Size().Width().ToInt()),
+    return IntSize(VerticalScrollbarStart(0, layer_.size().Width()),
                    Box().BorderTop().ToInt());
   }
 
-  if (&scrollbar == HorizontalScrollbar())
-    return IntSize(
-        HorizontalScrollbarStart(0),
-        (Box().Size().Height() - Box().BorderBottom() - scrollbar.Height())
-            .ToInt());
+  if (&scrollbar == HorizontalScrollbar()) {
+    return IntSize(HorizontalScrollbarStart(0),
+                   layer_.size().Height() - Box().BorderBottom().ToInt() -
+                       scrollbar.Height());
+  }
 
   ASSERT_NOT_REACHED();
   return IntSize();
 }
 
 static inline const LayoutObject& ScrollbarStyleSource(
     const LayoutObject& layout_object) {
   if (Node* node = layout_object.GetNode()) {
     if (layout_object.IsLayoutView()) {
       Document& doc = node->GetDocument();
@@ skipping 208 matching lines @@
       HorizontalScrollbar()->IsOverlayScrollbar()) {
     return 0;
   }
   return HorizontalScrollbar()->ScrollbarThickness();
 }
 
 void PaintLayerScrollableArea::PositionOverflowControls() {
   if (!HasScrollbar() && !Box().CanResize())
     return;
 
-  const IntRect border_box = Box().PixelSnappedBorderBoxRect();
+  const IntRect layer_bounds(IntPoint(), layer_.size());
   if (Scrollbar* vertical_scrollbar = this->VerticalScrollbar())
-    vertical_scrollbar->SetFrameRect(RectForVerticalScrollbar(border_box));
+    vertical_scrollbar->SetFrameRect(RectForVerticalScrollbar(layer_bounds));
 
-  if (Scrollbar* horizontal_scrollbar = this->HorizontalScrollbar())
-    horizontal_scrollbar->SetFrameRect(RectForHorizontalScrollbar(border_box));
+  if (Scrollbar* horizontal_scrollbar = this->HorizontalScrollbar()) {
+    horizontal_scrollbar->SetFrameRect(
+        RectForHorizontalScrollbar(layer_bounds));
+  }
 
   const IntRect& scroll_corner = ScrollCornerRect();
   if (scroll_corner_)
     scroll_corner_->SetFrameRect(LayoutRect(scroll_corner));
 
-  if (resizer_)
+  if (resizer_) {
     resizer_->SetFrameRect(
-        LayoutRect(ResizerCornerRect(border_box, kResizerForPointer)));
+        LayoutRect(ResizerCornerRect(layer_bounds, kResizerForPointer)));
+  }
 
   // FIXME, this should eventually be removed, once we are certain that
   // composited controls get correctly positioned on a compositor update. For
   // now, conservatively leaving this unchanged.
   if (Layer()->HasCompositedLayerMapping())
     Layer()->GetCompositedLayerMapping()->PositionOverflowControlsLayers();
 }
 
 void PaintLayerScrollableArea::UpdateScrollCornerStyle() {
   if (!scroll_corner_ && !HasScrollbar())
@@ skipping 22 matching lines @@
 }
 
 bool PaintLayerScrollableArea::HitTestOverflowControls(
     HitTestResult& result,
     const IntPoint& local_point) {
   if (!HasScrollbar() && !Box().CanResize())
     return false;
 
   IntRect resize_control_rect;
   if (Box().Style()->Resize() != RESIZE_NONE) {
-    resize_control_rect = ResizerCornerRect(Box().PixelSnappedBorderBoxRect(),
+    resize_control_rect = ResizerCornerRect(IntRect(IntPoint(), layer_.size()),
                                             kResizerForPointer);
     if (resize_control_rect.Contains(local_point))
       return true;
   }
 
   int resize_control_size = max(resize_control_rect.Height(), 0);
   if (HasVerticalScrollbar() &&
       VerticalScrollbar()->ShouldParticipateInHitTesting()) {
     LayoutRect v_bar_rect(
         VerticalScrollbarStart(0, Box().Size().Width().ToInt()),
         Box().BorderTop().ToInt(), VerticalScrollbar()->ScrollbarThickness(),
-        Box().Size().Height().ToInt() -
+        layer_.size().Height() -
             (Box().BorderTop() + Box().BorderBottom()).ToInt() -
             (HasHorizontalScrollbar()
                  ? HorizontalScrollbar()->ScrollbarThickness()
                  : resize_control_size));
     if (v_bar_rect.Contains(local_point)) {
       result.SetScrollbar(VerticalScrollbar());
       return true;
     }
   }
 
   resize_control_size = max(resize_control_rect.Width(), 0);
   if (HasHorizontalScrollbar() &&
       HorizontalScrollbar()->ShouldParticipateInHitTesting()) {
     // TODO(crbug.com/638981): Are the conversions to int intentional?
     LayoutRect h_bar_rect(
         HorizontalScrollbarStart(0),
-        (Box().Size().Height() - Box().BorderBottom() -
+        (layer_.size().Height() - Box().BorderBottom() -
          HorizontalScrollbar()->ScrollbarThickness())
             .ToInt(),
-        (Box().Size().Width() - (Box().BorderLeft() + Box().BorderRight()) -
+        (layer_.size().Width() - (Box().BorderLeft() + Box().BorderRight()) -
          (HasVerticalScrollbar() ? VerticalScrollbar()->ScrollbarThickness()
                                  : resize_control_size))
             .ToInt(),
         HorizontalScrollbar()->ScrollbarThickness());
     if (h_bar_rect.Contains(local_point)) {
       result.SetScrollbar(HorizontalScrollbar());
       return true;
     }
   }
 
@@ skipping 35 matching lines @@
 }
 
 bool PaintLayerScrollableArea::IsPointInResizeControl(
     const IntPoint& absolute_point,
     ResizerHitTestType resizer_hit_test_type) const {
   if (!Box().CanResize())
     return false;
 
   IntPoint local_point =
       RoundedIntPoint(Box().AbsoluteToLocal(absolute_point, kUseTransforms));
-  IntRect local_bounds(0, 0, Box().PixelSnappedWidth(),
-                       Box().PixelSnappedHeight());
+  IntRect local_bounds(IntPoint(), layer_.size());
   return ResizerCornerRect(local_bounds, resizer_hit_test_type)
       .Contains(local_point);
 }
 
 bool PaintLayerScrollableArea::HitTestResizerInFragments(
     const PaintLayerFragments& layer_fragments,
     const HitTestLocation& hit_test_location) const {
   if (!Box().CanResize())
     return false;
 
@@ skipping 173 matching lines @@
 LayoutRect PaintLayerScrollableArea::ScrollIntoView(
     const LayoutRect& rect,
     const ScrollAlignment& align_x,
     const ScrollAlignment& align_y,
     ScrollType scroll_type) {
   LayoutRect local_expose_rect(
       Box()
           .AbsoluteToLocalQuad(FloatQuad(FloatRect(rect)), kUseTransforms)
           .BoundingBox());
   local_expose_rect.Move(-Box().BorderLeft(), -Box().BorderTop());
-  LayoutRect layer_bounds(
-      LayoutPoint(), LayoutSize(Box().ClientWidth(), Box().ClientHeight()));
+  LayoutRect visible_rect(LayoutPoint(), ClientSize());
   LayoutRect r = ScrollAlignment::GetRectToExpose(
-      layer_bounds, local_expose_rect, align_x, align_y);
+      visible_rect, local_expose_rect, align_x, align_y);
 
   ScrollOffset old_scroll_offset = GetScrollOffset();
   ScrollOffset new_scroll_offset(ClampScrollOffset(RoundedIntSize(
       ToScrollOffset(FloatPoint(r.Location()) + old_scroll_offset))));
   SetScrollOffset(new_scroll_offset, scroll_type, kScrollBehaviorInstant);
   ScrollOffset scroll_offset_difference = GetScrollOffset() - old_scroll_offset;
   local_expose_rect.Move(-LayoutSize(scroll_offset_difference));
 
   LayoutRect intersect =
-      LocalToAbsolute(Box(), Intersection(layer_bounds, local_expose_rect));
-  if (intersect.IsEmpty() && !layer_bounds.IsEmpty() &&
+      LocalToAbsolute(Box(), Intersection(visible_rect, local_expose_rect));
+  if (intersect.IsEmpty() && !visible_rect.IsEmpty() &&
       !local_expose_rect.IsEmpty()) {
     return LocalToAbsolute(Box(), local_expose_rect);
   }
   return intersect;
 }
 
 void PaintLayerScrollableArea::UpdateScrollableAreaSet(bool has_overflow) {
   LocalFrame* frame = Box().GetFrame();
   if (!frame)
     return;
@@ skipping 417 matching lines @@
 
 void PaintLayerScrollableArea::DelayScrollOffsetClampScope::
     ClampScrollableAreas() {
   for (auto& scrollable_area : *needs_clamp_)
     scrollable_area->ClampScrollOffsetAfterOverflowChange();
   delete needs_clamp_;
   needs_clamp_ = nullptr;
 }
 
 }  // namespace blink