Move MediaQueryResults to RuleFeatureSet.

third_party/WebKit/Source/core/css/resolver/ScopedStyleResolver.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc.
  * All rights reserved.
  * Copyright (C) 2012 Google Inc. 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
@@ skipping 65 matching lines @@
       ruleSet.fontFaceRules();
   for (auto& fontFaceRule : fontFaceRules) {
     if (FontFace* fontFace = FontFace::create(&document, fontFaceRule))
       cssFontSelector->fontFaceCache()->add(cssFontSelector, fontFaceRule,
                                             fontFace);
   }
   if (fontFaceRules.size())
     document.styleResolver()->invalidateMatchedPropertiesCache();
 }
 
-void ScopedStyleResolver::appendCSSStyleSheet(
-    CSSStyleSheet& cssSheet,
-    const MediaQueryEvaluator& medium) {
+void ScopedStyleResolver::appendCSSStyleSheet(CSSStyleSheet& cssSheet) {
+  RuleSet* ruleSet =
+      treeScope().document().styleEngine().ruleSetForSheet(cssSheet);
+
+  m_viewportDependentMediaQueryResults.appendVector(
+      cssSheet.viewportDependentMediaQueryResults());
+  m_deviceDependentMediaQueryResults.appendVector(
+      cssSheet.deviceDependentMediaQueryResults());
+  if (!ruleSet)
+    return;
+
   unsigned index = m_authorStyleSheets.size();
   m_authorStyleSheets.append(&cssSheet);
-  StyleSheetContents* sheet = cssSheet.contents();
-  AddRuleFlags addRuleFlags =
-      treeScope().document().getSecurityOrigin()->canRequest(sheet->baseURL())
-          ? RuleHasDocumentSecurityOrigin
-          : RuleHasNoSpecialState;
-  const RuleSet& ruleSet = sheet->ensureRuleSet(medium, addRuleFlags);
-
-  addKeyframeRules(ruleSet);
-  addFontFaceRules(ruleSet);
-  addTreeBoundaryCrossingRules(ruleSet, &cssSheet, index);
-  treeScope().document().styleResolver()->addViewportDependentMediaQueries(
-      ruleSet.viewportDependentMediaQueryResults());
-  treeScope().document().styleResolver()->addDeviceDependentMediaQueries(
-      ruleSet.deviceDependentMediaQueryResults());
+  addKeyframeRules(*ruleSet);
+  addFontFaceRules(*ruleSet);
+  addTreeBoundaryCrossingRules(*ruleSet, &cssSheet, index);
 }
 
 void ScopedStyleResolver::appendActiveStyleSheets(
     unsigned index,
     const ActiveStyleSheetVector& activeSheets) {
   for (auto activeIterator = activeSheets.begin() + index;
        activeIterator != activeSheets.end(); activeIterator++) {
     CSSStyleSheet* sheet = activeIterator->first;
+    m_viewportDependentMediaQueryResults.appendVector(
+        sheet->viewportDependentMediaQueryResults());
+    m_deviceDependentMediaQueryResults.appendVector(
+        sheet->deviceDependentMediaQueryResults());
     if (!activeIterator->second)
       continue;
     const RuleSet& ruleSet = *activeIterator->second;
     m_authorStyleSheets.append(sheet);
     addKeyframeRules(ruleSet);
     addFontFaceRules(ruleSet);
     addTreeBoundaryCrossingRules(ruleSet, sheet, index++);
   }
 }
 
 void ScopedStyleResolver::collectFeaturesTo(
     RuleFeatureSet& features,
     HeapHashSet<Member<const StyleSheetContents>>&
         visitedSharedStyleSheetContents) const {
+  features.viewportDependentMediaQueryResults().appendVector(
+      m_viewportDependentMediaQueryResults);
+  features.deviceDependentMediaQueryResults().appendVector(
+      m_deviceDependentMediaQueryResults);
+
   for (size_t i = 0; i < m_authorStyleSheets.size(); ++i) {
     ASSERT(m_authorStyleSheets[i]->ownerNode());
     StyleSheetContents* contents = m_authorStyleSheets[i]->contents();
     if (contents->hasOneClient() ||
         visitedSharedStyleSheetContents.add(contents).isNewEntry)
       features.add(contents->ruleSet().features());
   }
 
   if (!m_treeBoundaryCrossingRuleSet)
     return;
 
   for (const auto& rules : *m_treeBoundaryCrossingRuleSet)
     features.add(rules->m_ruleSet->features());
 }
 
 void ScopedStyleResolver::resetAuthorStyle() {
   m_authorStyleSheets.clear();
+  m_viewportDependentMediaQueryResults.clear();
+  m_deviceDependentMediaQueryResults.clear();
   m_keyframesRuleMap.clear();
   m_treeBoundaryCrossingRuleSet = nullptr;
   m_hasDeepOrShadowSelector = false;
 }
 
 StyleRuleKeyframes* ScopedStyleResolver::keyframeStylesForAnimation(
     const StringImpl* animationName) {
   if (m_keyframesRuleMap.isEmpty())
     return nullptr;
 
@@ skipping 101 matching lines @@
   // Only consider the global author RuleSet for @page rules, as per the HTML5
   // spec.
   ASSERT(m_scope->rootNode().isDocumentNode());
   for (size_t i = 0; i < m_authorStyleSheets.size(); ++i)
     collector.matchPageRules(&m_authorStyleSheets[i]->contents()->ruleSet());
 }
 
 DEFINE_TRACE(ScopedStyleResolver) {
   visitor->trace(m_scope);
   visitor->trace(m_authorStyleSheets);
+  visitor->trace(m_viewportDependentMediaQueryResults);
+  visitor->trace(m_deviceDependentMediaQueryResults);
   visitor->trace(m_keyframesRuleMap);
   visitor->trace(m_treeBoundaryCrossingRuleSet);
 }
 
 static void addRules(RuleSet* ruleSet,
                      const HeapVector<MinimalRuleData>& rules) {
   for (unsigned i = 0; i < rules.size(); ++i) {
     const MinimalRuleData& info = rules[i];
     ruleSet->addRule(info.m_rule, info.m_selectorIndex, info.m_flags);
   }
@@ skipping 29 matching lines @@
   m_treeBoundaryCrossingRuleSet->append(
       RuleSubSet::create(parentStyleSheet, sheetIndex, ruleSetForScope));
 }
 
 DEFINE_TRACE(ScopedStyleResolver::RuleSubSet) {
   visitor->trace(m_parentStyleSheet);
   visitor->trace(m_ruleSet);
 }
 
 }  // namespace blink