Allocate CSSGlobalRuleSet on heap.

third_party/WebKit/Source/core/dom/StyleEngine.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2011, 2012 Apple Inc. All
  * rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
  * (http://www.torchmobile.com/)
  * Copyright (C) 2008, 2009, 2011, 2012 Google Inc. All rights reserved.
@@ skipping 60 matching lines @@
           this,
           DocumentStyleSheetCollection::Create(document)) {
   if (document.GetFrame()) {
     // We don't need to create CSSFontSelector for imported document or
     // HTMLTemplateElement's document, because those documents have no frame.
     font_selector_ = CSSFontSelector::Create(&document);
     font_selector_->RegisterForInvalidationCallbacks(this);
   }
   if (document.IsInMainFrame())
     viewport_resolver_ = ViewportStyleResolver::Create(document);
+  if (IsMaster())
+    global_rule_set_ = CSSGlobalRuleSet::Create();
 }
 
 StyleEngine::~StyleEngine() {}
 
 inline Document* StyleEngine::Master() {
   if (IsMaster())
     return document_;
   HTMLImportsController* import = GetDocument().ImportsController();
   // Document::import() can return null while executing its destructor.
   if (!import)
@@ skipping 154 matching lines @@
     SetNeedsActiveStyleUpdate(node.GetTreeScope());
 }
 
 void StyleEngine::MediaQueriesChangedInScope(TreeScope& tree_scope) {
   if (ScopedStyleResolver* resolver = tree_scope.GetScopedStyleResolver())
     resolver->SetNeedsAppendAllSheets();
   SetNeedsActiveStyleUpdate(tree_scope);
 }
 
 void StyleEngine::WatchedSelectorsChanged() {
-  global_rule_set_.InitWatchedSelectorsRuleSet(GetDocument());
+  DCHECK(IsMaster());
+  DCHECK(global_rule_set_);
+  global_rule_set_->InitWatchedSelectorsRuleSet(GetDocument());
   // TODO(rune@opera.com): Should be able to use RuleSetInvalidation here.
   GetDocument().SetNeedsStyleRecalc(
       kSubtreeStyleChange, StyleChangeReasonForTracing::Create(
                                StyleChangeReason::kDeclarativeContent));
 }
 
 bool StyleEngine::ShouldUpdateDocumentStyleSheetCollection() const {
   return all_tree_scopes_dirty_ || document_scope_dirty_;
 }
 
@@ skipping 84 matching lines @@
   tree_scopes_removed_ = false;
 }
 
 void StyleEngine::UpdateViewport() {
   if (viewport_resolver_)
     viewport_resolver_->UpdateViewport(GetDocumentStyleSheetCollection());
 }
 
 bool StyleEngine::NeedsActiveStyleUpdate() const {
   return (viewport_resolver_ && viewport_resolver_->NeedsUpdate()) ||
-         NeedsActiveStyleSheetUpdate() || global_rule_set_.IsDirty();
+         NeedsActiveStyleSheetUpdate() ||
+         (global_rule_set_ && global_rule_set_->IsDirty());
 }
 
 void StyleEngine::UpdateActiveStyle() {
   DCHECK(GetDocument().IsActive());
   UpdateViewport();
   UpdateActiveStyleSheets();
   UpdateGlobalRuleSet();
 }
 
 const ActiveStyleSheetVector StyleEngine::ActiveStyleSheetsForInspector() {
@@ skipping 31 matching lines @@
   tree_boundary_crossing_scopes_.Add(&tree_scope.RootNode());
 }
 
 void StyleEngine::ResetAuthorStyle(TreeScope& tree_scope) {
   tree_boundary_crossing_scopes_.Remove(&tree_scope.RootNode());
 
   ScopedStyleResolver* scoped_resolver = tree_scope.GetScopedStyleResolver();
   if (!scoped_resolver)
     return;
 
-  global_rule_set_.MarkDirty();
+  global_rule_set_->MarkDirty();
   if (tree_scope.RootNode().IsDocumentNode()) {
     scoped_resolver->ResetAuthorStyle();
     return;
   }
 
   tree_scope.ClearScopedStyleResolver();
 }
 
 void StyleEngine::SetRuleUsageTracker(StyleRuleUsageTracker* tracker) {
   tracker_ = tracker;
@@ skipping 29 matching lines @@
   if (resolver_) {
     TRACE_EVENT1("blink", "StyleEngine::clearResolver", "frame",
                  GetDocument().GetFrame());
     resolver_->Dispose();
     resolver_.Clear();
   }
 }
 
 void StyleEngine::DidDetach() {
   ClearResolvers();
-  global_rule_set_.Dispose();
+  if (global_rule_set_)
+    global_rule_set_->Dispose();
+  global_rule_set_ = nullptr;
   tree_boundary_crossing_scopes_.Clear();
   dirty_tree_scopes_.clear();
   active_tree_scopes_.clear();
   viewport_resolver_ = nullptr;
   media_query_evaluator_ = nullptr;
   if (font_selector_)
     font_selector_->GetFontFaceCache()->ClearAll();
   font_selector_ = nullptr;
 }
 
