Switch override containing block sizes to use LayoutRareData

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. 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
@@ skipping 53 matching lines @@
 #include "platform/geometry/FloatRoundedRect.h"
 #include "wtf/PtrUtil.h"
 #include <algorithm>
 #include <math.h>
 
 namespace blink {
 
 // Used by flexible boxes when flexing this element and by table cells.
 typedef WTF::HashMap<const LayoutBox*, LayoutUnit> OverrideSizeMap;
 
-// Used by grid elements to properly size their grid items.
-// FIXME: Move these into LayoutBoxRareData.
-static OverrideSizeMap* gOverrideContainingBlockLogicalHeightMap = nullptr;
-static OverrideSizeMap* gOverrideContainingBlockLogicalWidthMap = nullptr;
 static OverrideSizeMap* gExtraInlineOffsetMap = nullptr;
 static OverrideSizeMap* gExtraBlockOffsetMap = nullptr;
 
 
 // Size of border belt for autoscroll. When mouse pointer in border belt,
 // autoscroll is started.
 static const int autoscrollBeltSize = 20;
 static const unsigned backgroundObscurationTestMaxDepth = 4;
 
 struct SameSizeAsLayoutBox : public LayoutBoxModelObject {
@@ skipping 1044 matching lines @@
 
 LayoutUnit LayoutBox::overrideLogicalContentHeight() const
 {
     ASSERT(hasOverrideLogicalContentHeight());
     return m_rareData->m_overrideLogicalContentHeight;
 }
 
 // TODO (lajava) Now that we have implemented these functions based on physical direction, we'd rather remove the logical ones.
 LayoutUnit LayoutBox::overrideContainingBlockContentLogicalWidth() const
 {
-    ASSERT(hasOverrideContainingBlockLogicalWidth());
-    return gOverrideContainingBlockLogicalWidthMap->get(this);
+    DCHECK(hasOverrideContainingBlockLogicalWidth());
+    return m_rareData->m_overrideContainingBlockContentLogicalWidth;
 }
 
 // TODO (lajava) Shouldn't we implement these functions based on physical direction ?.
 LayoutUnit LayoutBox::overrideContainingBlockContentLogicalHeight() const
 {
-    ASSERT(hasOverrideContainingBlockLogicalHeight());
-    return gOverrideContainingBlockLogicalHeightMap->get(this);
+    DCHECK(hasOverrideContainingBlockLogicalHeight());
+    return m_rareData->m_overrideContainingBlockContentLogicalHeight;
 }
 
 // TODO (lajava) Shouldn't we implement these functions based on physical direction ?.
 bool LayoutBox::hasOverrideContainingBlockLogicalWidth() const
 {
-    return gOverrideContainingBlockLogicalWidthMap && gOverrideContainingBlockLogicalWidthMap->contains(this);
+    return m_rareData && m_rareData->m_overrideContainingBlockContentLogicalWidth != LayoutUnit(-2);
 }
 
 // TODO (lajava) Shouldn't we implement these functions based on physical direction ?.
 bool LayoutBox::hasOverrideContainingBlockLogicalHeight() const
 {
-    return gOverrideContainingBlockLogicalHeightMap && gOverrideContainingBlockLogicalHeightMap->contains(this);
+    return m_rareData && m_rareData->m_overrideContainingBlockContentLogicalHeight != LayoutUnit(-2);

[jfernandez, 2016/08/22 14:56:03]

thinking about this ... is this "-2" value intended to avoid the double access
to the hashmat due to the "contains" and "get and compare" with "-1" ?

 }
 
 // TODO (lajava) Shouldn't we implement these functions based on physical direction ?.
 void LayoutBox::setOverrideContainingBlockContentLogicalWidth(LayoutUnit logicalWidth)
 {
-    if (!gOverrideContainingBlockLogicalWidthMap)
-        gOverrideContainingBlockLogicalWidthMap = new OverrideSizeMap;
-    gOverrideContainingBlockLogicalWidthMap->set(this, logicalWidth);
+    DCHECK_NE(logicalWidth, LayoutUnit(-2));
+    ensureRareData().m_overrideContainingBlockContentLogicalWidth = logicalWidth;
 }
 
 // TODO (lajava) Shouldn't we implement these functions based on physical direction ?.
 void LayoutBox::setOverrideContainingBlockContentLogicalHeight(LayoutUnit logicalHeight)
 {
-    if (!gOverrideContainingBlockLogicalHeightMap)
-        gOverrideContainingBlockLogicalHeightMap = new OverrideSizeMap;
-    gOverrideContainingBlockLogicalHeightMap->set(this, logicalHeight);
+    DCHECK_NE(logicalHeight, LayoutUnit(-2));
+    ensureRareData().m_overrideContainingBlockContentLogicalHeight = logicalHeight;
 }
 
 // TODO (lajava) Shouldn't we implement these functions based on physical direction ?.
 void LayoutBox::clearContainingBlockOverrideSize()
 {
-    if (gOverrideContainingBlockLogicalWidthMap)
-        gOverrideContainingBlockLogicalWidthMap->remove(this);
-    clearOverrideContainingBlockContentLogicalHeight();
+    ensureRareData().m_overrideContainingBlockContentLogicalWidth = LayoutUnit(-2);
+    ensureRareData().m_overrideContainingBlockContentLogicalHeight = LayoutUnit(-2);
 }
 
 // TODO (lajava) Shouldn't we implement these functions based on physical direction ?.
 void LayoutBox::clearOverrideContainingBlockContentLogicalHeight()
 {
-    if (gOverrideContainingBlockLogicalHeightMap)
-        gOverrideContainingBlockLogicalHeightMap->remove(this);
+    ensureRareData().m_overrideContainingBlockContentLogicalHeight = LayoutUnit(-2);
 }
 
 LayoutUnit LayoutBox::extraInlineOffset() const
 {
     return gExtraInlineOffsetMap ? gExtraInlineOffsetMap->get(this) : LayoutUnit();
 }
 
 LayoutUnit LayoutBox::extraBlockOffset() const
 {
     return gExtraBlockOffsetMap ? gExtraBlockOffsetMap->get(this) : LayoutUnit();
@@ skipping 3627 matching lines @@
         m_rareData->m_snapAreas->remove(&snapArea);
     }
 }
 
 SnapAreaSet* LayoutBox::snapAreas() const
 {
     return m_rareData ? m_rareData->m_snapAreas.get() : nullptr;
 }
 
 } // namespace blink