Remove redundant casts, use NGLayoutInputNode base functions everywhere

third_party/WebKit/Source/core/layout/ng/ng_block_layout_algorithm.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_layout_algorithm.h"
 
 #include "core/layout/ng/ng_absolute_utils.h"
 #include "core/layout/ng/ng_block_child_iterator.h"
 #include "core/layout/ng/ng_box_fragment.h"
 #include "core/layout/ng/ng_constraint_space.h"
@@ skipping 59 matching lines @@
   MinMaxContentSize sizes;
 
   // Size-contained elements don't consider their contents for intrinsic sizing.
   if (Style().containsSize())
     return sizes;
 
   // TODO: handle floats & orthogonal children.
   for (NGLayoutInputNode* node = Node()->FirstChild(); node;
        node = node->NextSibling()) {
     MinMaxContentSize child_sizes;
-    if (node->Type() == NGLayoutInputNode::kLegacyInline) {
+    if (node->IsInline()) {
       // From |NGBlockLayoutAlgorithm| perspective, we can handle |NGInlineNode|
       // almost the same as |NGBlockNode|, because an |NGInlineNode| includes
       // all inline nodes following |node| and their descendants, and produces
       // an anonymous box that contains all line boxes.
       // |NextSibling| returns the next block sibling, or nullptr, skipping all
       // following inline siblings and descendants.
-      child_sizes = toNGInlineNode(node)->ComputeMinMaxContentSize();
+      child_sizes = node->ComputeMinMaxContentSize();
     } else {
       Optional<MinMaxContentSize> child_minmax;
-      NGBlockNode* block_child = toNGBlockNode(node);
-      if (NeedMinMaxContentSizeForContentContribution(block_child->Style())) {
-        child_minmax = block_child->ComputeMinMaxContentSize();
+      if (NeedMinMaxContentSizeForContentContribution(node->Style())) {
+        child_minmax = node->ComputeMinMaxContentSize();
       }
 
-      child_sizes = ComputeMinAndMaxContentContribution(block_child->Style(),
-                                                        child_minmax);
+      child_sizes =
+          ComputeMinAndMaxContentContribution(node->Style(), child_minmax);
     }
 
     sizes.min_content = std::max(sizes.min_content, child_sizes.min_content);
     sizes.max_content = std::max(sizes.max_content, child_sizes.max_content);
   }
 
   sizes.max_content = std::max(sizes.min_content, sizes.max_content);
   return sizes;
 }
 
@@ skipping 82 matching lines @@
     DCHECK_EQ(curr_margin_strut_, NGMarginStrut());
     // TODO(glebl): Uncomment the line below once we add the fragmentation
     // support for floats.
     // DCHECK_EQ(builder_.BfcOffset().value(), NGLogicalOffset());
     curr_bfc_offset_ = {};
   }
 
   curr_bfc_offset_.block_offset += content_size_;
 
   while (child) {
-    if (child->Type() == NGLayoutInputNode::kLegacyBlock) {
-      NGBlockNode* current_block_child = toNGBlockNode(child);
-      EPosition position = current_block_child->Style().position();
+    if (child->IsBlock()) {
+      EPosition position = child->Style().position();
       if (position == EPosition::kAbsolute || position == EPosition::kFixed) {
         NGLogicalOffset offset = {border_and_padding_.inline_start,
                                   content_size_ + curr_margin_strut_.Sum()};
-        builder_.AddOutOfFlowChildCandidate(current_block_child, offset);
+        builder_.AddOutOfFlowChildCandidate(toNGBlockNode(child), offset);
         NGBlockChildIterator::Entry entry = child_iterator.NextChild();
         child = entry.node;
         child_break_token = entry.token;
         continue;
       }
     }
 
     PrepareChildLayout(child);
     RefPtr<NGConstraintSpace> child_space =
         CreateConstraintSpaceForChild(child);
@@ skipping 295 matching lines @@
       // started handling the fragmentation for floats.
       space_builder_.SetBfcOffset(NGLogicalOffset());
     }
   }
   space_builder_.SetFragmentainerSpaceAvailable(space_available);
 
   return space_builder_.ToConstraintSpace(
       FromPlatformWritingMode(child_style.getWritingMode()));
 }
 }  // namespace blink