Deprecate the currently used NGMarginStrut in favor of the new one.

third_party/WebKit/Source/core/layout/ng/ng_units.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_units.h"
 
 namespace blink {
 
 LayoutUnit MinAndMaxContentSizes::ShrinkToFit(LayoutUnit available_size) const {
   DCHECK_GE(max_content, min_content);
   return std::min(max_content, std::max(min_content, available_size));
 }
 
 bool MinAndMaxContentSizes::operator==(
     const MinAndMaxContentSizes& other) const {
   return min_content == other.min_content && max_content == other.max_content;
 }
 
 NGPhysicalSize NGLogicalSize::ConvertToPhysical(NGWritingMode mode) const {
   return mode == kHorizontalTopBottom ? NGPhysicalSize(inline_size, block_size)
                                       : NGPhysicalSize(block_size, inline_size);
 }
 
 bool NGLogicalSize::operator==(const NGLogicalSize& other) const {
   return std::tie(other.inline_size, other.block_size) ==
          std::tie(inline_size, block_size);
 }
 
+bool NGPhysicalSize::operator==(const NGPhysicalSize& other) const {
+  return std::tie(other.width, other.height) == std::tie(width, height);
+}
+
 NGLogicalSize NGPhysicalSize::ConvertToLogical(NGWritingMode mode) const {
   return mode == kHorizontalTopBottom ? NGLogicalSize(width, height)
                                       : NGLogicalSize(height, width);
 }
 
 bool NGLogicalRect::IsEmpty() const {
   // TODO(layout-dev): equality check shouldn't allocate an object each time.
   return *this == NGLogicalRect();
 }
 
@@ skipping 87 matching lines @@
 bool NGLogicalOffset::operator<(const NGLogicalOffset& other) const {
   return inline_offset < other.inline_offset &&
          block_offset < other.block_offset;
 }
 
 bool NGLogicalOffset::operator<=(const NGLogicalOffset& other) const {
   return inline_offset <= other.inline_offset &&
          block_offset <= other.block_offset;
 }
 
+NGLogicalOffset NGLogicalOffset::operator-(const NGLogicalOffset& other) const {
+  return NGLogicalOffset{this->inline_offset - other.inline_offset,
+                         this->block_offset - other.block_offset};
+}
+
+NGLogicalOffset& NGLogicalOffset::operator-=(const NGLogicalOffset& other) {
+  *this = *this - other;
+  return *this;
+}
+
 String NGLogicalOffset::ToString() const {
   return String::format("%dx%d", inline_offset.toInt(), block_offset.toInt());
 }
 
 NGPhysicalOffset NGPhysicalOffset::operator+(
     const NGPhysicalOffset& other) const {
   return NGPhysicalOffset{this->left + other.left, this->top + other.top};
 }
 
 NGPhysicalOffset& NGPhysicalOffset::operator+=(const NGPhysicalOffset& other) {
@@ skipping 39 matching lines @@
       break;
     case kSidewaysLeftRight:
       strut = {bottom, top, left, right};
       break;
   }
   if (direction == TextDirection::kRtl)
     std::swap(strut.inline_start, strut.inline_end);
   return strut;
 }
 
-LayoutUnit NGMarginStrut::BlockEndSum() const {
+LayoutUnit NGDeprecatedMarginStrut::BlockEndSum() const {
   return margin_block_end + negative_margin_block_end;
 }
 
-void NGMarginStrut::AppendMarginBlockStart(const LayoutUnit& value) {
+void NGDeprecatedMarginStrut::AppendMarginBlockStart(const LayoutUnit& value) {
   if (value < 0) {
     negative_margin_block_start =
         -std::max(value.abs(), negative_margin_block_start.abs());
   } else {
     margin_block_start = std::max(value, margin_block_start);
   }
 }
 
-void NGMarginStrut::AppendMarginBlockEnd(const LayoutUnit& value) {
+void NGDeprecatedMarginStrut::AppendMarginBlockEnd(const LayoutUnit& value) {
   if (value < 0) {
     negative_margin_block_end =
         -std::max(value.abs(), negative_margin_block_end.abs());
   } else {
     margin_block_end = std::max(value, margin_block_end);
   }
 }
 
-void NGMarginStrut::SetMarginBlockStart(const LayoutUnit& value) {
+void NGDeprecatedMarginStrut::SetMarginBlockStart(const LayoutUnit& value) {
   if (value < 0) {
     negative_margin_block_start = value;
   } else {
     margin_block_start = value;
   }
 }
 
-void NGMarginStrut::SetMarginBlockEnd(const LayoutUnit& value) {
+void NGDeprecatedMarginStrut::SetMarginBlockEnd(const LayoutUnit& value) {
   if (value < 0) {
     negative_margin_block_end = value;
   } else {
     margin_block_end = value;
   }
 }
 
-String NGMarginStrut::ToString() const {
+String NGDeprecatedMarginStrut::ToString() const {
   return String::format("Start: (%d %d) End: (%d %d)",
                         margin_block_start.toInt(), margin_block_end.toInt(),
                         negative_margin_block_start.toInt(),
                         negative_margin_block_end.toInt());
 }
 
-bool NGMarginStrut::IsEmpty() const {
-  return *this == NGMarginStrut();
+bool NGDeprecatedMarginStrut::IsEmpty() const {
+  return *this == NGDeprecatedMarginStrut();
 }
 
-bool NGMarginStrut::operator==(const NGMarginStrut& other) const {
+bool NGDeprecatedMarginStrut::operator==(
+    const NGDeprecatedMarginStrut& other) const {
   return std::tie(other.margin_block_start, other.margin_block_end,
                   other.negative_margin_block_start,
                   other.negative_margin_block_end) ==
          std::tie(margin_block_start, margin_block_end,
                   negative_margin_block_start, negative_margin_block_end);
 }
 
+void NGMarginStrut::Append(const LayoutUnit& value) {
+  if (value < 0) {
+    negative_margin = std::min(value, negative_margin);
+  } else {
+    margin = std::max(value, margin);
+  }
+}
+
+LayoutUnit NGMarginStrut::Collapse() const {
+  return margin + negative_margin;
+}
+
+String NGMarginStrut::ToString() const {
+  return String::format("%d %d", margin.toInt(), negative_margin.toInt());
+}
+
+bool NGMarginStrut::operator==(const NGMarginStrut& other) const {
+  return std::tie(other.margin, other.negative_margin) ==
+         std::tie(margin, negative_margin);
+}
+
+bool NGExclusion::operator==(const NGExclusion& other) const {
+  return std::tie(other.rect, other.type) == std::tie(rect, type);
+}
+
+String NGExclusion::ToString() const {
+  return String::format("Rect: %s Type: %d", rect.ToString().ascii().data(),
+                        type);
+}
+
 NGExclusions::NGExclusions()
     : last_left_float(nullptr), last_right_float(nullptr) {}
 
 NGExclusions::NGExclusions(const NGExclusions& other) {
   for (const auto& exclusion : other.storage)
     Add(*exclusion);
 }
 
 void NGExclusions::Add(const NGExclusion& exclusion) {
   storage.push_back(WTF::makeUnique<NGExclusion>(exclusion));
@@ skipping 33 matching lines @@
       break;
     case kSidewaysLeftRight:
       position.type =
           (direction == TextDirection::kLtr) ? kBottomLeft : kTopLeft;
       break;
   }
   return position;
 }
 
 }  // namespace blink