WIP: redirect some LayoutBox methods to ng fragments

third_party/WebKit/Source/core/layout/LayoutBox.h

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2006, 2007 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #ifndef LayoutBox_h
 #define LayoutBox_h
 
 #include "core/CoreExport.h"
+#include "core/layout/ng/ng_physical_box_fragment.h"
 #include "core/layout/LayoutBoxModelObject.h"
 #include "core/layout/OverflowModel.h"
 #include "platform/scroll/ScrollTypes.h"
 #include "wtf/Compiler.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 namespace blink {
 
 class LayoutBlockFlow;
@@ skipping 170 matching lines @@
   bool backgroundIsKnownToBeOpaqueInRect(
       const LayoutRect& localRect) const override;
 
   virtual bool backgroundShouldAlwaysBeClipped() const { return false; }
 
   // Use this with caution! No type checking is done!
   LayoutBox* firstChildBox() const;
   LayoutBox* firstInFlowChildBox() const;
   LayoutBox* lastChildBox() const;
 
-  int pixelSnappedWidth() const { return m_frameRect.pixelSnappedWidth(); }
-  int pixelSnappedHeight() const { return m_frameRect.pixelSnappedHeight(); }
+  int pixelSnappedWidth() const {
+    return m_ngPhysicalBoxFragment->pixelSnappedWidth();
+  }
+  int pixelSnappedHeight() const {
+    return m_ngPhysicalBoxFragment->pixelSnappedHeight();
+  }
 
   void setX(LayoutUnit x) {
-    if (x == m_frameRect.x())
+    if (x == m_ngPhysicalBoxFragment->x())
       return;
-    m_frameRect.setX(x);
+    m_ngPhysicalBoxFragment->setX(x);
     locationChanged();
   }
   void setY(LayoutUnit y) {
-    if (y == m_frameRect.y())
+    if (y == m_ngPhysicalBoxFragment->y())
       return;
-    m_frameRect.setY(y);
+    m_ngPhysicalBoxFragment->setY(y);
     locationChanged();
   }
   void setWidth(LayoutUnit width) {
-    if (width == m_frameRect.width())
+    if (width == m_ngPhysicalBoxFragment->Width())
       return;
-    m_frameRect.setWidth(width);
+    m_ngPhysicalBoxFragment->setWidth(width);
     sizeChanged();
   }
   void setHeight(LayoutUnit height) {
-    if (height == m_frameRect.height())
+    if (height == m_ngPhysicalBoxFragment->Height())
       return;
-    m_frameRect.setHeight(height);
+    m_ngPhysicalBoxFragment->setHeight(height);
     sizeChanged();
   }
 
   LayoutUnit logicalLeft() const {
-    return style()->isHorizontalWritingMode() ? m_frameRect.x()
-                                              : m_frameRect.y();
+    return style()->isHorizontalWritingMode() ? m_ngPhysicalBoxFragment->x()
+                                              : m_ngPhysicalBoxFragment->y();
   }
   LayoutUnit logicalRight() const { return logicalLeft() + logicalWidth(); }
   LayoutUnit logicalTop() const {
-    return style()->isHorizontalWritingMode() ? m_frameRect.y()
-                                              : m_frameRect.x();
+    return style()->isHorizontalWritingMode() ? m_ngPhysicalBoxFragment->y()
+                                              : m_ngPhysicalBoxFragment->x();
   }
   LayoutUnit logicalBottom() const { return logicalTop() + logicalHeight(); }
   LayoutUnit logicalWidth() const {
-    return style()->isHorizontalWritingMode() ? m_frameRect.width()
-                                              : m_frameRect.height();
+    return style()->isHorizontalWritingMode()
+               ? m_ngPhysicalBoxFragment->Width()
+               : m_ngPhysicalBoxFragment->Height();
   }
   LayoutUnit logicalHeight() const {
-    return style()->isHorizontalWritingMode() ? m_frameRect.height()
-                                              : m_frameRect.width();
+    return style()->isHorizontalWritingMode()
+               ? m_ngPhysicalBoxFragment->Height()
+               : m_ngPhysicalBoxFragment->Width();
   }
 
   // Logical height of the object, including content overflowing the
   // border-after edge.
   virtual LayoutUnit logicalHeightWithVisibleOverflow() const;
 
   LayoutUnit constrainLogicalWidthByMinMax(LayoutUnit,
                                            LayoutUnit,
                                            LayoutBlock*) const;
   LayoutUnit constrainLogicalHeightByMinMax(
@@ skipping 43 matching lines @@
     else
       setHeight(size);
   }
   void setLogicalHeight(LayoutUnit size) {
     if (style()->isHorizontalWritingMode())
       setHeight(size);
     else
       setWidth(size);
   }
 
