CSS Length calculation with MediaValues

Source/core/css/MediaValues.cpp

 // 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/MediaValues.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/frame/FrameHost.h"
@@ skipping 67 matching lines @@
     if (screenIsMonochrome(frame->page()->mainFrame()->view()))
         return screenDepthPerComponent(frame->view());
     return 0;
 }
 
 static int calculateDefaultFontSize(RenderStyle* style)
 {
     return style->fontDescription().specifiedSize();
 }
 
+static int calculateComputedFontSize(RenderStyle* style)
+{
+    return style->fontDescription().computedSize();
+}
+
+static bool calculateHasXHeight(RenderStyle* style)
+{
+    return style->fontMetrics().hasXHeight();
+}
+
+static double calculateXHeight(RenderStyle* style)
+{
+    return style->fontMetrics().xHeight();
+}
+
+static double calculateZeroWidth(RenderStyle* style)
+{
+    return style->fontMetrics().zeroWidth();
+}
+
 static bool calculateScanMediaType(LocalFrame* frame)
 {
     ASSERT(frame && frame->view());
     // Scan only applies to 'tv' media.
     return equalIgnoringCase(frame->view()->mediaType(), "tv");
 }
 
 static bool calculateScreenMediaType(LocalFrame* frame)
 {
     ASSERT(frame && frame->view());
     return equalIgnoringCase(frame->view()->mediaType(), "screen");
 }
 
 static bool calculatePrintMediaType(LocalFrame* frame)
 {
     ASSERT(frame && frame->view());
     return equalIgnoringCase(frame->view()->mediaType(), "print");
 }
 
 static bool calculateThreeDEnabled(LocalFrame* frame)
 {
     ASSERT(frame && frame->contentRenderer() && frame->contentRenderer()->compositor());
     bool threeDEnabled = false;
     if (RenderView* view = frame->contentRenderer())
         threeDEnabled = view->compositor()->canRender3DTransforms();
     return threeDEnabled;
 }
 