@@ skipping 470 matching lines @@
   // the same api. If it did have an effect, we should have marked the
   // document scope dirty and triggered an update of the active stylesheets
   // from here.
 }
 
 void StyleEngine::SetHttpDefaultStyle(const String& content) {
   SetPreferredStylesheetSetNameIfNotSet(content);
 }
 
 void StyleEngine::EnsureUAStyleForFullscreen() {
-  if (global_rule_set_.HasFullscreenUAStyle())
+  DCHECK(IsMaster());
+  DCHECK(global_rule_set_);
+  if (global_rule_set_->HasFullscreenUAStyle())
     return;
   CSSDefaultStyleSheets::Instance().EnsureDefaultStyleSheetForFullscreen();
-  global_rule_set_.MarkDirty();
+  global_rule_set_->MarkDirty();
   UpdateActiveStyle();
 }
 
 void StyleEngine::EnsureUAStyleForElement(const Element& element) {
+  DCHECK(IsMaster());
+  DCHECK(global_rule_set_);
   if (CSSDefaultStyleSheets::Instance().EnsureDefaultStyleSheetsForElement(
           element)) {
-    global_rule_set_.MarkDirty();
+    global_rule_set_->MarkDirty();
     UpdateActiveStyle();
   }
 }
 
 bool StyleEngine::HasRulesForId(const AtomicString& id) const {
-  return global_rule_set_.GetRuleFeatureSet().HasSelectorForId(id);
+  DCHECK(IsMaster());
+  DCHECK(global_rule_set_);
+  return global_rule_set_->GetRuleFeatureSet().HasSelectorForId(id);
 }
 
 void StyleEngine::InitialViewportChanged() {
   if (viewport_resolver_)
     viewport_resolver_->InitialViewportChanged();
 }
 
 void StyleEngine::ViewportRulesChanged() {
   if (viewport_resolver_)
     viewport_resolver_->SetNeedsCollectRules();
@@ skipping 24 matching lines @@
     MarkDocumentDirty();
     resolver->SetNeedsAppendAllSheets();
     GetDocument().SetNeedsStyleRecalc(
         kSubtreeStyleChange, StyleChangeReasonForTracing::Create(
                                  StyleChangeReason::kActiveStylesheetsUpdate));
   }
 }
 
 PassRefPtr<ComputedStyle> StyleEngine::FindSharedStyle(
     const ElementResolveContext& element_resolve_context) {
+  DCHECK(IsMaster());
   DCHECK(resolver_);
+  DCHECK(global_rule_set_);
   return SharedStyleFinder(
-             element_resolve_context, global_rule_set_.GetRuleFeatureSet(),
-             global_rule_set_.SiblingRuleSet(),
-             global_rule_set_.UncommonAttributeRuleSet(), *resolver_)
+             element_resolve_context, global_rule_set_->GetRuleFeatureSet(),
+             global_rule_set_->SiblingRuleSet(),
+             global_rule_set_->UncommonAttributeRuleSet(), *resolver_)
       .FindSharedStyle();
 }
 namespace {
 
 enum RuleSetFlags {
   kFontFaceRules = 1 << 0,
   kKeyframesRules = 1 << 1,
   kFullRecalcRules = 1 << 2
 };
 
@@ skipping 10 matching lines @@
   }
   return flags;
 }
 
 }  // namespace
 
 void StyleEngine::ApplyRuleSetChanges(
     TreeScope& tree_scope,
     const ActiveStyleSheetVector& old_style_sheets,
     const ActiveStyleSheetVector& new_style_sheets) {
+  DCHECK(IsMaster());
+  DCHECK(global_rule_set_);
   HeapHashSet<Member<RuleSet>> changed_rule_sets;
 
   ScopedStyleResolver* scoped_resolver = tree_scope.GetScopedStyleResolver();
   bool append_all_sheets =
       scoped_resolver && scoped_resolver->NeedsAppendAllSheets();
 
   ActiveSheetsChange change = CompareActiveStyleSheets(
       old_style_sheets, new_style_sheets, changed_rule_sets);
   if (change == kNoActiveSheetsChanged && !append_all_sheets)
     return;
 
   // With rules added or removed, we need to re-aggregate rule meta data.
-  global_rule_set_.MarkDirty();
+  global_rule_set_->MarkDirty();
 
   unsigned changed_rule_flags = GetRuleSetFlags(changed_rule_sets);
   bool fonts_changed = tree_scope.RootNode().IsDocumentNode() &&
                        (changed_rule_flags & kFontFaceRules);
   unsigned append_start_index = 0;
 
   // We don't need to clear the font cache if new sheets are appended.
   if (fonts_changed && change == kActiveSheetsChanged)
     ClearFontCache();
 
@@ skipping 53 matching lines @@
     if (GetDocument().GetFrame())
       media_query_evaluator_ =
           new MediaQueryEvaluator(GetDocument().GetFrame());
     else
       media_query_evaluator_ = new MediaQueryEvaluator("all");
   }
   return *media_query_evaluator_;
 }
 
 bool StyleEngine::MediaQueryAffectedByViewportChange() {
+  DCHECK(IsMaster());
+  DCHECK(global_rule_set_);
   const MediaQueryEvaluator& evaluator = EnsureMediaQueryEvaluator();
-  const auto& results =
-      global_rule_set_.GetRuleFeatureSet().ViewportDependentMediaQueryResults();
+  const auto& results = global_rule_set_->GetRuleFeatureSet()
+                            .ViewportDependentMediaQueryResults();
   for (unsigned i = 0; i < results.size(); ++i) {
     if (evaluator.Eval(results[i].Expression()) != results[i].Result())
       return true;
   }
   return false;
 }
 
 bool StyleEngine::MediaQueryAffectedByDeviceChange() {
+  DCHECK(IsMaster());
+  DCHECK(global_rule_set_);
   const MediaQueryEvaluator& evaluator = EnsureMediaQueryEvaluator();
   const auto& results =
-      global_rule_set_.GetRuleFeatureSet().DeviceDependentMediaQueryResults();
+      global_rule_set_->GetRuleFeatureSet().DeviceDependentMediaQueryResults();
   for (unsigned i = 0; i < results.size(); ++i) {
     if (evaluator.Eval(results[i].Expression()) != results[i].Result())
       return true;
   }
   return false;
 }
 
 DEFINE_TRACE(StyleEngine) {
   visitor->Trace(document_);
   visitor->Trace(injected_author_style_sheets_);
   visitor->Trace(inspector_style_sheet_);
   visitor->Trace(document_style_sheet_collection_);
   visitor->Trace(style_sheet_collection_map_);
   visitor->Trace(dirty_tree_scopes_);
   visitor->Trace(active_tree_scopes_);
   visitor->Trace(tree_boundary_crossing_scopes_);
-  visitor->Trace(global_rule_set_);
   visitor->Trace(resolver_);
   visitor->Trace(viewport_resolver_);
   visitor->Trace(media_query_evaluator_);
+  visitor->Trace(global_rule_set_);
   visitor->Trace(style_invalidator_);
   visitor->Trace(font_selector_);
   visitor->Trace(text_to_sheet_cache_);
   visitor->Trace(sheet_to_text_cache_);
   visitor->Trace(tracker_);
   CSSFontSelectorClient::Trace(visitor);
 }
 
 DEFINE_TRACE_WRAPPERS(StyleEngine) {
   for (auto sheet : injected_author_style_sheets_) {
     visitor->TraceWrappers(sheet);
   }
   visitor->TraceWrappers(document_style_sheet_collection_);
 }
 
 }  // namespace blink