-  LayoutPoint location() const { return m_frameRect.location(); }
+  LayoutPoint location() const {
+    return m_ngPhysicalBoxFragment->Location();
+  }
+
   LayoutSize locationOffset() const {
-    return LayoutSize(m_frameRect.x(), m_frameRect.y());
+    return LayoutSize(m_ngPhysicalBoxFragment->x(),
+                      m_ngPhysicalBoxFragment->y());
   }
-  LayoutSize size() const { return m_frameRect.size(); }
-  IntSize pixelSnappedSize() const { return m_frameRect.pixelSnappedSize(); }
+  LayoutSize size() const {
+    return m_ngPhysicalBoxFragment->LegacySize();
+  }
+  IntSize pixelSnappedSize() const {
+    return m_ngPhysicalBoxFragment->pixelSnappedSize();
+  }
 
   void setLocation(const LayoutPoint& location) {
-    if (location == m_frameRect.location())
+    if (location == m_ngPhysicalBoxFragment->Location())
       return;
-    m_frameRect.setLocation(location);
+    m_ngPhysicalBoxFragment->setLocation(location);
     locationChanged();
   }
 
   // The ancestor box that this object's location and physicalLocation are
   // relative to.
   virtual LayoutBox* locationContainer() const;
 
   // FIXME: Currently scrollbars are using int geometry and positioned based on
   // pixelSnappedBorderBoxRect whose size may change when location changes
   // because of pixel snapping. This function is used to change location of the
   // LayoutBox outside of LayoutBox::layout(). Will remove when we use
   // LayoutUnits for scrollbars.
   void setLocationAndUpdateOverflowControlsIfNeeded(const LayoutPoint&);
 
   void setSize(const LayoutSize& size) {
-    if (size == m_frameRect.size())
+    if (size == m_ngPhysicalBoxFragment->LegacySize())
       return;
-    m_frameRect.setSize(size);
+    m_ngPhysicalBoxFragment->setSize(size);
     sizeChanged();
   }
   void move(LayoutUnit dx, LayoutUnit dy) {
     if (!dx && !dy)
       return;
-    m_frameRect.move(dx, dy);
+    m_ngPhysicalBoxFragment->move(dx, dy);
     locationChanged();
   }
 
   // This function is in the container's coordinate system, meaning
   // that it includes the logical top/left offset and the
   // inline-start/block-start margins.
-  LayoutRect frameRect() const { return m_frameRect; }
+  LayoutRect frameRect() const {
+    return m_ngPhysicalBoxFragment->getLayoutRect();
+  }
   void setFrameRect(const LayoutRect& rect) {
     setLocation(rect.location());
     setSize(rect.size());
   }
 
   // Note that those functions have their origin at this box's CSS border box.
   // As such their location doesn't account for 'top'/'left'.
   LayoutRect borderBoxRect() const { return LayoutRect(LayoutPoint(), size()); }
   LayoutRect paddingBoxRect() const {
     return LayoutRect(borderLeft(), borderTop(), clientWidth(), clientHeight());
   }
   IntRect pixelSnappedBorderBoxRect() const {
-    return IntRect(IntPoint(), m_frameRect.pixelSnappedSize());
+    return IntRect(IntPoint(), m_ngPhysicalBoxFragment->pixelSnappedSize());
   }
   IntRect borderBoundingBox() const final {
     return pixelSnappedBorderBoxRect();
   }
 
   // The content area of the box (excludes padding - and intrinsic padding for
   // table cells, etc... - and border).
   DISABLE_CFI_PERF LayoutRect contentBoxRect() const {
     return LayoutRect(borderLeft() + paddingLeft(), borderTop() + paddingTop(),
                       contentWidth(), contentHeight());
@@ skipping 136 matching lines @@
                                               : contentHeight();
   }
   LayoutUnit contentLogicalHeight() const {
     return style()->isHorizontalWritingMode() ? contentHeight()
                                               : contentWidth();
   }
 
   // IE extensions. Used to calculate offsetWidth/Height. Overridden by inlines
   // (LayoutFlow) to return the remaining width on a given line (and the height
   // of a single line).