+static float calculateEffectiveZoom(RenderStyle* style)
+{
+    ASSERT(style);
+    return style->effectiveZoom();
+}
+
 static MediaValues::PointerDeviceType calculateLeastCapablePrimaryPointerDeviceType(LocalFrame* frame)
 {
     ASSERT(frame && frame->settings());
     if (frame->settings()->deviceSupportsTouch())
         return MediaValues::TouchPointer;
 
     // FIXME: We should also try to determine if we know we have a mouse.
     // When we do this, we'll also need to differentiate between known not to
     // have mouse or touch screen (NoPointer) and unknown (UnknownPointer).
     // We could also take into account other preferences like accessibility
     // settings to decide which of the available pointers should be considered
     // "primary".
 
     return MediaValues::UnknownPointer;
 }
 
 PassRefPtr<MediaValues> MediaValues::create(MediaValuesMode mode,
     int viewportWidth,
     int viewportHeight,
     int deviceWidth,
     int deviceHeight,
     float devicePixelRatio,
     int colorBitsPerComponent,
     int monochromeBitsPerComponent,
     PointerDeviceType pointer,
     int defaultFontSize,
+    int computedFontSize,
+    bool hasXHeight,
+    double xHeight,
+    double zeroWidth,
     bool threeDEnabled,
     bool scanMediaType,
     bool screenMediaType,
     bool printMediaType,
-    bool strictMode)
+    bool strictMode,
+    float effectiveZoom)
 {
     ASSERT(mode == CachingMode);
     RefPtr<MediaValues> mediaValues = adoptRef(new MediaValues(0, nullptr, mode));
     mediaValues->m_viewportWidth = viewportWidth;
     mediaValues->m_viewportHeight = viewportHeight;
     mediaValues->m_deviceWidth = deviceWidth;
     mediaValues->m_deviceHeight = deviceHeight;
     mediaValues->m_devicePixelRatio = devicePixelRatio;
     mediaValues->m_colorBitsPerComponent = colorBitsPerComponent;
     mediaValues->m_monochromeBitsPerComponent = monochromeBitsPerComponent;
     mediaValues->m_pointer = pointer;
     mediaValues->m_defaultFontSize = defaultFontSize;
+    mediaValues->m_computedFontSize = computedFontSize;
+    mediaValues->m_hasXHeight = hasXHeight;
+    mediaValues->m_xHeight = xHeight;
+    mediaValues->m_zeroWidth = zeroWidth;
     mediaValues->m_threeDEnabled = threeDEnabled;
     mediaValues->m_scanMediaType = scanMediaType;
     mediaValues->m_screenMediaType = screenMediaType;
     mediaValues->m_printMediaType = printMediaType;
     mediaValues->m_strictMode = strictMode;
+    mediaValues->m_effectiveZoom = effectiveZoom;
 
     return mediaValues;
 }
 
 PassRefPtr<MediaValues> MediaValues::create(LocalFrame* frame, RenderStyle* style, MediaValuesMode mode)
 {
     ASSERT(frame && style);
     RefPtr<MediaValues> mediaValues;
     mediaValues = adoptRef(new MediaValues(frame, style, mode));
     if (mode == CachingMode) {
         mediaValues->m_viewportWidth = calculateViewportWidth(frame, style);
-        mediaValues->m_viewportHeight = calculateViewportHeight(frame, style),
-        mediaValues->m_deviceWidth = calculateDeviceWidth(frame),
-        mediaValues->m_deviceHeight = calculateDeviceHeight(frame),
-        mediaValues->m_devicePixelRatio = calculateDevicePixelRatio(frame),
-        mediaValues->m_colorBitsPerComponent = calculateColorBitsPerComponent(frame),
-        mediaValues->m_monochromeBitsPerComponent = calculateMonochromeBitsPerComponent(frame),
-        mediaValues->m_pointer = calculateLeastCapablePrimaryPointerDeviceType(frame),
-        mediaValues->m_defaultFontSize = calculateDefaultFontSize(style),
-        mediaValues->m_threeDEnabled = calculateThreeDEnabled(frame),
-        mediaValues->m_scanMediaType = calculateScanMediaType(frame),
-        mediaValues->m_screenMediaType = calculateScreenMediaType(frame),
-        mediaValues->m_printMediaType = calculatePrintMediaType(frame),
+        mediaValues->m_viewportHeight = calculateViewportHeight(frame, style);
+        mediaValues->m_deviceWidth = calculateDeviceWidth(frame);
+        mediaValues->m_deviceHeight = calculateDeviceHeight(frame);
+        mediaValues->m_devicePixelRatio = calculateDevicePixelRatio(frame);
+        mediaValues->m_colorBitsPerComponent = calculateColorBitsPerComponent(frame);
+        mediaValues->m_monochromeBitsPerComponent = calculateMonochromeBitsPerComponent(frame);
+        mediaValues->m_pointer = calculateLeastCapablePrimaryPointerDeviceType(frame);
+        mediaValues->m_defaultFontSize = calculateDefaultFontSize(style);
+        mediaValues->m_computedFontSize = calculateComputedFontSize(style);
+        mediaValues->m_hasXHeight = calculateHasXHeight(style);
+        mediaValues->m_xHeight = calculateXHeight(style);
+        mediaValues->m_zeroWidth = calculateZeroWidth(style);
+        mediaValues->m_threeDEnabled = calculateThreeDEnabled(frame);
+        mediaValues->m_scanMediaType = calculateScanMediaType(frame);
+        mediaValues->m_screenMediaType = calculateScreenMediaType(frame);
+        mediaValues->m_printMediaType = calculatePrintMediaType(frame);
         mediaValues->m_strictMode = calculateStrictMode(frame);
+        mediaValues->m_effectiveZoom = calculateEffectiveZoom(style);
 
         mediaValues->m_style.clear();
         mediaValues->m_frame = 0;
     }
 
     return mediaValues;
 }
 
