Translate viewport related meta tags into @viewport descriptors as suggested by the CSS Device Adap…

Source/core/css/resolver/ViewportStyleResolver.cpp

 /*
  * Copyright (C) 2012-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:
  *
  * 1. Redistributions of source code must retain the above
  *    copyright notice, this list of conditions and the following
  *    disclaimer.
@@ skipping 18 matching lines @@
 
 #include "config.h"
 #include "core/css/resolver/ViewportStyleResolver.h"
 
 #include "CSSValueKeywords.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/StyleRule.h"
 #include "core/dom/Document.h"
 #include "core/dom/NodeRenderStyle.h"
 #include "core/dom/ViewportArguments.h"
+#include "wtf/dtoa/utils.h"
 
 namespace WebCore {
 
 ViewportStyleResolver::ViewportStyleResolver(Document* document)
     : m_document(document)
+    , m_maxPriority(0)
 {
     ASSERT(m_document);
 }
 
 ViewportStyleResolver::~ViewportStyleResolver()
 {
 }
 
 void ViewportStyleResolver::addViewportRule(StyleRuleViewport* viewportRule)
 {
     StylePropertySet* propertySet = viewportRule->mutableProperties();
 
     unsigned propertyCount = propertySet->propertyCount();
     if (!propertyCount)
         return;
 
-    if (!m_propertySet) {
+    // Rules derived from legacy meta tags are only applied if no author @viewport rule
+    // precedes it, with the exception of viewport meta which is considered an actual
+    // @viewport rule according to the spec. They also have individual priority as defined
+    // below.
+    //
+    // 1) UA stylesheet is always applied first (min priority)
+    // 2) XHTML Mobile Profile (priority 1)
+    // 3) handheldfriendly meta tag (priority 2)
+    // 4) mobileoptimized meta tag (priority 3)
+    // 5) viewport meta tag and any author style sheet (max priority).
+
+    RefPtr<CSSValue> value = propertySet->getPropertyCSSValue(CSSPropertyInternalPriority);
+    float priority = (value && value->isPrimitiveValue()) ? toCSSPrimitiveValue(value.get())->getFloatValue() : std::numeric_limits<float>::max();
+
+    if (priority < m_maxPriority)
+        return;
+    m_maxPriority = priority;
+
+    if (m_propertySet) {
+        // We cannot use mergeAndOverrideOnConflict() here because it doesn't
+        // respect the !important declaration (but addParsedProperty() does).
+        for (unsigned i = 0; i < propertyCount; ++i)
+            m_propertySet->addParsedProperty(propertySet->propertyAt(i).toCSSProperty());
+    } else {
         m_propertySet = propertySet->mutableCopy();
-        return;
     }
+}
 
-    // We cannot use mergeAndOverrideOnConflict() here because it doesn't
-    // respect the !important declaration (but addParsedProperty() does).
-    for (unsigned i = 0; i < propertyCount; ++i)
-        m_propertySet->addParsedProperty(propertySet->propertyAt(i).toCSSProperty());
+bool ViewportStyleResolver::shouldDisableDesktopWorkarounds() const

[rune, 2013/08/28 23:30:14]

I have tried to split this out as a separate change where I work on the
constrained values in WebViewImpl instead:

https://codereview.chromium.org/23592015/

+{
+    if (!m_propertySet)
+        return false;
+
+    RefPtr<CSSValue> value;
+
+    // Check is zoomable.
+    if (!getViewportArgumentValue(CSSPropertyUserZoom))
+        return true;
+
+    float minZoom = getViewportArgumentValue(CSSPropertyMinZoom);
+    float maxZoom = getViewportArgumentValue(CSSPropertyMaxZoom);
+    if (minZoom == maxZoom && minZoom == ViewportArguments::ValueAuto)

[rune, 2013/08/28 23:30:14]

Should have been "minZoom != ViewportArguments::ValueAuto".

+        return true;
+
+    // Check whether 100% of viewport (device-width etc.)
+    value = m_propertySet->getPropertyCSSValue(CSSPropertyMaxWidth);
+    if (!value || !value->isPrimitiveValue())
+        return false;
+
+    CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value.get());
+    return primitiveValue->isPercentage() && primitiveValue->getFloatValue() == 100.0f;
 }
 
 void ViewportStyleResolver::clearDocument()
 {
     m_document = 0;
 }
 
 void ViewportStyleResolver::resolve()
 {
     if (!m_document || !m_propertySet)
         return;
 
-    ViewportArguments arguments(ViewportArguments::CSSDeviceAdaptation);
+    ViewportArguments arguments;
 
     arguments.userZoom = getViewportArgumentValue(CSSPropertyUserZoom);
     arguments.zoom = getViewportArgumentValue(CSSPropertyZoom);
     arguments.minZoom = getViewportArgumentValue(CSSPropertyMinZoom);
     arguments.maxZoom = getViewportArgumentValue(CSSPropertyMaxZoom);
     arguments.minWidth = getViewportArgumentValue(CSSPropertyMinWidth);
     arguments.maxWidth = getViewportArgumentValue(CSSPropertyMaxWidth);
     arguments.minHeight = getViewportArgumentValue(CSSPropertyMinHeight);
     arguments.maxHeight = getViewportArgumentValue(CSSPropertyMaxHeight);
     arguments.orientation = getViewportArgumentValue(CSSPropertyOrientation);
 
+    // Deprecated values:
+    arguments.deprecatedTargetDensityDPI = getViewportArgumentValue(CSSPropertyInternalTargetDensity);
+
     m_document->setViewportArguments(arguments);
     m_document->updateViewportArguments();
-
-    m_propertySet = 0;

[rune, 2013/08/21 09:18:22]

I can't see where the property set is reset between cascades with this removal.

 }
 
 float ViewportStyleResolver::getViewportArgumentValue(CSSPropertyID id) const
 {
     float defaultValue = ViewportArguments::ValueAuto;
 
     // UserZoom default value is CSSValueZoom, which maps to true, meaning that
     // yes, it is user scalable. When the value is set to CSSValueFixed, we
     // return false.
     if (id == CSSPropertyUserZoom)
@@ skipping 34 matching lines @@
     case CSSValueAuto:
         return defaultValue;
     case CSSValueLandscape:
         return ViewportArguments::ValueLandscape;
     case CSSValuePortrait:
         return ViewportArguments::ValuePortrait;
     case CSSValueZoom:
         return defaultValue;
     case CSSValueInternalExtendToZoom:
         return ViewportArguments::ValueExtendToZoom;
+    case CSSValueDevice:
+        return ViewportArguments::ValueDeviceDPI;
+    case CSSValueSmall:
+        return ViewportArguments::ValueLowDPI;
+    case CSSValueMedium:
+        return ViewportArguments::ValueMediumDPI;
+    case CSSValueLarge:
+        return ViewportArguments::ValueHighDPI;
     case CSSValueFixed:
         return 0;
     default:
         return defaultValue;
     }
 }
 
 } // namespace WebCore