Experiment: Switch to code-driven conversion of CSS unit type names.

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 33 matching lines @@
 
 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;
 
-typedef HashMap<String, CSSPrimitiveValue::UnitType> StringToUnitTable;
-
-StringToUnitTable createStringToUnitTable()
-{
-    StringToUnitTable table;
-    table.set(String("em"), CSSPrimitiveValue::UnitType::Ems);
-    table.set(String("ex"), CSSPrimitiveValue::UnitType::Exs);
-    table.set(String("px"), CSSPrimitiveValue::UnitType::Pixels);
-    table.set(String("cm"), CSSPrimitiveValue::UnitType::Centimeters);
-    table.set(String("mm"), CSSPrimitiveValue::UnitType::Millimeters);
-    table.set(String("in"), CSSPrimitiveValue::UnitType::Inches);
-    table.set(String("pt"), CSSPrimitiveValue::UnitType::Points);
-    table.set(String("pc"), CSSPrimitiveValue::UnitType::Picas);
-    table.set(String("deg"), CSSPrimitiveValue::UnitType::Degrees);
-    table.set(String("rad"), CSSPrimitiveValue::UnitType::Radians);
-    table.set(String("grad"), CSSPrimitiveValue::UnitType::Gradians);
-    table.set(String("ms"), CSSPrimitiveValue::UnitType::Milliseconds);
-    table.set(String("s"), CSSPrimitiveValue::UnitType::Seconds);
-    table.set(String("hz"), CSSPrimitiveValue::UnitType::Hertz);
-    table.set(String("khz"), CSSPrimitiveValue::UnitType::Kilohertz);
-    table.set(String("dpi"), CSSPrimitiveValue::UnitType::DotsPerInch);
-    table.set(String("dpcm"), CSSPrimitiveValue::UnitType::DotsPerCentimeter);
-    table.set(String("dppx"), CSSPrimitiveValue::UnitType::DotsPerPixel);
-    table.set(String("vw"), CSSPrimitiveValue::UnitType::ViewportWidth);
-    table.set(String("vh"), CSSPrimitiveValue::UnitType::ViewportHeight);
-    table.set(String("vmin"), CSSPrimitiveValue::UnitType::ViewportMin);
-    table.set(String("vmax"), CSSPrimitiveValue::UnitType::ViewportMax);
-    table.set(String("rem"), CSSPrimitiveValue::UnitType::Rems);
-    table.set(String("fr"), CSSPrimitiveValue::UnitType::Fraction);
-    table.set(String("turn"), CSSPrimitiveValue::UnitType::Turns);
-    table.set(String("ch"), CSSPrimitiveValue::UnitType::Chs);
-    table.set(String("__qem"), CSSPrimitiveValue::UnitType::QuirkyEms);
-    return table;
-}
-
-StringToUnitTable& unitTable()
-{
-    DEFINE_STATIC_LOCAL(StringToUnitTable, unitTable, (createStringToUnitTable()));
-    return unitTable;
-}
-
 } // namespace
 
 float CSSPrimitiveValue::clampToCSSLengthRange(double value)
 {
     return clampTo<float>(value, minValueForCssLength, maxValueForCssLength);
 }
 
-void CSSPrimitiveValue::initUnitTable()
+// Intentionally avoid keeping a hashed map of short strings here, it requiring temporary
+// strings to be constructed and hashed per lookup. Instead, use code-driven lookup of
+// unit type values from their short names.
+
+CSSPrimitiveValue::UnitType CSSPrimitiveValue::fromName(const UChar* unit, unsigned length)
 {
-    // Make sure we initialize this during blink initialization
-    // to avoid racy static local initialization.
-    unitTable();
+    if (!length || length > 5)
+        return CSSPrimitiveValue::UnitType::Unknown;
+
+    LChar buffer[5];
+    for (unsigned i = 0; i < length; ++i) {
+        if (!isASCII(unit[i]))
+            return CSSPrimitiveValue::UnitType::Unknown;
+        buffer[i] = static_cast<LChar>(unit[i]);
+    }
+    return fromName(buffer, length);
 }
 
