Separate @viewport from other RuleSet construction.

third_party/WebKit/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 14 matching lines @@
  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
  * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
 #include "core/css/resolver/ViewportStyleResolver.h"
 
 #include "core/CSSValueKeywords.h"
 #include "core/css/CSSDefaultStyleSheets.h"
 #include "core/css/CSSPrimitiveValueMappings.h"
+#include "core/css/CSSStyleSheet.h"
 #include "core/css/CSSToLengthConversionData.h"
+#include "core/css/MediaValuesDynamic.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/StyleRule.h"
-#include "core/css/resolver/ScopedStyleResolver.h"
+#include "core/css/StyleSheetContents.h"
 #include "core/dom/Document.h"
 #include "core/dom/NodeComputedStyle.h"
 #include "core/dom/ViewportDescription.h"
 #include "core/frame/Settings.h"
 #include "core/layout/api/LayoutViewItem.h"
 
 namespace blink {
 
 ViewportStyleResolver::ViewportStyleResolver(Document* document)
-    : m_document(document), m_hasAuthorStyle(false) {
-  ASSERT(m_document);
+    : m_document(document) {
+  DCHECK(m_document);
+  DCHECK(m_document->frame());
+  // TODO(rune@opera.com): The MediaValues object passed here should reflect the
+  // initial viewport, not the actual viewport. See https://crbug.com/332763
+  m_initialViewportMedium =
+      new MediaQueryEvaluator(MediaValuesDynamic::create(m_document->frame()));
 }
 
-void ViewportStyleResolver::collectViewportRules() {
+void ViewportStyleResolver::reset() {
+  m_viewportDependentMediaQueryResults.clear();
+  m_deviceDependentMediaQueryResults.clear();
+  m_propertySet = nullptr;
+  m_hasAuthorStyle = false;
+  m_hasViewportUnits = false;
+}
+
+void ViewportStyleResolver::collectViewportRulesFromUASheets() {
   CSSDefaultStyleSheets& defaultStyleSheets = CSSDefaultStyleSheets::instance();
-  collectViewportRules(defaultStyleSheets.defaultStyle(), UserAgentOrigin);
 
   WebViewportStyle viewportStyle = m_document->settings()
                                        ? m_document->settings()->viewportStyle()
                                        : WebViewportStyle::Default;
-  RuleSet* viewportRules = nullptr;
+  StyleSheetContents* viewportContents = nullptr;
   switch (viewportStyle) {
     case WebViewportStyle::Default:
       break;
     case WebViewportStyle::Mobile:
-      viewportRules = defaultStyleSheets.defaultMobileViewportStyle();
+      viewportContents = defaultStyleSheets.ensureMobileViewportStyleSheet();
       break;
     case WebViewportStyle::Television:
-      viewportRules = defaultStyleSheets.defaultTelevisionViewportStyle();
+      viewportContents =
+          defaultStyleSheets.ensureTelevisionViewportStyleSheet();
       break;
   }
-  if (viewportRules)
-    collectViewportRules(viewportRules, UserAgentOrigin);
-
-  if (m_document->isMobileDocument())
-    collectViewportRules(defaultStyleSheets.defaultXHTMLMobileProfileStyle(),
-                         UserAgentOrigin);
-
-  if (ScopedStyleResolver* scopedResolver = m_document->scopedStyleResolver())
-    scopedResolver->collectViewportRulesTo(this);
-
-  resolve();
+  if (viewportContents)
+    collectViewportChildRules(viewportContents->childRules(), UserAgentOrigin);
+  if (m_document->isMobileDocument()) {
+    collectViewportChildRules(
+        defaultStyleSheets.ensureXHTMLMobileProfileStyleSheet()->childRules(),
+        UserAgentOrigin);
+  }
 }
 
-void ViewportStyleResolver::collectViewportRules(RuleSet* rules,
-                                                 Origin origin) {
-  rules->compactRulesIfNeeded();
-
-  const HeapVector<Member<StyleRuleViewport>>& viewportRules =
-      rules->viewportRules();
-  for (size_t i = 0; i < viewportRules.size(); ++i)
-    addViewportRule(viewportRules[i], origin);
+void ViewportStyleResolver::collectViewportRulesFromAuthorSheet(
+    const CSSStyleSheet& sheet) {
+  if (!sheet.contents()->hasViewportRule())
+    return;
+  if (sheet.mediaQueries() &&
+      !m_initialViewportMedium->eval(sheet.mediaQueries(),
+                                     &m_viewportDependentMediaQueryResults))
+    return;
+  collectViewportChildRules(sheet.contents()->childRules(), AuthorOrigin);
 }
 
-void ViewportStyleResolver::addViewportRule(StyleRuleViewport* viewportRule,
+void ViewportStyleResolver::collectViewportChildRules(
+    const HeapVector<Member<StyleRuleBase>>& rules,
+    Origin origin) {
+  for (auto& rule : rules) {
+    if (rule->isViewportRule())
+      addViewportRule(*toStyleRuleViewport(rule), origin);
+    if (!rule->isMediaRule())
+      continue;
+    StyleRuleMedia* mediaRule = toStyleRuleMedia(rule);
+    if (!mediaRule->mediaQueries() ||
+        m_initialViewportMedium->eval(mediaRule->mediaQueries(),
+                                      &m_viewportDependentMediaQueryResults))
+      collectViewportChildRules(mediaRule->childRules(), origin);
+  }
+}
+
+void ViewportStyleResolver::addViewportRule(StyleRuleViewport& viewportRule,
                                             Origin origin) {
-  StylePropertySet& propertySet = viewportRule->mutableProperties();
+  StylePropertySet& propertySet = viewportRule.mutableProperties();
 
   unsigned propertyCount = propertySet.propertyCount();
   if (!propertyCount)
     return;
 
   if (origin == AuthorOrigin)
     m_hasAuthorStyle = true;
 
   if (!m_propertySet) {
     m_propertySet = propertySet.mutableCopy();
@@ skipping 22 matching lines @@
   description.zoom = viewportArgumentValue(CSSPropertyZoom);
   description.minZoom = viewportArgumentValue(CSSPropertyMinZoom);
   description.maxZoom = viewportArgumentValue(CSSPropertyMaxZoom);
   description.minWidth = viewportLengthValue(CSSPropertyMinWidth);
   description.maxWidth = viewportLengthValue(CSSPropertyMaxWidth);
   description.minHeight = viewportLengthValue(CSSPropertyMinHeight);
   description.maxHeight = viewportLengthValue(CSSPropertyMaxHeight);
   description.orientation = viewportArgumentValue(CSSPropertyOrientation);
 
   m_document->setViewportDescription(description);
-
-  m_propertySet = nullptr;
-  m_hasAuthorStyle = false;
 }
 
 float ViewportStyleResolver::viewportArgumentValue(CSSPropertyID id) const {
   float defaultValue = ViewportDescription::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)
     defaultValue = 1;
@@ skipping 40 matching lines @@
       default:
         NOTREACHED();
         break;
     }
   }
 
   NOTREACHED();
   return defaultValue;
 }
 
-Length ViewportStyleResolver::viewportLengthValue(CSSPropertyID id) const {
+Length ViewportStyleResolver::viewportLengthValue(CSSPropertyID id) {
   ASSERT(id == CSSPropertyMaxHeight || id == CSSPropertyMinHeight ||
          id == CSSPropertyMaxWidth || id == CSSPropertyMinWidth);
 
   const CSSValue* value = m_propertySet->getPropertyCSSValue(id);
   if (!value || !(value->isPrimitiveValue() || value->isIdentifierValue()))
     return Length();  // auto
 
   if (value->isIdentifierValue()) {
     CSSValueID valueID = toCSSIdentifierValue(value)->getValueID();
     if (valueID == CSSValueInternalExtendToZoom)
@@ skipping 10 matching lines @@
   bool documentStyleHasViewportUnits = documentStyle->hasViewportUnits();
   documentStyle->setHasViewportUnits(false);
 
   CSSToLengthConversionData::FontSizes fontSizes(documentStyle, documentStyle);
   CSSToLengthConversionData::ViewportSize viewportSize(
       m_document->layoutViewItem());
 
   Length result = primitiveValue->convertToLength(
       CSSToLengthConversionData(documentStyle, fontSizes, viewportSize, 1.0f));
   if (documentStyle->hasViewportUnits())
-    m_document->setHasViewportUnits();
+    m_hasViewportUnits = true;
   documentStyle->setHasViewportUnits(documentStyleHasViewportUnits);
 
   return result;
 }
 
+bool ViewportStyleResolver::isAffectedByInitialViewportChange() {
+  if (m_hasViewportUnits)
+    return true;
+  auto& results = m_viewportDependentMediaQueryResults;
+  for (unsigned i = 0; i < results.size(); i++) {
+    if (m_initialViewportMedium->eval(results[i]->expression()) !=
+        results[i]->result())
+      return true;
+  }
+  return false;
+}
+
 DEFINE_TRACE(ViewportStyleResolver) {
+  visitor->trace(m_document);
   visitor->trace(m_propertySet);
-  visitor->trace(m_document);
+  visitor->trace(m_initialViewportMedium);
+  visitor->trace(m_viewportDependentMediaQueryResults);
+  visitor->trace(m_deviceDependentMediaQueryResults);
 }
 
 }  // namespace blink