[LayoutNG] Remove derived constraint spaces from opportunity iterator.

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"
 
 #include "core/layout/ng/ng_writing_mode.h"
 
 namespace blink {
 
 NGPhysicalSize NGLogicalSize::ConvertToPhysical(NGWritingMode mode) const {
   return mode == HorizontalTopBottom ? 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);
+}
+
 NGLogicalSize NGPhysicalSize::ConvertToLogical(NGWritingMode mode) const {
   return mode == HorizontalTopBottom ? NGLogicalSize(width, height)
                                      : NGLogicalSize(height, width);
 }
 
+bool NGLogicalRect::IsEmpty() const {
+  return *this == NGLogicalRect();

[Gleb Lanbin, 2016/10/21 21:06:59]

.nit We will need to change that later as it allocates an empty object every
time we need to check NGLogicalRect for emptiness. I think we can either use
static constexpr NGLogicalRect kEmptyNGLogicalRect = NGLogicalRect(); or
std::is_empty if it's supported. Feel free to leave it as is now or add a TODO.

[ikilpatrick, 2016/10/21 21:45:27]

added TODO

+}
+
+bool NGLogicalRect::operator==(const NGLogicalRect& other) const {
+  return std::tie(other.offset, other.size) == std::tie(offset, size);
+}
+
+String NGLogicalRect::ToString() const {
+  return String::format("%s,%s %sx%s",
+                        offset.inline_offset.toString().ascii().data(),
+                        offset.block_offset.toString().ascii().data(),
+                        size.inline_size.toString().ascii().data(),
+                        size.block_size.toString().ascii().data());
+}
+
 NGPhysicalOffset NGLogicalOffset::ConvertToPhysical(
     NGWritingMode mode,
     NGDirection direction,
     NGPhysicalSize container_size,
     NGPhysicalSize inner_size) const {
   switch (mode) {
     case HorizontalTopBottom:
       if (direction == LeftToRight)
         return NGPhysicalOffset(inline_offset, block_offset);
       else
@@ skipping 23 matching lines @@
             block_offset,
             container_size.height - inline_offset - inner_size.height);
       else
         return NGPhysicalOffset(block_offset, inline_offset);
     default:
       ASSERT_NOT_REACHED();
       return NGPhysicalOffset();
   }
 }
 
+bool NGLogicalOffset::operator==(const NGLogicalOffset& other) const {
+  return std::tie(other.inline_offset, other.block_offset) ==
+         std::tie(inline_offset, block_offset);
+}
+
 bool NGBoxStrut::IsEmpty() const {
   return *this == NGBoxStrut();
 }
 
 bool NGBoxStrut::operator==(const NGBoxStrut& other) const {
   return std::tie(other.inline_start, other.inline_end, other.block_start,
                   other.block_end) ==
          std::tie(inline_start, inline_end, block_start, block_end);
 }
 
@@ skipping 48 matching lines @@
 
 bool NGMarginStrut::operator==(const NGMarginStrut& 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);
 }
 
 }  // namespace blink