-PassRefPtr<MediaValues> MediaValues::create(Document* document, MediaValuesMode mode)
+PassRefPtr<MediaValues> MediaValues::create(const Document& document, MediaValuesMode mode)
 {
-    ASSERT(document);
-    Document* executingDocument = document->import() ? document->import()->master() : document;
+    const 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();
 
     return MediaValues::create(frame, style, mode);
 }
 
 PassRefPtr<MediaValues> MediaValues::copy() const
 {
     ASSERT(m_mode == CachingMode && !m_style.get() && !m_frame);
     RefPtr<MediaValues> mediaValues = adoptRef(new MediaValues(0, nullptr, m_mode));
     mediaValues->m_viewportWidth = m_viewportWidth;
     mediaValues->m_viewportHeight = m_viewportHeight;
     mediaValues->m_deviceWidth = m_deviceWidth;
     mediaValues->m_deviceHeight = m_deviceHeight;
     mediaValues->m_devicePixelRatio = m_devicePixelRatio;
     mediaValues->m_colorBitsPerComponent = m_colorBitsPerComponent;
     mediaValues->m_monochromeBitsPerComponent = m_monochromeBitsPerComponent;
     mediaValues->m_pointer = m_pointer;
     mediaValues->m_defaultFontSize = m_defaultFontSize;
+    mediaValues->m_computedFontSize = m_computedFontSize;
+    mediaValues->m_hasXHeight = m_hasXHeight;
+    mediaValues->m_xHeight = m_xHeight;
+    mediaValues->m_zeroWidth = m_zeroWidth;
     mediaValues->m_threeDEnabled = m_threeDEnabled;
     mediaValues->m_scanMediaType = m_scanMediaType;
     mediaValues->m_screenMediaType = m_screenMediaType;
     mediaValues->m_printMediaType = m_printMediaType;
     mediaValues->m_strictMode = m_strictMode;
+    mediaValues->m_effectiveZoom = m_effectiveZoom;
 
     return mediaValues;
 }
 
 bool MediaValues::isSafeToSendToAnotherThread() const
 {
     return (!m_frame && !m_style && m_mode == CachingMode && hasOneRef());
 }
 
 int MediaValues::viewportWidth() const
@@ skipping 52 matching lines @@
     return m_pointer;
 }
 
 int MediaValues::defaultFontSize() const
 {
     if (m_mode == DynamicMode)
         return calculateDefaultFontSize(m_style.get());
     return m_defaultFontSize;
 }
 
+int MediaValues::computedFontSize() const
+{
+    if (m_mode == DynamicMode)
+        return calculateComputedFontSize(m_style.get());
+    return m_computedFontSize;
+}
+
 bool MediaValues::threeDEnabled() const
 {
     if (m_mode == DynamicMode)
         return calculateThreeDEnabled(m_frame);
     return m_threeDEnabled;
 }
 
 bool MediaValues::scanMediaType() const
 {
     if (m_mode == DynamicMode)
@@ skipping 15 matching lines @@
     return m_printMediaType;
 }
 
 bool MediaValues::strictMode() const
 {
     if (m_mode == DynamicMode)
         return calculateStrictMode(m_frame);
     return m_strictMode;
 }
 
+float MediaValues::effectiveZoom() const
+{
+    if (m_mode == DynamicMode)
+        return calculateEffectiveZoom(m_style.get());
+    return m_effectiveZoom;
+}
+
 Document* MediaValues::document() const
 {
     if (!m_frame)
         return 0;
     return m_frame->document();
 }
 
+float MediaValues::zoom() const
+{
+    return m_effectiveZoom;
+}
+
+bool MediaValues::computingFontSize() const
+{
+    // MediaValues is used to computeLength from the MediaQueryEvaluator with the assumption that fonts are computed
+    return true;
+}
+
+double MediaValues::fontSpecifiedSize() const
+{
+    return m_defaultFontSize;
+}
+
+double MediaValues::fontComputedSize() const
+{
+    return m_computedFontSize;
+
+}
+
+double MediaValues::rootFontSpecifiedSize() const
+{
+    return m_defaultFontSize;
+}
+
+double MediaValues::rootFontComputedSize() const
+{
+    return m_computedFontSize;
+}
+
+bool MediaValues::hasXHeight() const
+{
+    return m_hasXHeight;
+}
+
+double MediaValues::xHeight() const
+{
+    return m_xHeight;
+}
+
+double MediaValues::zeroWidth() const
+{
+    return m_zeroWidth;
+}
+
+bool MediaValues::hasRoot() const
+{
+    // MediaValues is used to computeLength from the MediaQueryEvaluator with the assumption
+    // that root is present (and equal to the initial style)
+    return true;
+}
+
+
+double MediaValues::viewportWidthPercent() const
+{
+    return (double)m_viewportWidth / 100.0;
+}
+
+double MediaValues::viewportHeightPercent() const
+{
+    return (double)m_viewportHeight / 100.0;
+}
+
+double MediaValues::viewportMinPercent() const
+{
+    return (double)(std::min(m_viewportWidth, m_viewportHeight)) / 100.0;
+}
+
+double MediaValues::viewportMaxPercent() const
+{
+    return (double)(std::max(m_viewportWidth, m_viewportHeight)) / 100.0;
+}
+
 } // namespace