A sizes attribute parser

Source/core/css/MediaValuesCached.cpp

Index: Source/core/css/MediaValuesCached.cpp
diff --git a/Source/core/css/MediaValuesCached.cpp b/Source/core/css/MediaValuesCached.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3e8435134dfe76a71ef42e7d73e602fe003d38ce
--- /dev/null
+++ b/Source/core/css/MediaValuesCached.cpp
@@ -0,0 +1,238 @@
+// Copyright 2014 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 "config.h"
+#include "core/css/MediaValuesCached.h"
+
+#include "core/css/CSSHelper.h"
+#include "core/css/CSSPrimitiveValue.h"
+
+namespace WebCore {
+
+PassRefPtr<MediaValues> MediaValuesCached::create(MediaValuesInitializer& initializer)
+{
+    return adoptRef(new MediaValuesCached(initializer));
+}
+
+PassRefPtr<MediaValues> MediaValuesCached::create(LocalFrame* frame, RenderStyle* style)
+{
+    return adoptRef(new MediaValuesCached(frame, style));
+}
+
+MediaValuesCached::MediaValuesCached(LocalFrame* frame, RenderStyle* style)
+{
+    ASSERT(frame && style);
+    m_viewportWidth = calculateViewportWidth(frame, style);
+    m_viewportHeight = calculateViewportHeight(frame, style);
+    m_deviceWidth = calculateDeviceWidth(frame);
+    m_deviceHeight = calculateDeviceHeight(frame);
+    m_devicePixelRatio = calculateDevicePixelRatio(frame);
+    m_colorBitsPerComponent = calculateColorBitsPerComponent(frame);
+    m_monochromeBitsPerComponent = calculateMonochromeBitsPerComponent(frame);
+    m_pointer = calculateLeastCapablePrimaryPointerDeviceType(frame);
+    m_defaultFontSize = calculateDefaultFontSize(style);
+    m_computedFontSize = calculateComputedFontSize(style);
+    m_hasXHeight = calculateHasXHeight(style);
+    m_xHeight = calculateXHeight(style);
+    m_zeroWidth = calculateZeroWidth(style);
+    m_threeDEnabled = calculateThreeDEnabled(frame);
+    m_scanMediaType = calculateScanMediaType(frame);
+    m_screenMediaType = calculateScreenMediaType(frame);
+    m_printMediaType = calculatePrintMediaType(frame);
+    m_strictMode = calculateStrictMode(frame);
+}
+
+MediaValuesCached::MediaValuesCached(MediaValuesInitializer& initializer)
+    : m_viewportWidth(initializer.viewportWidth)
+    , m_viewportHeight(initializer.viewportHeight)
+    , m_deviceWidth(initializer.deviceWidth)
+    , m_deviceHeight(initializer.deviceHeight)
+    , m_devicePixelRatio(initializer.devicePixelRatio)
+    , m_colorBitsPerComponent(initializer.colorBitsPerComponent)
+    , m_monochromeBitsPerComponent(initializer.monochromeBitsPerComponent)
+    , m_pointer(initializer.pointer)
+    , m_defaultFontSize(initializer.defaultFontSize)
+    , m_computedFontSize(initializer.computedFontSize)
+    , m_hasXHeight(initializer.hasXHeight)
+    , m_xHeight(initializer.xHeight)
+    , m_zeroWidth(initializer.zeroWidth)
+    , m_threeDEnabled(initializer.threeDEnabled)
+    , m_scanMediaType(initializer.scanMediaType)
+    , m_screenMediaType(initializer.screenMediaType)
+    , m_printMediaType(initializer.printMediaType)
+    , m_strictMode(initializer.strictMode)
+{
+}
+
+PassRefPtr<MediaValues> MediaValuesCached::copy() const
+{
+    MediaValuesInitializer initializer;
+    initializer.viewportWidth = m_viewportWidth;
+    initializer.viewportHeight = m_viewportHeight;
+    initializer.deviceWidth = m_deviceWidth;
+    initializer.deviceHeight = m_deviceHeight;
+    initializer.devicePixelRatio = m_devicePixelRatio;
+    initializer.colorBitsPerComponent = m_colorBitsPerComponent;
+    initializer.monochromeBitsPerComponent = m_monochromeBitsPerComponent;
+    initializer.pointer = m_pointer;
+    initializer.defaultFontSize = m_defaultFontSize;
+    initializer.computedFontSize = m_computedFontSize;
+    initializer.hasXHeight = m_hasXHeight;
+    initializer.xHeight = m_xHeight;
+    initializer.zeroWidth = m_zeroWidth;
+    initializer.threeDEnabled = m_threeDEnabled;
+    initializer.scanMediaType = m_scanMediaType;
+    initializer.screenMediaType = m_screenMediaType;
+    initializer.printMediaType = m_printMediaType;
+    initializer.strictMode = m_strictMode;
+
+    return adoptRef(new MediaValuesCached(initializer));
+}
+
+bool MediaValuesCached::computeLength(CSSPrimitiveValue& primitiveValue, int& result) const
+{
+    unsigned short type = primitiveValue.primitiveType();
+    double value = primitiveValue.getDoubleValue();
+
+    // We're running in a background thread, so RenderStyle is not available.
+    // Nevertheless, we can evaluate lengths using cached values.
+    // The logic here is duplicated from CSSPrimitiveValue::computeLengthDouble for performance reasons.

[eseidel, 2014/04/14 23:10:13]

Why?  Can't we share code?  Have them both call a shared function?

+    int factor = 0;
+    switch (type) {
+    case CSSPrimitiveValue::CSS_EMS:
+    case CSSPrimitiveValue::CSS_REMS:
+        factor = m_defaultFontSize;
+        break;
+    case CSSPrimitiveValue::CSS_PX:
+        factor = 1;
+        break;
+    case CSSPrimitiveValue::CSS_EXS:
+        // FIXME: We have a bug right now where the zoom will be applied twice to EX units.
+        // We really need to compute EX using fontMetrics for the original specifiedSize and not use
+        // our actual constructed rendering font.
+        if (m_hasXHeight)
+            factor = m_xHeight;
+        else
+            factor = m_defaultFontSize / 2.0;
+        break;
+    case CSSPrimitiveValue::CSS_CHS:
+        factor = m_zeroWidth;
+        break;
+    case CSSPrimitiveValue::CSS_VW:
+        factor = m_viewportWidth / 100;
+        break;
+    case CSSPrimitiveValue::CSS_VH:
+        factor = m_viewportHeight / 100;
+        break;
+    case CSSPrimitiveValue::CSS_VMIN:
+        factor = std::min(m_viewportWidth, m_viewportHeight) / 100;
+        break;
+    case CSSPrimitiveValue::CSS_VMAX:
+        factor = std::max(m_viewportWidth, m_viewportHeight) / 100;
+        break;
+    case CSSPrimitiveValue::CSS_CM:
+        factor = cssPixelsPerCentimeter;
+        break;
+    case CSSPrimitiveValue::CSS_MM:
+        factor = cssPixelsPerMillimeter;
+        break;
+    case CSSPrimitiveValue::CSS_IN:
+        factor = cssPixelsPerInch;
+        break;
+    case CSSPrimitiveValue::CSS_PT:
+        factor = cssPixelsPerPoint;
+        break;
+    case CSSPrimitiveValue::CSS_PC:
+        factor = cssPixelsPerPica;
+        break;
+    default:
+        return false;
+    }
+
+    ASSERT(factor > 0);
+    result = roundForImpreciseConversion<int>(value*factor);
+    return true;
+}
+
+bool MediaValuesCached::isSafeToSendToAnotherThread() const
+{
+    return hasOneRef();
+}
+
+int MediaValuesCached::viewportWidth() const
+{
+    return m_viewportWidth;
+}
+
+int MediaValuesCached::viewportHeight() const
+{
+    return m_viewportHeight;
+}
+
+int MediaValuesCached::deviceWidth() const
+{
+    return m_deviceWidth;
+}
+
+int MediaValuesCached::deviceHeight() const
+{
+    return m_deviceHeight;
+}
+
+float MediaValuesCached::devicePixelRatio() const
+{
+    return m_devicePixelRatio;
+}
+
+int MediaValuesCached::colorBitsPerComponent() const
+{
+    return m_colorBitsPerComponent;
+}
+
+int MediaValuesCached::monochromeBitsPerComponent() const
+{
+    return m_monochromeBitsPerComponent;
+}
+
+MediaValues::PointerDeviceType MediaValuesCached::pointer() const
+{
+    return m_pointer;
+}
+
+bool MediaValuesCached::threeDEnabled() const
+{
+    return m_threeDEnabled;
+}
+
+bool MediaValuesCached::scanMediaType() const
+{
+    return m_scanMediaType;
+}
+
+bool MediaValuesCached::screenMediaType() const
+{
+    return m_screenMediaType;
+}
+
+bool MediaValuesCached::printMediaType() const
+{
+    return m_printMediaType;
+}
+
+bool MediaValuesCached::strictMode() const
+{
+    return m_strictMode;
+}
+
+Document* MediaValuesCached::document() const
+{
+    return 0;
+}
+
+bool MediaValuesCached::hasValues() const
+{
+    return true;
+}
+
+} // namespace