Remove unsafe DEFINE_STATIC_LOCALs in CSSPrimitiveValue

Source/core/css/CSSPrimitiveValue.cpp

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2012 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,
@@ skipping 18 matching lines @@
 #include "core/css/Counter.h"
 #include "core/css/Pair.h"
 #include "core/css/Rect.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/dom/Node.h"
 #include "core/rendering/style/RenderStyle.h"
 #include "platform/Decimal.h"
 #include "platform/LayoutUnit.h"
 #include "platform/fonts/FontMetrics.h"
 #include "wtf/StdLibExtras.h"
+#include "wtf/ThreadSpecific.h"
+#include "wtf/Threading.h"
 #include "wtf/text/StringBuffer.h"
 #include "wtf/text/StringBuilder.h"
 
 using namespace WTF;
 
 namespace blink {
 
+namespace {
+
 // Max/min values for CSS, needs to slightly smaller/larger than the true max/min values to allow for rounding without overflowing.
 // Subtract two (rather than one) to allow for values to be converted to float and back without exceeding the LayoutUnit::max.
 const int maxValueForCssLength = INT_MAX / kFixedPointDenominator - 2;
 const int minValueForCssLength = INT_MIN / kFixedPointDenominator + 2;
 
 static inline bool isValidCSSUnitTypeForDoubleConversion(CSSPrimitiveValue::UnitType unitType)
 {
     switch (unitType) {
     case CSSPrimitiveValue::CSS_CALC:
     case CSSPrimitiveValue::CSS_CALC_PERCENTAGE_WITH_NUMBER:
@@ skipping 76 matching lines @@
     table.set(String("vh"), CSSPrimitiveValue::CSS_VH);
     table.set(String("vmin"), CSSPrimitiveValue::CSS_VMIN);
     table.set(String("vmax"), CSSPrimitiveValue::CSS_VMAX);
     table.set(String("rem"), CSSPrimitiveValue::CSS_REMS);
     table.set(String("fr"), CSSPrimitiveValue::CSS_FR);
     table.set(String("turn"), CSSPrimitiveValue::CSS_TURN);
     table.set(String("ch"), CSSPrimitiveValue::CSS_CHS);
     return table;
 }
 
+StringToUnitTable& unitTable()
+{
+    DEFINE_STATIC_LOCAL(StringToUnitTable, unitTable, (createStringToUnitTable()));
+    return unitTable;
+}
+
+} // namespace
+
+void CSSPrimitiveValue::initUnitTable()
+{
+    // Make sure we initialize this during blink initialization
+    // to avoid racy static local initialization.
+    unitTable();
+}
+
 CSSPrimitiveValue::UnitType CSSPrimitiveValue::fromName(const String& unit)
 {
-    DEFINE_STATIC_LOCAL(StringToUnitTable, unitTable, (createStringToUnitTable()));
-    return unitTable.get(unit.lower());
+    return unitTable().get(unit.lower());
 }
 
 CSSPrimitiveValue::UnitCategory CSSPrimitiveValue::unitCategory(UnitType type)
 {
     // Here we violate the spec (http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSPrimitiveValue) and allow conversions
     // between CSS_PX and relative lengths (see cssPixelsPerInch comment in core/css/CSSHelper.h for the topic treatment).
     switch (type) {
     case CSS_NUMBER:
         return CSSPrimitiveValue::UNumber;
     case CSS_PERCENTAGE:
@@ skipping 35 matching lines @@
     case CSSValueCurrentcolor:
         return true;
     default:
         return false;
     }
 }
 
 typedef HashMap<const CSSPrimitiveValue*, String> CSSTextCache;
 static CSSTextCache& cssTextCache()
 {
-    DEFINE_STATIC_LOCAL(CSSTextCache, cache, ());
-    return cache;
+    AtomicallyInitializedStaticReference(ThreadSpecific<CSSTextCache>, cache, new ThreadSpecific<CSSTextCache>());

[sof, 2015/12/02 13:32:41]

fwiw, http/tests/misc/client-hints-picture-source-removal.html is a test that
exercises non-main thread use of cssTextCache().

+    return *cache;
 }
 
 CSSPrimitiveValue::UnitType CSSPrimitiveValue::primitiveType() const
 {
     if (m_primitiveUnitType == CSS_PROPERTY_ID || m_primitiveUnitType == CSS_VALUE_ID)
         return CSS_IDENT;
 
     if (m_primitiveUnitType != CSS_CALC)
         return static_cast<UnitType>(m_primitiveUnitType);
 
@@ skipping 1007 matching lines @@
         visitor->trace(m_value.shape);
         break;
     default:
         break;
     }
 #endif
     CSSValue::traceAfterDispatch(visitor);
 }
 
 } // namespace blink