[LayoutNG] Make NGBlockNode return a const style reference.

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 98 matching lines @@
                         borderAndPadding;
     sizes.max_content = layout_box_->computeLogicalWidthUsing(
                             MainOrPreferredSize, Length(MaxContent),
                             LayoutUnit(), layout_box_->containingBlock()) -
                         borderAndPadding;
     return sizes;
   }
 
   NGConstraintSpace* constraint_space =
       NGConstraintSpaceBuilder(
-          FromPlatformWritingMode(Style()->getWritingMode()))
-          .SetTextDirection(Style()->direction())
+          FromPlatformWritingMode(Style().getWritingMode()))
+          .SetTextDirection(Style().direction())
           .ToConstraintSpace();
 
   // TODO(cbiesinger): For orthogonal children, we need to always synthesize.
   // TODO(kojii): Add other algorithms when they support
   // ComputeMinAndMaxContentSizes.
   NGLayoutInputNode* first_child = FirstChild();
   if (!first_child || first_child->Type() == kLegacyBlock) {
     NGBlockLayoutAlgorithm minmax_algorithm(
-        layout_box_, Style(), toNGBlockNode(FirstChild()), constraint_space);
+        layout_box_, &Style(), toNGBlockNode(FirstChild()), constraint_space);
     if (minmax_algorithm.ComputeMinAndMaxContentSizes(&sizes))
       return sizes;
   }
 
   // Have to synthesize this value.
   NGPhysicalFragment* physical_fragment = Layout(constraint_space);
   NGBoxFragment* fragment = new NGBoxFragment(
-      FromPlatformWritingMode(Style()->getWritingMode()), Style()->direction(),
+      FromPlatformWritingMode(Style().getWritingMode()), Style().direction(),
       toNGPhysicalBoxFragment(physical_fragment));
 
   sizes.min_content = fragment->InlineOverflow();
 
   // Now, redo with infinite space for max_content
   constraint_space =
       NGConstraintSpaceBuilder(
-          FromPlatformWritingMode(Style()->getWritingMode()))
-          .SetTextDirection(Style()->direction())
+          FromPlatformWritingMode(Style().getWritingMode()))
+          .SetTextDirection(Style().direction())
           .SetAvailableSize({LayoutUnit::max(), LayoutUnit()})
           .SetPercentageResolutionSize({LayoutUnit(), LayoutUnit()})
           .ToConstraintSpace();
 
   physical_fragment = Layout(constraint_space);
   fragment = new NGBoxFragment(
-      FromPlatformWritingMode(Style()->getWritingMode()), Style()->direction(),
+      FromPlatformWritingMode(Style().getWritingMode()), Style().direction(),
       toNGPhysicalBoxFragment(physical_fragment));
   sizes.max_content = fragment->InlineOverflow();
   return sizes;
 }
 
-ComputedStyle* NGBlockNode::MutableStyle() {
+const ComputedStyle& NGBlockNode::Style() const {
   if (style_)
-    return style_.get();
+    return *style_.get();
   DCHECK(layout_box_);
-  return layout_box_->mutableStyle();
-}
-
-const ComputedStyle* NGBlockNode::Style() const {
-  if (style_)
-    return style_.get();
-  DCHECK(layout_box_);
-  return layout_box_->style();
+  return layout_box_->styleRef();
 }
 
 NGBlockNode* NGBlockNode::NextSibling() {
   if (!next_sibling_) {
     LayoutObject* next_sibling =
         layout_box_ ? layout_box_->nextSibling() : nullptr;
     NGBlockNode* box = next_sibling ? new NGBlockNode(next_sibling) : nullptr;
     SetNextSibling(box);
   }
   return next_sibling_;
 }
 
 LayoutObject* NGBlockNode::GetLayoutObject() {
   return layout_box_;
 }
 
 NGLayoutInputNode* NGBlockNode::FirstChild() {
   if (!first_child_) {
     LayoutObject* child = layout_box_ ? layout_box_->slowFirstChild() : nullptr;
     if (child) {
       if (child->isInline()) {
-        SetFirstChild(new NGInlineNode(child, MutableStyle()));
+        SetFirstChild(new NGInlineNode(child, &Style()));
       } else {
         SetFirstChild(new NGBlockNode(child));
       }
     }
   }
   return first_child_;
 }
 
 void NGBlockNode::SetNextSibling(NGBlockNode* sibling) {
   next_sibling_ = sibling;
@@ skipping 42 matching lines @@
 
 void NGBlockNode::CopyFragmentDataToLayoutBox(
     const NGConstraintSpace& constraint_space) {
   // We may not have a layout_box_ during unit tests.
   if (!layout_box_)
     return;
 
   layout_box_->setWidth(fragment_->Width());
   layout_box_->setHeight(fragment_->Height());
   NGBoxStrut border_and_padding =
-      ComputeBorders(*Style()) + ComputePadding(constraint_space, *Style());
+      ComputeBorders(Style()) + ComputePadding(constraint_space, Style());
   LayoutUnit intrinsic_logical_height =
       layout_box_->style()->isHorizontalWritingMode()
           ? fragment_->HeightOverflow()
           : fragment_->WidthOverflow();
   intrinsic_logical_height -= border_and_padding.BlockSum();
   layout_box_->setIntrinsicContentLogicalHeight(intrinsic_logical_height);
 
   // TODO(layout-dev): Currently we are not actually performing layout on
   // inline children. For now just clear the needsLayout bit so that we can
   // run unittests.
@@ skipping 73 matching lines @@
 // 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