Remove MediaValues' dependency on RenderStyle

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/css/CSSHelper.h"
 #include "core/css/MediaValuesCached.h"
 #include "core/css/MediaValuesDynamic.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/html/imports/HTMLImportsController.h"
 #include "core/page/Page.h"
 #include "core/rendering/RenderObject.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/compositing/RenderLayerCompositor.h"
 #include "core/rendering/style/RenderStyle.h"
 #include "platform/PlatformScreen.h"
 
 namespace WebCore {
 
 Document* MediaValues::getExecutingDocument(Document& document)
 {
     Document* executingDocument = document.importsController() ? document.importsController()->master() : &document;
     ASSERT(executingDocument);
-    ASSERT(executingDocument->renderer());
     return executingDocument;
 }
 
 int MediaValues::calculateViewportWidth(LocalFrame* frame) const
 {
     ASSERT(frame && frame->view() && frame->document());
     int viewportWidth = frame->view()->layoutSize(IncludeScrollbars).width();
     return adjustForAbsoluteZoom(viewportWidth, frame->document()->renderView());
 }
 
@@ skipping 42 matching lines @@
 }
 
 int MediaValues::calculateMonochromeBitsPerComponent(LocalFrame* frame) const
 {
     ASSERT(frame && frame->page() && frame->page()->mainFrame());
     if (screenIsMonochrome(frame->page()->mainFrame()->view()))
         return screenDepthPerComponent(frame->view());
     return 0;
 }
 
-int MediaValues::calculateDefaultFontSize(RenderStyle* style) const
+int MediaValues::calculateDefaultFontSize(LocalFrame* frame) const
 {
-    return style->fontDescription().specifiedSize();
-}
-
-int MediaValues::calculateComputedFontSize(RenderStyle* style) const
-{
-    return style->fontDescription().computedSize();
+    return frame->host()->settings().defaultFontSize();
 }
 
 bool MediaValues::calculateScanMediaType(LocalFrame* frame) const
 {
     ASSERT(frame && frame->view());
     // Scan only applies to 'tv' media.
     return equalIgnoringCase(frame->view()->mediaType(), "tv");
 }
 
 bool MediaValues::calculateScreenMediaType(LocalFrame* frame) const
@@ skipping 26 matching lines @@
     // 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;
 }
 
+bool MediaValues::computeLength(double value, unsigned short type, unsigned defaultFontSize, unsigned viewportWidth, unsigned viewportHeight, int& result)
+{
+    // We're running in a background thread, so RenderStyle is not available.

[eseidel, 2014/04/18 16:50:13]

Why is this in MediaValues?  MediaValues could be dynamic and thus not be on a
background thread?

+    // Nevertheless, we can evaluate lengths using cached values.
+    //
+    // The logic in this function is duplicated from CSSPrimitiveValue::computeLengthDouble
+    // because MediaValues::computeLength needs nearly identical logic, but we haven't found a way to make
+    // CSSPrimitiveValue::computeLengthDouble more generic (to solve both cases) without hurting performance.
+
+    // FIXME - Unite the logic here with CSSPrimitiveValue in a performant way.
+    int factor = 0;
+    switch (type) {
+    case CSSPrimitiveValue::CSS_EMS:
+    case CSSPrimitiveValue::CSS_REMS:
+        factor = 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.
+        // FIXME: We don't seem to be able to cache fontMetrics related values.
+        // Trying to access them is triggering some sort of microtask. Serving the spec's default instead.
+        factor = defaultFontSize / 2.0;
+        break;
+    case CSSPrimitiveValue::CSS_CHS:
+        // FIXME: We don't seem to be able to cache fontMetrics related values.
+        // Trying to access them is triggering some sort of microtask. Serving the (future) spec default instead.
+        factor = defaultFontSize / 2.0;
+        break;
+    case CSSPrimitiveValue::CSS_VW:
+        factor = viewportWidth / 100;
+        break;
+    case CSSPrimitiveValue::CSS_VH:
+        factor = viewportHeight / 100;
+        break;
+    case CSSPrimitiveValue::CSS_VMIN:
+        factor = std::min(viewportWidth, viewportHeight) / 100;
+        break;
+    case CSSPrimitiveValue::CSS_VMAX:
+        factor = std::max(viewportWidth, 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;
+}
+
 } // namespace