[LayoutNG] Remove checks for layout_box_ inside NGBlockNode.

third_party/WebKit/Source/core/layout/ng/ng_block_node.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/layout/ng/ng_block_node.h"
 
 #include "core/layout/LayoutBlockFlow.h"
 #include "core/layout/api/LineLayoutAPIShim.h"
 #include "core/layout/line/InlineIterator.h"
 #include "core/layout/ng/layout_ng_block_flow.h"
@@ skipping 67 matching lines @@
 
 // Need an explicit destructor in the .cc file, or the MSWIN compiler will
 // produce an error when attempting to generate a default one, if the .h file is
 // included from a compilation unit that lacks the ComputedStyle definition.
 NGBlockNode::~NGBlockNode() {}
 
 RefPtr<NGLayoutResult> NGBlockNode::Layout(NGConstraintSpace* constraint_space,
                                            NGBreakToken* break_token) {
   // Use the old layout code and synthesize a fragment.
   if (!CanUseNewLayout()) {
-    DCHECK(layout_box_);
     return RunOldLayout(*constraint_space);
   }
 
   RefPtr<NGLayoutResult> layout_result =
       NGBlockLayoutAlgorithm(this, constraint_space,
                              toNGBlockBreakToken(break_token))
           .Layout();
 
   CopyFragmentDataToLayoutBox(*constraint_space, layout_result.get());
   return layout_result;
 }
 
 MinMaxContentSize NGBlockNode::ComputeMinMaxContentSize() {
   MinMaxContentSize sizes;
   if (!CanUseNewLayout()) {
-    DCHECK(layout_box_);
     // TODO(layout-ng): This could be somewhat optimized by directly calling
     // computeIntrinsicLogicalWidths, but that function is currently private.
     // Consider doing that if this becomes a performance issue.
     LayoutUnit borderAndPadding = layout_box_->borderAndPaddingLogicalWidth();
     sizes.min_content = layout_box_->computeLogicalWidthUsing(
                             MainOrPreferredSize, Length(MinContent),
                             LayoutUnit(), layout_box_->containingBlock()) -
                         borderAndPadding;
     sizes.max_content = layout_box_->computeLogicalWidthUsing(
                             MainOrPreferredSize, Length(MaxContent),
@@ skipping 34 matching lines @@
 
   layout_result = Layout(constraint_space.get());
   physical_fragment = layout_result->PhysicalFragment().get();
   NGBoxFragment max_fragment(FromPlatformWritingMode(Style().getWritingMode()),
                              toNGPhysicalBoxFragment(physical_fragment));
   sizes.max_content = max_fragment.InlineOverflow();
   return sizes;
 }
 
 const ComputedStyle& NGBlockNode::Style() const {
-  DCHECK(layout_box_);
   return layout_box_->styleRef();
 }
 
 NGLayoutInputNode* NGBlockNode::NextSibling() {
   if (!next_sibling_) {
-    LayoutObject* next_sibling =
-        layout_box_ ? layout_box_->nextSibling() : nullptr;
+    LayoutObject* next_sibling = layout_box_->nextSibling();
     if (next_sibling) {
       if (next_sibling->isInline())
         next_sibling_ = new NGInlineNode(next_sibling, &Style());
       else
         next_sibling_ = new NGBlockNode(next_sibling);
     }
   }
   return next_sibling_;
 }
 
 LayoutObject* NGBlockNode::GetLayoutObject() {
   return layout_box_;
 }
 
 NGLayoutInputNode* NGBlockNode::FirstChild() {
   if (!first_child_) {
-    LayoutObject* child = layout_box_ ? layout_box_->slowFirstChild() : nullptr;
+    LayoutObject* child = layout_box_->slowFirstChild();
     if (child) {
       if (child->isInline()) {
         first_child_ = new NGInlineNode(child, &Style());
       } else {
         first_child_ = new NGBlockNode(child);
       }
     }
   }
   return first_child_;
 }
 
 DEFINE_TRACE(NGBlockNode) {
   visitor->trace(next_sibling_);
   visitor->trace(first_child_);
   NGLayoutInputNode::trace(visitor);
 }
 
 bool NGBlockNode::CanUseNewLayout() {
-  if (!layout_box_)
-    return true;
   if (!layout_box_->isLayoutBlockFlow())
     return false;
   return RuntimeEnabledFeatures::layoutNGInlineEnabled() ||
          !HasInlineChildren();
 }
 
 bool NGBlockNode::HasInlineChildren() {
-  if (!layout_box_ || !layout_box_->isLayoutBlockFlow())
+  if (!layout_box_->isLayoutBlockFlow())
     return false;
 
   const LayoutBlockFlow* block_flow = toLayoutBlockFlow(layout_box_);
   if (!block_flow->childrenInline())
     return false;
   LayoutObject* child = block_flow->firstChild();
   while (child) {
     if (child->isInline())
       return true;
     child = child->nextSibling();
   }
 
   return false;
 }
 
 void NGBlockNode::CopyFragmentDataToLayoutBox(
     const NGConstraintSpace& constraint_space,
     NGLayoutResult* layout_result) {
-  // We may not have a layout_box_ during unit tests.
-  if (!layout_box_)
-    return;
-
   NGPhysicalBoxFragment* fragment =
       toNGPhysicalBoxFragment(layout_result->PhysicalFragment().get());
 
   layout_box_->setWidth(fragment->Width());
   layout_box_->setHeight(fragment->Height());
   NGBoxStrut border_and_padding = ComputeBorders(constraint_space, Style()) +
                                   ComputePadding(constraint_space, Style());
   LayoutUnit intrinsic_logical_height =
       layout_box_->style()->isHorizontalWritingMode()
           ? fragment->HeightOverflow()
@@ skipping 91 matching lines @@
       .SetBlockSize(layout_box_->logicalHeight())
       .SetDirection(layout_box_->styleRef().direction())
       .SetWritingMode(
           FromPlatformWritingMode(layout_box_->styleRef().getWritingMode()))
       .SetInlineOverflow(overflow.width())
       .SetBlockOverflow(overflow.height());
   return builder.ToBoxFragment();
 }
 
 void NGBlockNode::UseOldOutOfFlowPositioning() {
-  DCHECK(layout_box_);
   DCHECK(layout_box_->isOutOfFlowPositioned());
   layout_box_->containingBlock()->insertPositionedObject(layout_box_);
 }
 
 // Save static position for legacy AbsPos layout.
 void NGBlockNode::SaveStaticOffsetForLegacy(const NGLogicalOffset& offset) {
-  DCHECK(layout_box_);
   DCHECK(layout_box_->isOutOfFlowPositioned());
   DCHECK(layout_box_->layer());
   layout_box_->layer()->setStaticBlockPosition(offset.block_offset);
   layout_box_->layer()->setStaticInlinePosition(offset.inline_offset);
 }
 
 }  // namespace blink