-CSSPrimitiveValue::UnitType CSSPrimitiveValue::fromName(const String& unit)
+#define UNIT_MATCH_(index, ch, value) if (length == index + 1 && isASCIIAlphaCaselessEqual(unit[index], ch)) return value
+#define UNIT_MATCH2_(index, ch1, ch2, value) if (length == index + 2 && isASCIIAlphaCaselessEqual(unit[index], ch1) && isASCIIAlphaCaselessEqual(unit[index + 1], ch2)) return value
+#define UNIT_MATCH3_(index, ch1, ch2, ch3, value) if (length == index + 3 && isASCIIAlphaCaselessEqual(unit[index], ch1) && isASCIIAlphaCaselessEqual(unit[index + 1], ch2) && isASCIIAlphaCaselessEqual(unit[index + 2], ch3)) return value
+
+CSSPrimitiveValue::UnitType CSSPrimitiveValue::fromName(const LChar* unit, unsigned length)
 {
-    return unitTable().get(unit.lower());
+    if (!length || length > 5)
+        return UnitType::Unknown;
+
+    switch (toASCIILower(unit[0])) {
+    case '_':
+        if (length == 5 && unit[1] == '_')
+            UNIT_MATCH3_(2, 'q', 'e', 'm', UnitType::QuirkyEms);
+        return UnitType::Unknown;
+    case 'c':
+        UNIT_MATCH_(1, 'h', UnitType::Chs);
+        UNIT_MATCH_(1, 'm', UnitType::Centimeters);
+        return UnitType::Unknown;
+    case 'd':
+        UNIT_MATCH2_(1, 'e', 'g', UnitType::Degrees);
+        UNIT_MATCH2_(1, 'p', 'i', UnitType::DotsPerInch);
+        UNIT_MATCH3_(1, 'p', 'c', 'm', UnitType::DotsPerCentimeter);
+        UNIT_MATCH3_(1, 'p', 'p', 'x', UnitType::DotsPerPixel);
+        return UnitType::Unknown;
+    case 'e':
+        UNIT_MATCH_(1, 'm', UnitType::Ems);
+        UNIT_MATCH_(1, 'x', UnitType::Exs);
+        return UnitType::Unknown;
+    case 'f':
+        UNIT_MATCH_(1, 'r', UnitType::Fraction);
+        return UnitType::Unknown;
+    case 'g':
+        UNIT_MATCH3_(1, 'r', 'a', 'd', UnitType::Gradians);
+        return UnitType::Unknown;
+    case 'h':
+        UNIT_MATCH_(1, 'z', UnitType::Hertz);
+        return UnitType::Unknown;
+    case 'i':
+        UNIT_MATCH_(1, 'n', UnitType::Inches);
+        return UnitType::Unknown;
+    case 'k':
+        UNIT_MATCH2_(1, 'h', 'z', UnitType::Kilohertz);
+        return UnitType::Unknown;
+    case 'm':
+        UNIT_MATCH_(1, 'm', UnitType::Millimeters);
+        UNIT_MATCH_(1, 's', UnitType::Milliseconds);
+        return UnitType::Unknown;
+    case 'p':
+        UNIT_MATCH_(1, 'c', UnitType::Picas);
+        UNIT_MATCH_(1, 't', UnitType::Points);
+        UNIT_MATCH_(1, 'x', UnitType::Pixels);
+        return UnitType::Unknown;
+    case 'r':
+        UNIT_MATCH2_(1, 'a', 'd', UnitType::Radians);
+        UNIT_MATCH2_(1, 'e', 'm', UnitType::Rems);
+        return UnitType::Unknown;
+    case 's':
+        return UnitType::Seconds;
+    case 't':
+        UNIT_MATCH3_(1, 'u', 'r', 'n', UnitType::Turns);
+        return UnitType::Unknown;
+    case 'v':
+        UNIT_MATCH_(1, 'h', UnitType::ViewportHeight);
+        UNIT_MATCH_(1, 'w', UnitType::ViewportWidth);
+        UNIT_MATCH3_(1, 'm', 'a', 'x', UnitType::ViewportMax);
+        UNIT_MATCH3_(1, 'm', 'i', 'n', UnitType::ViewportMin);
+        return UnitType::Unknown;
+    default:
+        return UnitType::Unknown;
+    }
 }
 
+#undef UNIT_MATCH_
+#undef UNIT_MATCH2_
+#undef UNIT_MATCH3_
+
 CSSPrimitiveValue::UnitCategory CSSPrimitiveValue::unitCategory(UnitType type)
 {
     switch (type) {
     case UnitType::Number:
         return CSSPrimitiveValue::UNumber;
     case UnitType::Percentage:
         return CSSPrimitiveValue::UPercent;
     case UnitType::Pixels:
     case UnitType::Centimeters:
     case UnitType::Millimeters:
@@ skipping 1029 matching lines @@
         visitor->trace(m_value.shape);
         break;
     default:
         break;
     }
 #endif
     CSSValue::traceAfterDispatch(visitor);
 }
 
 } // namespace blink