Index: Source/core/css/MediaQueryEvaluator.cpp |
diff --git a/Source/core/css/MediaQueryEvaluator.cpp b/Source/core/css/MediaQueryEvaluator.cpp |
index 37847a78b3cdfcd29a298d2fdb9dacaa2acdc04f..bde9bee4cb8645136b4c25e59e6ed4e189334038 100644 |
--- a/Source/core/css/MediaQueryEvaluator.cpp |
+++ b/Source/core/css/MediaQueryEvaluator.cpp |
@@ -46,6 +46,7 @@ |
#include "core/frame/FrameView.h" |
#include "core/frame/LocalFrame.h" |
#include "core/frame/Settings.h" |
+#include "core/html/imports/HTMLImport.h" |
#include "core/inspector/InspectorInstrumentation.h" |
#include "core/rendering/RenderView.h" |
#include "core/rendering/compositing/RenderLayerCompositor.h" |
@@ -60,7 +61,7 @@ using namespace MediaFeatureNames; |
enum MediaFeaturePrefix { MinPrefix, MaxPrefix, NoPrefix }; |
-typedef bool (*EvalFunc)(CSSValue*, RenderStyle*, LocalFrame*, MediaFeaturePrefix); |
+typedef bool (*EvalFunc)(CSSValue*, RenderStyle*, LocalFrame*, MediaFeaturePrefix, MediaValues*, bool); |
typedef HashMap<StringImpl*, EvalFunc> FunctionMap; |
static FunctionMap* gFunctionMap; |
@@ -68,6 +69,7 @@ MediaQueryEvaluator::MediaQueryEvaluator(bool mediaFeatureResult) |
: m_frame(0) |
, m_style(nullptr) |
, m_expResult(mediaFeatureResult) |
+ , m_mediaValues(nullptr) |
{ |
} |
@@ -76,6 +78,7 @@ MediaQueryEvaluator::MediaQueryEvaluator(const String& acceptedMediaType, bool m |
, m_frame(0) |
, m_style(nullptr) |
, m_expResult(mediaFeatureResult) |
+ , m_mediaValues(nullptr) |
{ |
} |
@@ -84,6 +87,7 @@ MediaQueryEvaluator::MediaQueryEvaluator(const char* acceptedMediaType, bool med |
, m_frame(0) |
, m_style(nullptr) |
, m_expResult(mediaFeatureResult) |
+ , m_mediaValues(nullptr) |
{ |
} |
@@ -92,6 +96,16 @@ MediaQueryEvaluator::MediaQueryEvaluator(const String& acceptedMediaType, LocalF |
, m_frame(frame) |
, m_style(style) |
, m_expResult(false) // Doesn't matter when we have m_frame and m_style. |
+ , m_mediaValues(nullptr) |
+{ |
+} |
+ |
+MediaQueryEvaluator::MediaQueryEvaluator(const String& acceptedMediaType, const MediaValues* mediaValues, bool mediaFeatureResult) |
+ : m_mediaType(acceptedMediaType) |
+ , m_frame(0) |
+ , m_style(nullptr) |
+ , m_expResult(mediaFeatureResult) |
+ , m_mediaValues(MediaValues::copy(mediaValues)) |
{ |
} |
@@ -148,8 +162,9 @@ bool MediaQueryEvaluator::eval(const MediaQuerySet* querySet, MediaQueryResultLi |
// Assume true if we are at the end of the list, otherwise assume false. |
result = applyRestrictor(query->restrictor(), expressions.size() == j); |
- } else |
+ } else { |
result = applyRestrictor(query->restrictor(), false); |
+ } |
} |
return result; |
@@ -189,9 +204,17 @@ static bool numberValue(CSSValue* value, float& result) |
return false; |
} |
-static bool colorMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame* frame, MediaFeaturePrefix op) |
+static bool colorMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame* frame, MediaFeaturePrefix op, MediaValues* mediaValues, bool expectedValue) |
{ |
- int bitsPerComponent = screenDepthPerComponent(frame->view()); |
+ if (!frame && !mediaValues) |
+ return expectedValue; |
+ |
+ int bitsPerComponent; |
+ if (frame) |
+ bitsPerComponent = screenDepthPerComponent(frame->view()); |
+ else |
+ bitsPerComponent = mediaValues->getColorBitsPerComponent(); |
+ |
float number; |
if (value) |
return numberValue(value, number) && compareValue(bitsPerComponent, static_cast<int>(number), op); |
@@ -199,7 +222,7 @@ static bool colorMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame* fra |
return bitsPerComponent != 0; |
} |
-static bool colorIndexMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame*, MediaFeaturePrefix op) |
+static bool colorIndexMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame*, MediaFeaturePrefix op, MediaValues*, bool) |
{ |
// FIXME: We currently assume that we do not support indexed displays, as it is unknown |
// how to retrieve the information if the display mode is indexed. This matches Firefox. |
@@ -211,9 +234,18 @@ static bool colorIndexMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame |
return numberValue(value, number) && compareValue(0, static_cast<int>(number), op); |
} |
-static bool monochromeMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix op) |
+static bool monochromeMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix op, MediaValues* mediaValues, bool expectedValue) |
{ |
- if (!screenIsMonochrome(frame->view())) { |
+ if ((!frame || !style) && !mediaValues) |
+ return expectedValue; |
+ |
+ bool isMonochrome; |
+ if (frame) |
+ isMonochrome = screenIsMonochrome(frame->view()); |
+ else |
+ isMonochrome = (mediaValues->getMonochromeBitsPerComponent() > 0); |
+ |
+ if (!isMonochrome) { |
if (value) { |
float number; |
return numberValue(value, number) && compareValue(0, static_cast<int>(number), op); |
@@ -221,7 +253,7 @@ static bool monochromeMediaFeatureEval(CSSValue* value, RenderStyle* style, Loca |
return false; |
} |
- return colorMediaFeatureEval(value, style, frame, op); |
+ return colorMediaFeatureEval(value, style, frame, op, mediaValues, expectedValue); |
} |
static IntSize viewportSize(FrameView* view) |
@@ -229,11 +261,22 @@ static IntSize viewportSize(FrameView* view) |
return view->layoutSize(IncludeScrollbars); |
} |
-static bool orientationMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame* frame, MediaFeaturePrefix) |
+static bool orientationMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame* frame, MediaFeaturePrefix, MediaValues* mediaValues, bool expectedValue) |
{ |
- FrameView* view = frame->view(); |
- int width = viewportSize(view).width(); |
- int height = viewportSize(view).height(); |
+ if (!frame && !mediaValues) |
+ return expectedValue; |
+ |
+ int width; |
+ int height; |
+ if (frame) { |
+ FrameView* view = frame->view(); |
+ width = viewportSize(view).width(); |
+ height = viewportSize(view).height(); |
+ } else { |
+ width = mediaValues->getViewportWidth(); |
+ height = mediaValues->getViewportHeight(); |
+ } |
+ |
if (value && value->isPrimitiveValue()) { |
const CSSValueID id = toCSSPrimitiveValue(value)->getValueID(); |
if (width > height) // Square viewport is portrait. |
@@ -245,11 +288,24 @@ static bool orientationMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFram |
return height >= 0 && width >= 0; |
} |
-static bool aspectRatioMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame* frame, MediaFeaturePrefix op) |
+static bool aspectRatioMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame* frame, MediaFeaturePrefix op, MediaValues* mediaValues, bool expectedValue) |
{ |
+ if (!frame && !mediaValues) |
+ return expectedValue; |
+ |
if (value) { |
- FrameView* view = frame->view(); |
- return compareAspectRatioValue(value, viewportSize(view).width(), viewportSize(view).height(), op); |
+ int width; |
+ int height; |
+ if (frame) { |
+ FrameView* view = frame->view(); |
+ width = viewportSize(view).width(); |
+ height = viewportSize(view).height(); |
+ } else { |
+ width = mediaValues->getViewportWidth(); |
+ height = mediaValues->getViewportHeight(); |
+ } |
+ |
+ return compareAspectRatioValue(value, width, height, op); |
} |
// ({,min-,max-}aspect-ratio) |
@@ -257,11 +313,24 @@ static bool aspectRatioMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFram |
return true; |
} |
-static bool deviceAspectRatioMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame* frame, MediaFeaturePrefix op) |
+static bool deviceAspectRatioMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame* frame, MediaFeaturePrefix op, MediaValues* mediaValues, bool expectedValue) |
{ |
+ if (!frame && !mediaValues) |
+ return expectedValue; |
+ |
if (value) { |
- FloatRect sg = screenRect(frame->view()); |
- return compareAspectRatioValue(value, static_cast<int>(sg.width()), static_cast<int>(sg.height()), op); |
+ int width; |
+ int height; |
+ if (frame) { |
+ FloatRect sg = screenRect(frame->view()); |
+ width = static_cast<int>(sg.width()); |
+ height = static_cast<int>(sg.height()); |
+ } else { |
+ width = mediaValues->getDeviceWidth(); |
+ height = mediaValues->getDeviceHeight(); |
+ } |
+ |
+ return compareAspectRatioValue(value, width, height, op); |
} |
// ({,min-,max-}device-aspect-ratio) |
@@ -269,8 +338,11 @@ static bool deviceAspectRatioMediaFeatureEval(CSSValue* value, RenderStyle*, Loc |
return true; |
} |
-static bool evalResolution(CSSValue* value, LocalFrame* frame, MediaFeaturePrefix op) |
+static bool evalResolution(CSSValue* value, LocalFrame* frame, MediaFeaturePrefix op, MediaValues* mediaValues, bool expectedValue) |
{ |
+ if (!frame && !mediaValues) |
+ return expectedValue; |
+ |
// According to MQ4, only 'screen', 'print' and 'speech' may match. |
// FIXME: What should speech match? https://www.w3.org/Style/CSS/Tracker/issues/348 |
float actualResolution = 0; |
@@ -279,14 +351,18 @@ static bool evalResolution(CSSValue* value, LocalFrame* frame, MediaFeaturePrefi |
// this method only got called if this media type matches the one defined |
// in the query. Thus, if if the document's media type is "print", the |
// media type of the query will either be "print" or "all". |
- String mediaType = frame->view()->mediaType(); |
- if (equalIgnoringCase(mediaType, "screen")) |
- actualResolution = clampTo<float>(frame->devicePixelRatio()); |
- else if (equalIgnoringCase(mediaType, "print")) { |
- // The resolution of images while printing should not depend on the DPI |
- // of the screen. Until we support proper ways of querying this info |
- // we use 300px which is considered minimum for current printers. |
- actualResolution = 300 / cssPixelsPerInch; |
+ if (frame) { |
+ String mediaType = frame->view()->mediaType(); |
+ if (equalIgnoringCase(mediaType, "screen")) { |
+ actualResolution = clampTo<float>(frame->devicePixelRatio()); |
+ } else if (equalIgnoringCase(mediaType, "print")) { |
+ // The resolution of images while printing should not depend on the DPI |
+ // of the screen. Until we support proper ways of querying this info |
+ // we use 300px which is considered minimum for current printers. |
+ actualResolution = 300 / cssPixelsPerInch; |
+ } |
+ } else { |
+ actualResolution = mediaValues->getPixelRatio(); |
} |
if (!value) |
@@ -317,19 +393,19 @@ static bool evalResolution(CSSValue* value, LocalFrame* frame, MediaFeaturePrefi |
return compareValue(actualResolution, resolution->getFloatValue(CSSPrimitiveValue::CSS_DPPX), op); |
} |
-static bool devicePixelRatioMediaFeatureEval(CSSValue *value, RenderStyle*, LocalFrame* frame, MediaFeaturePrefix op) |
+static bool devicePixelRatioMediaFeatureEval(CSSValue *value, RenderStyle*, LocalFrame* frame, MediaFeaturePrefix op, MediaValues* mediaValues, bool expectedValue) |
{ |
UseCounter::count(frame->document(), UseCounter::PrefixedDevicePixelRatioMediaFeature); |
- return (!value || toCSSPrimitiveValue(value)->isNumber()) && evalResolution(value, frame, op); |
+ return (!value || toCSSPrimitiveValue(value)->isNumber()) && evalResolution(value, frame, op, mediaValues, expectedValue); |
} |
-static bool resolutionMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame* frame, MediaFeaturePrefix op) |
+static bool resolutionMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame* frame, MediaFeaturePrefix op, MediaValues* MediaValues, bool expectedValue) |
{ |
- return (!value || toCSSPrimitiveValue(value)->isResolution()) && evalResolution(value, frame, op); |
+ return (!value || toCSSPrimitiveValue(value)->isResolution()) && evalResolution(value, frame, op, MediaValues, expectedValue); |
} |
-static bool gridMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame*, MediaFeaturePrefix op) |
+static bool gridMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame*, MediaFeaturePrefix op, MediaValues*, bool) |
{ |
// if output device is bitmap, grid: 0 == true |
// assume we have bitmap device |
@@ -339,7 +415,7 @@ static bool gridMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame*, Med |
return false; |
} |
-static bool computeLength(CSSValue* value, bool strict, RenderStyle* initialStyle, int& result) |
+static bool computeLength(CSSValue* value, bool strict, RenderStyle* initialStyle, int defaultFontSize, int& result) |
{ |
if (!value->isPrimitiveValue()) |
return false; |
@@ -352,73 +428,138 @@ static bool computeLength(CSSValue* value, bool strict, RenderStyle* initialStyl |
} |
if (primitiveValue->isLength()) { |
- // 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 */)); |
+ 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 { |
+ 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; |
} |
return false; |
} |
-static bool deviceHeightMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix op) |
+static bool deviceHeightMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix op, MediaValues* mediaValues, bool expectedValue) |
{ |
+ if ((!frame || !style) && !mediaValues) |
+ return expectedValue; |
+ int fontSize = 0; |
+ if (mediaValues) |
+ fontSize = mediaValues->getDefaultFontSize(); |
+ |
if (value) { |
+ int height; |
int length; |
- if (!computeLength(value, !frame->document()->inQuirksMode(), style, length)) |
- return false; |
- int height = static_cast<int>(screenRect(frame->view()).height()); |
- if (frame->settings()->reportScreenSizeInPhysicalPixelsQuirk()) |
- height = lroundf(height * frame->host()->deviceScaleFactor()); |
- return compareValue(height, length, op); |
+ bool inStrictMode = true; |
+ if (frame) { |
+ height = static_cast<int>(screenRect(frame->view()).height()); |
+ if (frame->settings()->reportScreenSizeInPhysicalPixelsQuirk()) |
+ height = lroundf(height * frame->host()->deviceScaleFactor()); |
+ inStrictMode = !frame->document()->inQuirksMode(); |
+ } else { |
+ height = mediaValues->getDeviceHeight(); |
+ } |
+ return computeLength(value, inStrictMode, style, fontSize, length) && compareValue(static_cast<int>(height), length, op); |
} |
// ({,min-,max-}device-height) |
// assume if we have a device, assume non-zero |
return true; |
} |
-static bool deviceWidthMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix op) |
+static bool deviceWidthMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix op, MediaValues* mediaValues, bool expectedValue) |
{ |
+ if ((!frame || !style) && !mediaValues) |
+ return expectedValue; |
+ int fontSize = 0; |
+ if (mediaValues) |
+ fontSize = mediaValues->getDefaultFontSize(); |
+ |
if (value) { |
+ int width; |
int length; |
- if (!computeLength(value, !frame->document()->inQuirksMode(), style, length)) |
- return false; |
- int width = static_cast<int>(screenRect(frame->view()).width()); |
- if (frame->settings()->reportScreenSizeInPhysicalPixelsQuirk()) |
- width = lroundf(width * frame->host()->deviceScaleFactor()); |
- return compareValue(width, length, op); |
+ bool inStrictMode = true; |
+ if (frame) { |
+ width = static_cast<int>(screenRect(frame->view()).width()); |
+ if (frame->settings()->reportScreenSizeInPhysicalPixelsQuirk()) |
+ width = lroundf(width * frame->host()->deviceScaleFactor()); |
+ inStrictMode = !frame->document()->inQuirksMode(); |
+ } else { |
+ width = mediaValues->getDeviceWidth(); |
+ } |
+ return computeLength(value, inStrictMode, style, fontSize, length) && compareValue(static_cast<int>(width), length, op); |
} |
// ({,min-,max-}device-width) |
// assume if we have a device, assume non-zero |
return true; |
} |
-static bool heightMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix op) |
+static bool heightMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix op, MediaValues* mediaValues, bool expectedValue) |
{ |
+ if ((!frame || !style) && !mediaValues) |
+ return expectedValue; |
+ int fontSize = 0; |
+ if (mediaValues) |
+ fontSize = mediaValues->getDefaultFontSize(); |
+ |
FrameView* view = frame->view(); |
int height = viewportSize(view).height(); |
if (value) { |
- if (RenderView* renderView = frame->document()->renderView()) |
- height = adjustForAbsoluteZoom(height, renderView); |
+ RenderView* renderView = 0; |
+ bool inStrictMode = true; |
+ if (frame) { |
+ if ((renderView = frame->document()->renderView())) |
+ height = adjustForAbsoluteZoom(height, renderView); |
+ inStrictMode = !frame->document()->inQuirksMode(); |
+ } |
int length; |
- return computeLength(value, !frame->document()->inQuirksMode(), style, length) && compareValue(height, length, op); |
+ return computeLength(value, inStrictMode, style, fontSize, length) && compareValue(height, length, op); |
} |
return height; |
} |
-static bool widthMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix op) |
+static bool widthMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix op, MediaValues* mediaValues, bool expectedValue) |
{ |
- FrameView* view = frame->view(); |
+ if ((!frame || !style) && !mediaValues) |
+ return expectedValue; |
+ int fontSize = 0; |
+ int width; |
+ if (mediaValues) |
+ fontSize = mediaValues->getDefaultFontSize(); |
+ |
+ if (frame) { |
+ FrameView* view = frame->view(); |
+ width = viewportSize(view).width(); |
+ } else { |
+ width = mediaValues->getViewportWidth(); |
+ } |
- int width = viewportSize(view).width(); |
if (value) { |
- if (RenderView* renderView = frame->document()->renderView()) |
- width = adjustForAbsoluteZoom(width, renderView); |
+ RenderView* renderView = 0; |
+ bool inStrictMode = true; |
+ if (frame) { |
+ if ((renderView = frame->document()->renderView())) |
+ width = adjustForAbsoluteZoom(width, renderView); |
+ inStrictMode = !frame->document()->inQuirksMode(); |
+ } |
int length; |
- return computeLength(value, !frame->document()->inQuirksMode(), style, length) && compareValue(width, length, op); |
+ return computeLength(value, inStrictMode, style, fontSize, length) && compareValue(width, length, op); |
} |
return width; |
@@ -426,121 +567,121 @@ static bool widthMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFram |
// Rest of the functions are trampolines which set the prefix according to the media feature expression used. |
-static bool minColorMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix) |
+static bool minColorMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix, MediaValues* mediaValues, bool expectedValue) |
{ |
- return colorMediaFeatureEval(value, style, frame, MinPrefix); |
+ return colorMediaFeatureEval(value, style, frame, MinPrefix, mediaValues, expectedValue); |
} |
-static bool maxColorMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix) |
+static bool maxColorMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix, MediaValues* mediaValues, bool expectedValue) |
{ |
- return colorMediaFeatureEval(value, style, frame, MaxPrefix); |
+ return colorMediaFeatureEval(value, style, frame, MaxPrefix, mediaValues, expectedValue); |
} |
-static bool minColorIndexMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix) |
+static bool minColorIndexMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix, MediaValues*, bool expectedValue) |
{ |
- return colorIndexMediaFeatureEval(value, style, frame, MinPrefix); |
+ return colorIndexMediaFeatureEval(value, style, frame, MinPrefix, 0, expectedValue); |
} |
-static bool maxColorIndexMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix) |
+static bool maxColorIndexMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix, MediaValues*, bool expectedValue) |
{ |
- return colorIndexMediaFeatureEval(value, style, frame, MaxPrefix); |
+ return colorIndexMediaFeatureEval(value, style, frame, MaxPrefix, 0, expectedValue); |
} |
-static bool minMonochromeMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix) |
+static bool minMonochromeMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix, MediaValues* mediaValues, bool expectedValue) |
{ |
- return monochromeMediaFeatureEval(value, style, frame, MinPrefix); |
+ return monochromeMediaFeatureEval(value, style, frame, MinPrefix, mediaValues, expectedValue); |
} |
-static bool maxMonochromeMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix) |
+static bool maxMonochromeMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix, MediaValues* mediaValues, bool expectedValue) |
{ |
- return monochromeMediaFeatureEval(value, style, frame, MaxPrefix); |
+ return monochromeMediaFeatureEval(value, style, frame, MaxPrefix, mediaValues, expectedValue); |
} |
-static bool minAspectRatioMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix) |
+static bool minAspectRatioMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix, MediaValues* mediaValues, bool expectedValue) |
{ |
- return aspectRatioMediaFeatureEval(value, style, frame, MinPrefix); |
+ return aspectRatioMediaFeatureEval(value, style, frame, MinPrefix, mediaValues, expectedValue); |
} |
-static bool maxAspectRatioMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix) |
+static bool maxAspectRatioMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix, MediaValues* mediaValues, bool expectedValue) |
{ |
- return aspectRatioMediaFeatureEval(value, style, frame, MaxPrefix); |
+ return aspectRatioMediaFeatureEval(value, style, frame, MaxPrefix, mediaValues, expectedValue); |
} |
-static bool minDeviceAspectRatioMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix) |
+static bool minDeviceAspectRatioMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix, MediaValues* mediaValues, bool expectedValue) |
{ |
- return deviceAspectRatioMediaFeatureEval(value, style, frame, MinPrefix); |
+ return deviceAspectRatioMediaFeatureEval(value, style, frame, MinPrefix, mediaValues, expectedValue); |
} |
-static bool maxDeviceAspectRatioMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix) |
+static bool maxDeviceAspectRatioMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix, MediaValues* mediaValues, bool expectedValue) |
{ |
- return deviceAspectRatioMediaFeatureEval(value, style, frame, MaxPrefix); |
+ return deviceAspectRatioMediaFeatureEval(value, style, frame, MaxPrefix, mediaValues, expectedValue); |
} |
-static bool minDevicePixelRatioMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix) |
+static bool minDevicePixelRatioMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix, MediaValues* mediaValues, bool expectedValue) |
{ |
UseCounter::count(frame->document(), UseCounter::PrefixedMinDevicePixelRatioMediaFeature); |
- return devicePixelRatioMediaFeatureEval(value, style, frame, MinPrefix); |
+ return devicePixelRatioMediaFeatureEval(value, style, frame, MinPrefix, mediaValues, expectedValue); |
} |
-static bool maxDevicePixelRatioMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix) |
+static bool maxDevicePixelRatioMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix, MediaValues* mediaValues, bool expectedValue) |
{ |
UseCounter::count(frame->document(), UseCounter::PrefixedMaxDevicePixelRatioMediaFeature); |
- return devicePixelRatioMediaFeatureEval(value, style, frame, MaxPrefix); |
+ return devicePixelRatioMediaFeatureEval(value, style, frame, MaxPrefix, mediaValues, expectedValue); |
} |
-static bool minHeightMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix) |
+static bool minHeightMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix, MediaValues* mediaValues, bool expectedValue) |
{ |
- return heightMediaFeatureEval(value, style, frame, MinPrefix); |
+ return heightMediaFeatureEval(value, style, frame, MinPrefix, mediaValues, expectedValue); |
} |
-static bool maxHeightMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix) |
+static bool maxHeightMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix, MediaValues* mediaValues, bool expectedValue) |
{ |
- return heightMediaFeatureEval(value, style, frame, MaxPrefix); |
+ return heightMediaFeatureEval(value, style, frame, MaxPrefix, mediaValues, expectedValue); |
} |
-static bool minWidthMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix) |
+static bool minWidthMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix, MediaValues* mediaValues, bool expectedValue) |
{ |
- return widthMediaFeatureEval(value, style, frame, MinPrefix); |
+ return widthMediaFeatureEval(value, style, frame, MinPrefix, mediaValues, expectedValue); |
} |
-static bool maxWidthMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix) |
+static bool maxWidthMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix, MediaValues* mediaValues, bool expectedValue) |
{ |
- return widthMediaFeatureEval(value, style, frame, MaxPrefix); |
+ return widthMediaFeatureEval(value, style, frame, MaxPrefix, mediaValues, expectedValue); |
} |
-static bool minDeviceHeightMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix) |
+static bool minDeviceHeightMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix, MediaValues* mediaValues, bool expectedValue) |
{ |
- return deviceHeightMediaFeatureEval(value, style, frame, MinPrefix); |
+ return deviceHeightMediaFeatureEval(value, style, frame, MinPrefix, mediaValues, expectedValue); |
} |
-static bool maxDeviceHeightMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix) |
+static bool maxDeviceHeightMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix, MediaValues* mediaValues, bool expectedValue) |
{ |
- return deviceHeightMediaFeatureEval(value, style, frame, MaxPrefix); |
+ return deviceHeightMediaFeatureEval(value, style, frame, MaxPrefix, mediaValues, expectedValue); |
} |
-static bool minDeviceWidthMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix) |
+static bool minDeviceWidthMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix, MediaValues* mediaValues, bool expectedValue) |
{ |
- return deviceWidthMediaFeatureEval(value, style, frame, MinPrefix); |
+ return deviceWidthMediaFeatureEval(value, style, frame, MinPrefix, mediaValues, expectedValue); |
} |
-static bool maxDeviceWidthMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix) |
+static bool maxDeviceWidthMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix, MediaValues* mediaValues, bool expectedValue) |
{ |
- return deviceWidthMediaFeatureEval(value, style, frame, MaxPrefix); |
+ return deviceWidthMediaFeatureEval(value, style, frame, MaxPrefix, mediaValues, expectedValue); |
} |
-static bool minResolutionMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix) |
+static bool minResolutionMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix, MediaValues* mediaValues, bool expectedValue) |
{ |
- return resolutionMediaFeatureEval(value, style, frame, MinPrefix); |
+ return resolutionMediaFeatureEval(value, style, frame, MinPrefix, mediaValues, expectedValue); |
} |
-static bool maxResolutionMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix) |
+static bool maxResolutionMediaFeatureEval(CSSValue* value, RenderStyle* style, LocalFrame* frame, MediaFeaturePrefix, MediaValues* mediaValues, bool expectedValue) |
{ |
- return resolutionMediaFeatureEval(value, style, frame, MaxPrefix); |
+ return resolutionMediaFeatureEval(value, style, frame, MaxPrefix, mediaValues, expectedValue); |
} |
-static bool animationMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame* frame, MediaFeaturePrefix op) |
+static bool animationMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame* frame, MediaFeaturePrefix op, MediaValues*, bool) |
{ |
UseCounter::count(frame->document(), UseCounter::PrefixedAnimationMediaFeature); |
@@ -551,7 +692,7 @@ static bool animationMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame* |
return true; |
} |
-static bool transform2dMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame* frame, MediaFeaturePrefix op) |
+static bool transform2dMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame* frame, MediaFeaturePrefix op, MediaValues*, bool) |
{ |
UseCounter::count(frame->document(), UseCounter::PrefixedTransform2dMediaFeature); |
@@ -562,16 +703,25 @@ static bool transform2dMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFram |
return true; |
} |
-static bool transform3dMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame* frame, MediaFeaturePrefix op) |
+static bool transform3dMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame* frame, MediaFeaturePrefix op, MediaValues* mediaValues, bool expectedValue) |
{ |
UseCounter::count(frame->document(), UseCounter::PrefixedTransform3dMediaFeature); |
+ // TODO: Not implementing mediaValues yet |
+ |
+ if (!frame && !mediaValues) |
+ return expectedValue; |
+ |
bool returnValueIfNoParameter; |
int have3dRendering; |
bool threeDEnabled = false; |
- if (RenderView* view = frame->contentRenderer()) |
- threeDEnabled = view->compositor()->canRender3DTransforms(); |
+ if (frame) { |
+ if (RenderView* view = frame->contentRenderer()) |
+ threeDEnabled = view->compositor()->canRender3DTransforms(); |
+ } else { |
+ threeDEnabled = mediaValues->getThreeDEnabled(); |
+ } |
returnValueIfNoParameter = threeDEnabled; |
have3dRendering = threeDEnabled ? 1 : 0; |
@@ -583,7 +733,7 @@ static bool transform3dMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFram |
return returnValueIfNoParameter; |
} |
-static bool viewModeMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame* frame, MediaFeaturePrefix) |
+static bool viewModeMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame* frame, MediaFeaturePrefix, MediaValues*, bool) |
{ |
UseCounter::count(frame->document(), UseCounter::PrefixedViewModeMediaFeature); |
@@ -610,9 +760,16 @@ static PointerDeviceType leastCapablePrimaryPointerDeviceType(LocalFrame* frame) |
return UnknownPointer; |
} |
-static bool hoverMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame* frame, MediaFeaturePrefix) |
+static bool hoverMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame* frame, MediaFeaturePrefix, MediaValues* mediaValues, bool expectedValue) |
{ |
- PointerDeviceType pointer = leastCapablePrimaryPointerDeviceType(frame); |
+ if (!frame && !mediaValues) |
+ return expectedValue; |
+ |
+ PointerDeviceType pointer; |
+ if (frame) |
+ pointer = leastCapablePrimaryPointerDeviceType(frame); |
+ else |
+ pointer = static_cast<PointerDeviceType>(mediaValues->getPointer()); |
// If we're on a port that hasn't explicitly opted into providing pointer device information |
// (or otherwise can't be confident in the pointer hardware available), then behave exactly |
@@ -631,9 +788,16 @@ static bool hoverMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame* fra |
|| (pointer == MousePointer && number == 1); |
} |
-static bool pointerMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame* frame, MediaFeaturePrefix) |
+static bool pointerMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame* frame, MediaFeaturePrefix, MediaValues* mediaValues, bool expectedValue) |
{ |
- PointerDeviceType pointer = leastCapablePrimaryPointerDeviceType(frame); |
+ if (!frame && !mediaValues) |
+ return expectedValue; |
+ |
+ PointerDeviceType pointer; |
+ if (frame) |
+ pointer = leastCapablePrimaryPointerDeviceType(frame); |
+ else |
+ pointer = static_cast<PointerDeviceType>(mediaValues->getPointer()); |
// If we're on a port that hasn't explicitly opted into providing pointer device information |
// (or otherwise can't be confident in the pointer hardware available), then behave exactly |
@@ -653,9 +817,18 @@ static bool pointerMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame* f |
|| (pointer == MousePointer && id == CSSValueFine); |
} |
-static bool scanMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame* frame, MediaFeaturePrefix) |
+static bool scanMediaFeatureEval(CSSValue* value, RenderStyle*, LocalFrame* frame, MediaFeaturePrefix, MediaValues* mediaValues, bool expectedValue) |
{ |
+ if (!frame && !mediaValues) |
+ return expectedValue; |
+ |
// Scan only applies to 'tv' media. |
+ String mediaType; |
+ if (frame) |
+ mediaType = frame->view()->mediaType(); |
+ else |
+ mediaType = mediaValues->getMediaType(); |
+ |
if (!equalIgnoringCase(frame->view()->mediaType(), "tv")) |
return false; |
@@ -683,7 +856,7 @@ static void createFunctionMap() |
bool MediaQueryEvaluator::eval(const MediaQueryExp* expr) const |
{ |
- if (!m_frame || !m_style) |
+ if (!m_mediaValues && (!m_frame || !m_style)) |
return m_expResult; |
if (!gFunctionMap) |
@@ -693,9 +866,73 @@ bool MediaQueryEvaluator::eval(const MediaQueryExp* expr) const |
// trampoline functions override the prefix if prefix is used. |
EvalFunc func = gFunctionMap->get(expr->mediaFeature().impl()); |
if (func) |
- return func(expr->value(), m_style.get(), m_frame, NoPrefix); |
+ return func(expr->value(), m_style.get(), m_frame, NoPrefix, m_mediaValues.get(), m_expResult); |
return false; |
} |
+PassRefPtr<MediaValues> MediaValues::create(Document* document) |
+{ |
+ Document* executingDocument = document->import() ? document->import()->master() : document; |
+ ASSERT(executingDocument->frame()); |
+ ASSERT(executingDocument->renderer()); |
+ ASSERT(executingDocument->renderer()->style()); |
+ LocalFrame* frame = executingDocument->frame(); |
+ RenderStyle* style = executingDocument->renderer()->style(); |
+ |
+ // get the values from Frame and Style |
+ FrameView* view = frame->view(); |
+ RenderView* renderView = frame->document()->renderView(); |
+ int viewportWidth = viewportSize(view).width(); |
+ int viewportHeight = viewportSize(view).height(); |
+ FloatRect sg = screenRect(frame->page()->mainFrame()->view()); |
+ int deviceWidth = static_cast<int>(sg.width()); |
+ int deviceHeight = static_cast<int>(sg.height()); |
+ float pixelRatio = frame->page()->deviceScaleFactor(); |
+ int bitsPerComponent = screenDepthPerComponent(frame->page()->mainFrame()->view()); |
+ int colorBitsPerComponent = 0; |
+ int monochromeBitsPerComponent = 0; |
+ int defaultFontSize = style->fontDescription().specifiedSize(); |
+ bool threeDEnabled = false; |
+ String mediaType = frame->view()->mediaType(); |
+ if (renderView) { |
+ viewportWidth = adjustForAbsoluteZoom(viewportWidth, renderView); |
+ viewportHeight = adjustForAbsoluteZoom(viewportHeight, renderView); |
+ } |
+ if (RenderView* view = frame->contentRenderer()) |
+ threeDEnabled = view->compositor()->canRender3DTransforms(); |
+ if (screenIsMonochrome(frame->page()->mainFrame()->view())) |
+ monochromeBitsPerComponent = bitsPerComponent; |
+ else |
+ colorBitsPerComponent = bitsPerComponent; |
+ PointerDeviceType pointer = leastCapablePrimaryPointerDeviceType(frame); |
+ |
+ return adoptRefWillBeRefCountedGarbageCollected(new MediaValues(viewportWidth, |
+ viewportHeight, |
+ deviceWidth, |
+ deviceHeight, |
+ pixelRatio, |
+ colorBitsPerComponent, |
+ monochromeBitsPerComponent, |
+ pointer, |
+ defaultFontSize, |
+ threeDEnabled, |
+ mediaType)); |
+} |
+ |
+PassRefPtr<MediaValues> MediaValues::copy(const MediaValues* mediaValues) |
+{ |
+ return adoptRefWillBeRefCountedGarbageCollected(new MediaValues(mediaValues->m_viewportWidth, |
+ mediaValues->m_viewportHeight, |
+ mediaValues->m_deviceWidth, |
+ mediaValues->m_deviceHeight, |
+ mediaValues->m_pixelRatio, |
+ mediaValues->m_colorBitsPerComponent, |
+ mediaValues->m_monochromeBitsPerComponent, |
+ mediaValues->m_pointer, |
+ mediaValues->m_defaultFontSize, |
+ mediaValues->m_threeDEnabled, |
+ mediaValues->m_mediaType)); |
+} |
+ |
} // namespace |