[@container] Add placeholder StyleRecalcContext to ElementRuleCollector

We need to propagate container size information down to style
resolution of elements that depend on a container queries.
The StyleRecalcContext class will (eventually) transport that
information.

This CL is the first in a chain of CLs which does the necessary
refactoring to propagate a StyleRecalcContext all the way from
StyleEngine::UpdateStyleAndLayoutTreeForContainer to descendants
ElementRuleCollector instances.

Longer term I expect StyleRecalcContext to also setup/manage the
SelectorFilter (or otherwise merge with that functionality), but this
problem is out of scope at the moment.

Bug: 1145970
Change-Id: Ia30b796e0e95c83e5f04d971a593644ec18bc8eb
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2626433
Commit-Queue: Anders Hartvoll Ruud <andruud@chromium.org>
Reviewed-by: Rune Lillesveen <futhark@chromium.org>
Reviewed-by: Xiaocheng Hu <xiaochengh@chromium.org>
Cr-Commit-Position: refs/heads/master@{#843535}

third_party/blink/renderer/core/css/element_rule_collector.cc

@@ -60,12 +60,15 @@ unsigned AdjustLinkMatchType(EInsideLink inside_link,
 
 }  // namespace
 
-ElementRuleCollector::ElementRuleCollector(const ElementResolveContext& context,
+ElementRuleCollector::ElementRuleCollector(
+    const ElementResolveContext& context,
+    const StyleRecalcContext& style_recalc_context,
     const SelectorFilter& filter,
     MatchResult& result,
     ComputedStyle* style,
     EInsideLink inside_link)
     : context_(context),
+      style_recalc_context_(style_recalc_context),
       selector_filter_(filter),
       style_(style),
       pseudo_style_request_(kPseudoIdNone),

third_party/blink/renderer/core/css/element_rule_collector.h

@@ -30,6 +30,7 @@
 #include "third_party/blink/renderer/core/css/resolver/match_request.h"
 #include "third_party/blink/renderer/core/css/resolver/match_result.h"
 #include "third_party/blink/renderer/core/css/selector_checker.h"
+#include "third_party/blink/renderer/core/css/style_recalc.h"
 #include "third_party/blink/renderer/core/style/computed_style_base_constants.h"
 #include "third_party/blink/renderer/platform/wtf/ref_counted.h"
 #include "third_party/blink/renderer/platform/wtf/vector.h"
@@ -99,6 +100,7 @@ class CORE_EXPORT ElementRuleCollector {
 
  public:
   ElementRuleCollector(const ElementResolveContext&,
+                       const StyleRecalcContext&,
                        const SelectorFilter&,
                        MatchResult&,
                        ComputedStyle*,
@@ -177,6 +179,7 @@ class CORE_EXPORT ElementRuleCollector {
 
  private:
   const ElementResolveContext& context_;
+  StyleRecalcContext style_recalc_context_;
   const SelectorFilter& selector_filter_;
   scoped_refptr<ComputedStyle>
       style_;  // FIXME: This can be mutated during matching!

third_party/blink/renderer/core/css/element_rule_collector_test.cc

@@ -39,8 +39,8 @@ class ElementRuleCollectorTest : public PageTestBase {
     SelectorFilter filter;
     MatchResult result;
     auto style = ComputedStyle::Create();
-    ElementRuleCollector collector(context, filter, result, style.get(),
-                                   InsideLink(element));
+    ElementRuleCollector collector(context, StyleRecalcContext(), filter,
+                                   result, style.get(), InsideLink(element));
 
     String rule = selector + " { color: green }";
     auto* style_rule =

third_party/blink/renderer/core/css/resolver/style_resolver.cc

@@ -851,9 +851,11 @@ void StyleResolver::ApplyBaseStyle(
           DocumentElementUserAgentDeclarations());
     }
 
-    ElementRuleCollector collector(state.ElementContext(), selector_filter_,
-                                   match_result, state.Style(),
-                                   state.Style()->InsideLink());
+    // TODO(crbug.com/1145970): Use actual StyleRecalcContext.
+    StyleRecalcContext style_recalc_context;
+    ElementRuleCollector collector(state.ElementContext(), style_recalc_context,
+                                   selector_filter_, match_result,
+                                   state.Style(), state.Style()->InsideLink());
 
     MatchAllRules(state, collector,
                   matching_behavior != kMatchAllRulesExcludingSMIL);
@@ -972,8 +974,11 @@ scoped_refptr<ComputedStyle> StyleResolver::PseudoStyleForElement(
     }
     state.Style()->SetStyleType(pseudo_style_request.pseudo_id);
 
+    // TODO(crbug.com/1145970): Use actual StyleRecalcContext.
+    StyleRecalcContext style_recalc_context;
     // Check UA, user and author rules.
-    ElementRuleCollector collector(state.ElementContext(), selector_filter_,
+    ElementRuleCollector collector(state.ElementContext(), style_recalc_context,
+                                   selector_filter_,
                                    cascade.MutableMatchResult(), state.Style(),
                                    state.Style()->InsideLink());
     collector.SetPseudoElementStyleRequest(pseudo_style_request);
@@ -1138,8 +1143,10 @@ StyleRuleList* StyleResolver::StyleRulesForElement(Element* element,
   DCHECK(element);
   StyleResolverState state(GetDocument(), *element);
   MatchResult match_result;
-  ElementRuleCollector collector(state.ElementContext(), selector_filter_,
-                                 match_result, state.Style(),
+  // TODO(crbug.com/1145970): Use actual StyleRecalcContext.
+  StyleRecalcContext style_recalc_context;
+  ElementRuleCollector collector(state.ElementContext(), style_recalc_context,
+                                 selector_filter_, match_result, state.Style(),
                                  EInsideLink::kNotInsideLink);
   collector.SetMode(SelectorChecker::kCollectingStyleRules);
   CollectPseudoRulesForElement(*element, collector, kPseudoIdNone,
@@ -1153,9 +1160,11 @@ StyleResolver::CascadedValuesForElement(Element* element, PseudoId pseudo_id) {
   state.SetStyle(ComputedStyle::Create());
 
   STACK_UNINITIALIZED StyleCascade cascade(state);
-  ElementRuleCollector collector(state.ElementContext(), selector_filter_,
-                                 cascade.MutableMatchResult(), state.Style(),
-                                 EInsideLink::kNotInsideLink);
+  // TODO(crbug.com/1145970): Use actual StyleRecalcContext.
+  StyleRecalcContext style_recalc_context;
+  ElementRuleCollector collector(state.ElementContext(), style_recalc_context,
+                                 selector_filter_, cascade.MutableMatchResult(),
+                                 state.Style(), EInsideLink::kNotInsideLink);
   collector.SetPseudoElementStyleRequest(PseudoElementStyleRequest(pseudo_id));
   MatchAllRules(state, collector, false /* include_smil_properties */);
 
@@ -1170,8 +1179,10 @@ RuleIndexList* StyleResolver::PseudoCSSRulesForElement(
   DCHECK(element);
   StyleResolverState state(GetDocument(), *element);
   MatchResult match_result;
-  ElementRuleCollector collector(state.ElementContext(), selector_filter_,
-                                 match_result, state.Style(),
+  // TODO(crbug.com/1145970): Use actual StyleRecalcContext.
+  StyleRecalcContext style_recalc_context;
+  ElementRuleCollector collector(state.ElementContext(), style_recalc_context,
+                                 selector_filter_, match_result, state.Style(),
                                  EInsideLink::kNotInsideLink);
   collector.SetMode(SelectorChecker::kCollectingCSSRules);
   // TODO(obrufau): support collecting rules for nested ::marker
@@ -1587,9 +1598,11 @@ void StyleResolver::ApplyCallbackSelectors(StyleResolverState& state) {
   if (!watched_selectors_rule_set)
     return;
 
+  // TODO(crbug.com/1145970): Use actual StyleRecalcContext.
+  StyleRecalcContext style_recalc_context;
   MatchResult match_result;
-  ElementRuleCollector collector(state.ElementContext(), selector_filter_,
-                                 match_result, state.Style(),
+  ElementRuleCollector collector(state.ElementContext(), style_recalc_context,
+                                 selector_filter_, match_result, state.Style(),
                                  state.Style()->InsideLink());
   collector.SetMode(SelectorChecker::kCollectingStyleRules);
   collector.SetIncludeEmptyRules(true);

third_party/blink/renderer/core/css/resolver/style_resolver_test.cc

@@ -956,8 +956,9 @@ TEST_F(StyleResolverTest, TreeScopedReferences) {
     StyleResolverState state(GetDocument(), *host);
     SelectorFilter filter;
     MatchResult match_result;
-    ElementRuleCollector collector(state.ElementContext(), filter, match_result,
-                                   state.Style(), EInsideLink::kNotInsideLink);
+    ElementRuleCollector collector(state.ElementContext(), StyleRecalcContext(),
+                                   filter, match_result, state.Style(),
+                                   EInsideLink::kNotInsideLink);
     GetDocument().GetStyleEngine().GetStyleResolver().MatchAllRules(
         state, collector, false /* include_smil_properties */);
     const auto& properties = match_result.GetMatchedProperties();
@@ -982,8 +983,9 @@ TEST_F(StyleResolverTest, TreeScopedReferences) {
     StyleResolverState state(GetDocument(), *span);
     SelectorFilter filter;
     MatchResult match_result;
-    ElementRuleCollector collector(state.ElementContext(), filter, match_result,
-                                   state.Style(), EInsideLink::kNotInsideLink);
+    ElementRuleCollector collector(state.ElementContext(), StyleRecalcContext(),
+                                   filter, match_result, state.Style(),
+                                   EInsideLink::kNotInsideLink);
     GetDocument().GetStyleEngine().GetStyleResolver().MatchAllRules(
         state, collector, false /* include_smil_properties */);
     const auto& properties = match_result.GetMatchedProperties();

third_party/blink/renderer/core/css/style_recalc.h

@@ -5,6 +5,8 @@
 #ifndef THIRD_PARTY_BLINK_RENDERER_CORE_CSS_STYLE_RECALC_H_
 #define THIRD_PARTY_BLINK_RENDERER_CORE_CSS_STYLE_RECALC_H_
 
+#include "third_party/blink/renderer/platform/wtf/allocator/allocator.h"
+
 namespace blink {
 
 class Element;
@@ -96,6 +98,17 @@ class StyleRecalcChange {
   bool recalc_container_query_dependent_ = false;
 };
 
+// StyleRecalcContext is an object that is passed on the stack during
+// the style recalc process.
+//
+// In the future, it will contain data which makes it possible to
+// evaluate Container Queries, but for now it's an empty placeholder.
+//
+// TODO(crbug.com/1145970): Populate this class.
+class StyleRecalcContext {
+  STACK_ALLOCATED();
+};
+
 }  // namespace blink
 
 #endif  // THIRD_PARTY_BLINK_RENDERER_CORE_CSS_STYLE_RECALC_H_