Revert "A sizes attribute parser" (https://codereview.chromium.org/224733011)

Source/core/css/MediaQueryEvaluator.cpp

 /*
  * CSS Media Query Evaluator
  *
  * Copyright (C) 2006 Kimmo Kinnunen <kimmo.t.kinnunen@nokia.com>.
  * Copyright (C) 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Intel Corporation. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
@@ skipping 22 matching lines @@
 #include "CSSValueKeywords.h"
 #include "MediaFeatureNames.h"
 #include "MediaFeatures.h"
 #include "MediaTypeNames.h"
 #include "core/css/CSSAspectRatioValue.h"
 #include "core/css/CSSHelper.h"
 #include "core/css/CSSPrimitiveValue.h"
 #include "core/css/CSSToLengthConversionData.h"
 #include "core/css/MediaList.h"
 #include "core/css/MediaQuery.h"
-#include "core/css/MediaValuesDynamic.h"
+#include "core/css/MediaValues.h"
 #include "core/css/resolver/MediaQueryResult.h"
 #include "core/dom/NodeRenderStyle.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/compositing/RenderLayerCompositor.h"
 #include "core/rendering/style/RenderStyle.h"
@@ skipping 24 matching lines @@
 
 MediaQueryEvaluator::MediaQueryEvaluator(const char* acceptedMediaType, bool mediaFeatureResult)
     : m_mediaType(acceptedMediaType)
     , m_expectedResult(mediaFeatureResult)
 {
 }
 
 MediaQueryEvaluator::MediaQueryEvaluator(const String& acceptedMediaType, LocalFrame* frame, RenderStyle* style)
     : m_mediaType(acceptedMediaType)
     , m_expectedResult(false) // Doesn't matter when we have m_frame and m_style.
-    , m_mediaValues(MediaValuesDynamic::create(frame, style))
+    , m_mediaValues(MediaValues::create(frame, style, MediaValues::DynamicMode))
 {
 }
 
 MediaQueryEvaluator::MediaQueryEvaluator(const String& acceptedMediaType, const MediaValues& mediaValues)
     : m_mediaType(acceptedMediaType)
     , m_expectedResult(false) // Doesn't matter when we have mediaValues.
     , m_mediaValues(mediaValues.copy())
 {
 }
 
@@ skipping 225 matching lines @@
 static bool gridMediaFeatureEval(CSSValue* value, MediaFeaturePrefix op, const MediaValues&)
 {
     // if output device is bitmap, grid: 0 == true
     // assume we have bitmap device
     float number;
     if (value && numberValue(value, number))
         return compareValue(static_cast<int>(number), 0, op);
     return false;
 }
 
-static bool computeLength(CSSValue* value, const MediaValues& mediaValues, int& result)
+static bool computeLengthWithoutStyle(CSSPrimitiveValue* primitiveValue, int defaultFontSize, int& result)
+{
+    // We're running in a background thread, so RenderStyle is not available.
+    // Nevertheless, we can evaluate length MQs with em, rem or px units.
+    // FIXME: Learn to support more units here, or teach CSSPrimitiveValue about MediaValues.
+    unsigned short type = primitiveValue->primitiveType();
+    int factor = 0;
+    if (type == CSSPrimitiveValue::CSS_EMS || type == CSSPrimitiveValue::CSS_REMS) {
+        if (defaultFontSize > 0)
+            factor = defaultFontSize;
+        else
+            return false;
+    } else if (type == CSSPrimitiveValue::CSS_PX) {
+        factor = 1;
+    } else {
+        return false;
+    }
+    result = roundForImpreciseConversion<int>(primitiveValue->getDoubleValue()*factor);
+    return true;
+}
+
+static bool computeLength(CSSValue* value, bool strict, RenderStyle* initialStyle, int defaultFontSize, int& result)
 {
     if (!value->isPrimitiveValue())
         return false;
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
 
     if (primitiveValue->isNumber()) {
         result = primitiveValue->getIntValue();
-        return !mediaValues.strictMode() || !result;
+        return !strict || !result;
     }
 
-    if (primitiveValue->isLength())
-        return mediaValues.computeLength(primitiveValue->getDoubleValue(), primitiveValue->primitiveType(), result);
+    if (primitiveValue->isLength()) {
+        if (initialStyle) {
+            // Relative (like EM) and root relative (like REM) units are always resolved against
+            // the initial values for media queries, hence the two initialStyle parameters.
+            // FIXME: We need to plumb viewport unit support down to here.
+            result = primitiveValue->computeLength<int>(CSSToLengthConversionData(initialStyle, initialStyle, 0, 1.0 /* zoom */, true /* computingFontSize */));
+        } else {
+            return computeLengthWithoutStyle(primitiveValue, defaultFontSize, result);
+        }
+        return true;
+    }
 
     return false;
 }
 
 static bool deviceHeightMediaFeatureEval(CSSValue* value, MediaFeaturePrefix op, const MediaValues& mediaValues)
 {
     if (value) {
         int length;
-        return computeLength(value, mediaValues, length) && compareValue(static_cast<int>(mediaValues.deviceHeight()), length, op);
+        return computeLength(value, mediaValues.strictMode(), mediaValues.style(), mediaValues.defaultFontSize(), length)
+            && compareValue(static_cast<int>(mediaValues.deviceHeight()), length, op);
     }
     // ({,min-,max-}device-height)
     // assume if we have a device, assume non-zero
     return true;
 }
 
 static bool deviceWidthMediaFeatureEval(CSSValue* value, MediaFeaturePrefix op, const MediaValues& mediaValues)
 {
     if (value) {
         int length;
-        return computeLength(value, mediaValues, length) && compareValue(static_cast<int>(mediaValues.deviceWidth()), length, op);
+        return computeLength(value, mediaValues.strictMode(), mediaValues.style(), mediaValues.defaultFontSize(), length)
+            && compareValue(static_cast<int>(mediaValues.deviceWidth()), length, op);
     }
     // ({,min-,max-}device-width)
     // assume if we have a device, assume non-zero
     return true;
 }
 
 static bool heightMediaFeatureEval(CSSValue* value, MediaFeaturePrefix op, const MediaValues& mediaValues)
 {
     int height = mediaValues.viewportHeight();
     if (value) {
         int length;
-        return computeLength(value, mediaValues, length) && compareValue(height, length, op);
+        return computeLength(value, mediaValues.strictMode(), mediaValues.style(), mediaValues.defaultFontSize(), length)
+            && compareValue(height, length, op);
     }
 
     return height;
 }
 
 static bool widthMediaFeatureEval(CSSValue* value, MediaFeaturePrefix op, const MediaValues& mediaValues)
 {
     int width = mediaValues.viewportWidth();
     if (value) {
         int length;
-        return computeLength(value, mediaValues, length) && compareValue(width, length, op);
+        return computeLength(value, mediaValues.strictMode(), mediaValues.style(), mediaValues.defaultFontSize(), length)
+            && compareValue(width, length, op);
     }
 
     return width;
 }
 
 // Rest of the functions are trampolines which set the prefix according to the media feature expression used.
 
 static bool minColorMediaFeatureEval(CSSValue* value, MediaFeaturePrefix, const MediaValues& mediaValues)
 {
     return colorMediaFeatureEval(value, MinPrefix, mediaValues);
@@ skipping 224 matching lines @@
     // Create the table.
     gFunctionMap = new FunctionMap;
 #define ADD_TO_FUNCTIONMAP(name)  \
     gFunctionMap->set(name##MediaFeature.impl(), name##MediaFeatureEval);
     CSS_MEDIAQUERY_NAMES_FOR_EACH_MEDIAFEATURE(ADD_TO_FUNCTIONMAP);
 #undef ADD_TO_FUNCTIONMAP
 }
 
 bool MediaQueryEvaluator::eval(const MediaQueryExp* expr) const
 {
-    if (!m_mediaValues || !m_mediaValues->hasValues())
+    if (!m_mediaValues)
         return m_expectedResult;
 
     if (!gFunctionMap)
         createFunctionMap();
 
     // Call the media feature evaluation function. Assume no prefix and let
     // trampoline functions override the prefix if prefix is used.
     EvalFunc func = gFunctionMap->get(expr->mediaFeature().impl());
     if (func)
         return func(expr->value(), NoPrefix, *m_mediaValues);
 
     return false;
 }
 
 } // namespace