Update layer size from LayoutBox::UpdateAfterLayout

third_party/WebKit/Source/core/paint/PaintLayer.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@web.de>
@@ skipping 770 matching lines @@
       child_has3d = true;
 
     if (child_has3d) {
       has3d_transformed_descendant_ = true;
       break;
     }
   }
 }
 
 void PaintLayer::UpdateLayerPosition() {
+  // LayoutBoxes will call UpdateSizeAndScrollingAfterLayout() from
+  // LayoutBox::UpdateAfterLayout, but LayoutInlines will still need to update

[bokan, 2017/05/12 15:58:18]

This may be a naive question as I'm a layout-outsider, but what makes inlines
special here? Why can't they call UpdateSizeAndScrollingAfterLayout after they
layout/get their size in the same way a LayoutBox does? I noticed that
LayoutInline::UpdateLayout is a NOTREACHED so I'm guessing it's special somehow;
how does an inline get its size?

[szager1, 2017/05/12 19:12:13]

LayoutInline's don't run their own layout; instead, their parent LayoutBlockFlow
creates a line box tree (instances of InlineFlowBox) and lays them out. 
LayoutInline gets its geometry from the geometry of its constituent
InlineFlowBox'es.

LayoutBlockFlow iterates over the line box tree when running layout, so there
isn't currently an iteration over LayoutInline's where we can call
UpdateSizeAndScrollingAfterLayout.  I could add an iteration to do this in
LayoutBlockFlow::LayoutInlineChildren, after the call to LayoutRunsAndFloats,
but I don't really think it's worth the performance cost.

+  // their size.
+  if (GetLayoutObject().IsInline() && GetLayoutObject().IsLayoutInline())
+    UpdateSizeAndScrollingAfterLayout();
   LayoutPoint local_point;
-
-  bool did_resize = false;
-  if (GetLayoutObject().IsInline() && GetLayoutObject().IsLayoutInline()) {
-    LayoutInline& inline_flow = ToLayoutInline(GetLayoutObject());
-    IntRect line_box = EnclosingIntRect(inline_flow.LinesBoundingBox());
-    size_ = line_box.Size();
-  } else if (LayoutBox* box = GetLayoutBox()) {
-    IntSize new_size = PixelSnappedIntSize(box->Size(), box->Location());
-    did_resize = new_size != size_;
-    size_ = new_size;
+  if (LayoutBox* box = GetLayoutBox()) {
     local_point.MoveBy(box->PhysicalLocation());
   }
 
   if (!GetLayoutObject().IsOutOfFlowPositioned() &&
       !GetLayoutObject().IsColumnSpanAll()) {
     // We must adjust our position by walking up the layout tree looking for the
     // nearest enclosing object with a layer.
     LayoutObject* curr = GetLayoutObject().Container();
     while (curr && !curr->HasLayer()) {
       if (curr->IsBox() && !curr->IsTableRow()) {
@@ skipping 30 matching lines @@
     LayoutSize new_offset = GetLayoutObject().OffsetForInFlowPosition();
     if (rare_data_ || !new_offset.IsZero())
       EnsureRareData().offset_for_in_flow_position = new_offset;
     local_point.Move(new_offset);
   } else if (rare_data_) {
     rare_data_->offset_for_in_flow_position = LayoutSize();
   }
 
   location_ = local_point;
 
-  if (scrollable_area_ && did_resize)
-    scrollable_area_->VisibleSizeChanged();
-
 #if DCHECK_IS_ON()
   needs_position_update_ = false;
 #endif
 }
 
-void PaintLayer::UpdateScrollingAfterLayout() {
-  if (GetLayoutObject().HasOverflowClip())
+bool PaintLayer::UpdateSize() {
+  bool did_resize = false;
+  if (IsRootLayer() && RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
+    const IntSize new_size = GetLayoutObject().GetDocument().View()->Size();
+    did_resize = new_size != size_;
+    size_ = new_size;
+  } else if (GetLayoutObject().IsInline() &&
+             GetLayoutObject().IsLayoutInline()) {
+    LayoutInline& inline_flow = ToLayoutInline(GetLayoutObject());
+    IntRect line_box = EnclosingIntRect(inline_flow.LinesBoundingBox());
+    size_ = line_box.Size();

[skobes, 2017/05/16 22:22:22]

Why is did_resize not set in this branch?

[szager, 2017/05/16 23:55:46]

This preserves the existing logic.  did_resize is only used to decide whether to
call PLSA->VisibleSizeChanged().  A LayoutInline can't be scrollable, so size
changes to LayoutInline's are not interesting.

Having said that: now that UpdateSize is a separate, public method, it makes no
sense to preserve that logic, and it won't affect anything in the existing code,
so I changed it so that did_resize will be set for inlines that change size.

+  } else if (LayoutBox* box = GetLayoutBox()) {
+    IntSize new_size = PixelSnappedIntSize(box->Size(), box->Location());
+    did_resize = new_size != size_;
+    size_ = new_size;
+  }
+  return did_resize;
+}
+
+void PaintLayer::UpdateSizeAndScrollingAfterLayout() {
+  bool did_resize = UpdateSize();
+  if (GetLayoutObject().HasOverflowClip()) {
     scrollable_area_->UpdateAfterLayout();
+    if (did_resize)
+      scrollable_area_->VisibleSizeChanged();

[bokan, 2017/05/12 15:58:18]

Any reason not to put this in UpdateSize().

[szager1, 2017/05/12 19:12:13]

UpdateSize is also called from LayoutBoxModelObject::StyleDidChange, but it's
not safe to call into scrollable_area_ at that point.

+  }
 }
 
 TransformationMatrix PaintLayer::PerspectiveTransform() const {
   if (!GetLayoutObject().HasTransformRelatedProperty())
     return TransformationMatrix();
 
   const ComputedStyle& style = GetLayoutObject().StyleRef();
   if (!style.HasPerspective())
     return TransformationMatrix();
 
@@ skipping 2454 matching lines @@
 }
 
 void showLayerTree(const blink::LayoutObject* layoutObject) {
   if (!layoutObject) {
     LOG(INFO) << "Cannot showLayerTree. Root is (nil)";
     return;
   }
   showLayerTree(layoutObject->EnclosingLayer());
 }
 #endif