Fix not autosizing ruby elements issue.

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

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 12 matching lines @@
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/layout/TextAutosizer.h"
 
+#include <memory>
 #include "core/dom/Document.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/frame/VisualViewport.h"
 #include "core/html/HTMLTextAreaElement.h"
 #include "core/layout/LayoutBlock.h"
 #include "core/layout/LayoutInline.h"
 #include "core/layout/LayoutListItem.h"
 #include "core/layout/LayoutListMarker.h"
+#include "core/layout/LayoutRubyRun.h"
 #include "core/layout/LayoutTable.h"
 #include "core/layout/LayoutTableCell.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/api/LayoutAPIShim.h"
 #include "core/layout/api/LayoutViewItem.h"
 #include "core/page/Page.h"
 #include "wtf/PtrUtil.h"
-#include <memory>
 
 #ifdef AUTOSIZING_DOM_DEBUG_INFO
 #include "core/dom/ExecutionContextTask.h"
 #endif
 
 namespace blink {
 
 #ifdef AUTOSIZING_DOM_DEBUG_INFO
 class WriteDebugInfoTask : public ExecutionContextTask {
  public:
@@ skipping 331 matching lines @@
   }
 }
 
 void TextAutosizer::beginLayout(LayoutBlock* block,
                                 SubtreeLayoutScope* layouter) {
   ASSERT(shouldHandleLayout());
 
   if (prepareForLayout(block) == StopLayout)
     return;
 
+  // Skip ruby's inner blocks, because these blocks already are inflated.
+  if (block->isRubyRun() || block->isRubyBase() || block->isRubyText())
+    return;
+
   ASSERT(!m_clusterStack.isEmpty() || block->isLayoutView());
 
   if (Cluster* cluster = maybeCreateCluster(block))
     m_clusterStack.push_back(WTF::wrapUnique(cluster));
 
   ASSERT(!m_clusterStack.isEmpty());
 
   // Cells in auto-layout tables are handled separately by inflateAutoTable.
   bool isAutoTableCell =
       block->isTableCell() &&
@@ skipping 50 matching lines @@
 }
 
 float TextAutosizer::inflate(LayoutObject* parent,
                              SubtreeLayoutScope* layouter,
                              InflateBehavior behavior,
                              float multiplier) {
   Cluster* cluster = currentCluster();
   bool hasTextChild = false;
 
   LayoutObject* child = nullptr;
-  if (parent->isLayoutBlock() &&
-      (parent->childrenInline() || behavior == DescendToInnerBlocks))
+  if (parent->isRuby()) {
+    // Skip layoutRubyRun which is inline-block.
+    // Inflate rubyRun's inner blocks.
+    LayoutObject* run = parent->slowFirstChild();
+    if (run && run->isRubyRun()) {
+      child = toLayoutRubyRun(run)->firstChild();
+      behavior = DescendToInnerBlocks;
+    }
+  } else if (parent->isLayoutBlock() &&
+             (parent->childrenInline() || behavior == DescendToInnerBlocks)) {
     child = toLayoutBlock(parent)->firstChild();
-  else if (parent->isLayoutInline())
+  } else if (parent->isLayoutInline()) {
     child = toLayoutInline(parent)->firstChild();
+  }
 
   while (child) {
     if (child->isText()) {
       hasTextChild = true;
       // We only calculate this multiplier on-demand to ensure the parent block
       // of this text has entered layout.
       if (!multiplier)
         multiplier =
             cluster->m_flags & SUPPRESSING ? 1.0f : clusterMultiplier(cluster);
       applyMultiplier(child, multiplier, layouter);
 
-      // FIXME: Investigate why MarkOnlyThis is sufficient.
-      if (parent->isLayoutInline())
+      if (behavior == DescendToInnerBlocks) {
+        // The ancestor nodes might be inline-blocks. We should
+        // setPreferredLogicalWidthsDirty for ancestor nodes here.
+        child->setPreferredLogicalWidthsDirty();
+      } else if (parent->isLayoutInline()) {
+        // FIXME: Investigate why MarkOnlyThis is sufficient.
         child->setPreferredLogicalWidthsDirty(MarkOnlyThis);
+      }
     } else if (child->isLayoutInline()) {
       multiplier = inflate(child, layouter, behavior, multiplier);
     } else if (child->isLayoutBlock() && behavior == DescendToInnerBlocks &&
                !classifyBlock(child,
                               INDEPENDENT | EXPLICIT_WIDTH | SUPPRESSING)) {
       multiplier = inflate(child, layouter, behavior, multiplier);
     }
     child = child->nextSibling();
   }
 
@@ skipping 664 matching lines @@
   style->setUnique();
 
   switch (relayoutBehavior) {
     case AlreadyInLayout:
       // Don't free currentStyle until the end of the layout pass. This allows
       // other parts of the system to safely hold raw ComputedStyle* pointers
       // during layout, e.g. BreakingContext::m_currentStyle.
       m_stylesRetainedDuringLayout.push_back(&currentStyle);
 
       layoutObject->setStyleInternal(std::move(style));
+      if (layoutObject->isText())
+        toLayoutText(layoutObject)->autosizingMultiplerChanged();
       DCHECK(!layouter || layoutObject->isDescendantOf(&layouter->root()));
       layoutObject->setNeedsLayoutAndFullPaintInvalidation(
           LayoutInvalidationReason::TextAutosizing, MarkContainerChain,
           layouter);
       break;
 
     case LayoutNeeded:
       DCHECK(!layouter);
       layoutObject->setStyle(std::move(style));
       break;
@@ skipping 245 matching lines @@
     }
   }
   potentiallyInconsistentSuperclusters.clear();
 }
 
 DEFINE_TRACE(TextAutosizer) {
   visitor->trace(m_document);
 }
 
 }  // namespace blink