-  LayoutUnit offsetWidth() const override { return m_frameRect.width(); }
-  LayoutUnit offsetHeight() const override { return m_frameRect.height(); }
+  LayoutUnit offsetWidth() const override {
+    return m_ngPhysicalBoxFragment->Width();
+  }
+  LayoutUnit offsetHeight() const override {
+    return m_ngPhysicalBoxFragment->Height();
+  }
 
   int pixelSnappedOffsetWidth(const Element*) const final;
   int pixelSnappedOffsetHeight(const Element*) const final;
 
   // More IE extensions.  clientWidth and clientHeight represent the interior of
   // an object excluding border and scrollbar. clientLeft/Top are just the
   // borderLeftWidth and borderTopWidth.
   DISABLE_CFI_PERF LayoutUnit clientLeft() const {
     return LayoutUnit(borderLeft() +
                       (shouldPlaceBlockDirectionScrollbarOnLogicalLeft()
@@ skipping 624 matching lines @@
     // for vertical writing modes).
     if (!UNLIKELY(hasFlippedBlocksWritingMode()))
       return position;
     return logicalHeight() - position;
   }
   WARN_UNUSED_RESULT LayoutPoint
   flipForWritingMode(const LayoutPoint& position) const {
     if (!UNLIKELY(hasFlippedBlocksWritingMode()))
       return position;
     return isHorizontalWritingMode()
-               ? LayoutPoint(position.x(), m_frameRect.height() - position.y())
-               : LayoutPoint(m_frameRect.width() - position.x(), position.y());
+               ? LayoutPoint(position.x(),
+                             m_ngPhysicalBoxFragment->Height() - position.y())
+               : LayoutPoint(m_ngPhysicalBoxFragment->Width() - position.x(),
+                             position.y());
   }
   WARN_UNUSED_RESULT LayoutSize
   flipForWritingMode(const LayoutSize& offset) const {
     if (!UNLIKELY(hasFlippedBlocksWritingMode()))
       return offset;
-    return LayoutSize(m_frameRect.width() - offset.width(), offset.height());
+    return LayoutSize(m_ngPhysicalBoxFragment->Width() - offset.width(),
+                      offset.height());
   }
   void flipForWritingMode(LayoutRect& rect) const {
     if (!UNLIKELY(hasFlippedBlocksWritingMode()))
       return;
-    rect.setX(m_frameRect.width() - rect.maxX());
+    rect.setX(m_ngPhysicalBoxFragment->Width() - rect.maxX());
   }
   WARN_UNUSED_RESULT FloatPoint
   flipForWritingMode(const FloatPoint& position) const {
     if (!UNLIKELY(hasFlippedBlocksWritingMode()))
       return position;
-    return FloatPoint(m_frameRect.width() - position.x(), position.y());
+    return FloatPoint(m_ngPhysicalBoxFragment->Width() - position.x(),
+                      position.y());
   }
   void flipForWritingMode(FloatRect& rect) const {
     if (!UNLIKELY(hasFlippedBlocksWritingMode()))
       return;
-    rect.setX(m_frameRect.width() - rect.maxX());
+    rect.setX(m_ngPhysicalBoxFragment->Width() - rect.maxX());
   }
 
   // Passing |container| causes flipped-block flipping w.r.t. that container,
   // or containingBlock() otherwise.
   LayoutPoint physicalLocation(
       const LayoutBox* flippedBlocksContainer = nullptr) const;
   LayoutSize physicalLocationOffset() const {
     return toLayoutSize(physicalLocation());
   }
 
@@ skipping 366 matching lines @@
   LayoutRect debugRect() const override;
 
   // The CSS border box rect for this box.
   //
   // The rectangle is in this box's physical coordinates but with a
   // flipped block-flow direction (see the COORDINATE SYSTEMS section
   // in LayoutBoxModelObject). The location is the distance from this
   // object's border edge to the container's border edge (which is not
   // always the parent). Thus it includes any logical top/left along
   // with this box's margins.
-  LayoutRect m_frameRect;
+  RefPtr<NGPhysicalBoxFragment> m_ngPhysicalBoxFragment;
 
   // Previous size of m_frameRect, updated after paint invalidation.
   LayoutSize m_previousSize;
 
   // Our intrinsic height, used for min-height: min-content etc. Maintained by
   // updateLogicalHeight. This is logicalHeight() before it is clamped to
   // min/max.
   mutable LayoutUnit m_intrinsicContentLogicalHeight;
 
  protected:
@@ skipping 95 matching lines @@
          breakValue == EBreakBetween::kLeft ||
          breakValue == EBreakBetween::kPage ||
          breakValue == EBreakBetween::kRecto ||
          breakValue == EBreakBetween::kRight ||
          breakValue == EBreakBetween::kVerso;
 }
 
 }  // namespace blink
 
 #endif  // LayoutBox_h