Fix preferred logical widths of orthogonal writing modes

third_party/WebKit/Source/core/layout/LayoutBox.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 115 matching lines @@
 
 void LayoutBox::willBeDestroyed()
 {
     clearOverrideSize();
     clearContainingBlockOverrideSize();
     clearExtraInlineAndBlockOffests();
 
     if (isOutOfFlowPositioned())
         LayoutBlock::removePositionedObject(this);
     removeFromPercentHeightContainer();
+    if (!documentBeingDestroyed() && isOrthogonalWritingModeRoot())
+        unmarkOrthogonalWritingModeRoot();
 
     ShapeOutsideInfo::removeInfo(*this);
 
     LayoutBoxModelObject::willBeDestroyed();
 }
 
+void LayoutBox::insertedIntoTree()
+{
+    LayoutBoxModelObject::insertedIntoTree();
+
+    if (isOrthogonalWritingModeRoot())
+        markOrthogonalWritingModeRoot();
+}
+
+void LayoutBox::willBeRemovedFromTree()
+{
+    if (!documentBeingDestroyed() && isOrthogonalWritingModeRoot())
+        unmarkOrthogonalWritingModeRoot();
+
+    LayoutBoxModelObject::willBeRemovedFromTree();
+}
+
 void LayoutBox::removeFloatingOrPositionedChildFromBlockLists()
 {
     ASSERT(isFloatingOrOutOfFlowPositioned());
 
     if (documentBeingDestroyed())
         return;
 
     if (isFloating()) {
         LayoutBlockFlow* parentBlockFlow = nullptr;
         for (LayoutObject* curr = parent(); curr && !curr->isLayoutView(); curr = curr->parent()) {
@@ skipping 64 matching lines @@
     // (as part of the LayoutBoxModelObject::styleDidChange call below). So, we can safely cache the horizontal
     // writing mode value before style change here.
     bool oldHorizontalWritingMode = isHorizontalWritingMode();
 
     LayoutBoxModelObject::styleDidChange(diff, oldStyle);
 
     const ComputedStyle& newStyle = styleRef();
     if (needsLayout() && oldStyle)
         removeFromPercentHeightContainer();
 
-    if (oldHorizontalWritingMode != isHorizontalWritingMode())
+    if (oldHorizontalWritingMode != isHorizontalWritingMode()) {
+        if (parent()) {

[esprehn, 2016/01/31 00:44:56]

The only times you go through here without a parent are:

you're the LayoutView, you're being first constructed before you get inserted,
so insertedIntoTree handles it.

Which case are you guarding here though?

[kojii, 2016/01/31 01:12:20]

This "if" avoids:
* Mark/unmark twice for when first constructed as you said.
* isOrthogonalWritingModeRoot() needs parent() to determine whether it's
orthogonal or not.
so insertedIntoTree() handles when constructed, while this code needs to handle
when styles were changed.

Did I miss something? I actually haven't gone though we always re-attach when
writing-mode is changed, and if that's the case, this code may not run at all.
Are you saying that's the case?

+            if (isOrthogonalWritingModeRoot())
+                markOrthogonalWritingModeRoot();
+            else
+                unmarkOrthogonalWritingModeRoot();
+        }
+
         clearPercentHeightDescendants();
+    }
 
     // If our zoom factor changes and we have a defined scrollLeft/Top, we need to adjust that value into the
     // new zoomed coordinate space.
     if (hasOverflowClip() && oldStyle && oldStyle->effectiveZoom() != newStyle.effectiveZoom() && layer()) {
         if (int left = layer()->scrollableArea()->scrollXOffset()) {
             left = (left / oldStyle->effectiveZoom()) * newStyle.effectiveZoom();
             layer()->scrollableArea()->scrollToXOffset(left);
         }
         if (int top = layer()->scrollableArea()->scrollYOffset()) {
             top = (top / oldStyle->effectiveZoom()) * newStyle.effectiveZoom();
@@ skipping 3689 matching lines @@
 
 void LayoutBox::markForPaginationRelayoutIfNeeded(SubtreeLayoutScope& layoutScope)
 {
     ASSERT(!needsLayout());
     // If fragmentation height has changed, we need to lay out. No need to enter the layoutObject if it
     // is childless, though.
     if (view()->layoutState()->pageLogicalHeightChanged() && slowFirstChild())
         layoutScope.setChildNeedsLayout(this);
 }
 
+void LayoutBox::markOrthogonalWritingModeRoot()
+{
+    ASSERT(frameView());
+    frameView()->addOrthogonalWritingModeRoot(*this);
+}
+
+void LayoutBox::unmarkOrthogonalWritingModeRoot()
+{
+    ASSERT(frameView());
+    frameView()->removeOrthogonalWritingModeRoot(*this);
+}
+
 void LayoutBox::addVisualEffectOverflow()
 {
     if (!style()->hasVisualOverflowingEffect())
         return;
 
     // Add in the final overflow with shadows, outsets and outline combined.
     LayoutRect visualEffectOverflow = borderBoxRect();
     visualEffectOverflow.expand(computeVisualEffectOverflowOutsets());
     addVisualOverflow(visualEffectOverflow);
 }
@@ skipping 693 matching lines @@
 
 void LayoutBox::clearPercentHeightDescendants()
 {
     for (LayoutObject* curr = slowFirstChild(); curr; curr = curr->nextInPreOrder(this)) {
         if (curr->isBox())
             toLayoutBox(curr)->removeFromPercentHeightContainer();
     }
 }
 
 } // namespace blink