Don't trigger full active style update on styleSheets access.

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 76 matching lines @@
 inline Document* StyleEngine::Master() {
   if (IsMaster())
     return document_;
   HTMLImportsController* import = GetDocument().ImportsController();
   // Document::import() can return null while executing its destructor.
   if (!import)
     return nullptr;
   return import->Master();
 }
 
-TreeScopeStyleSheetCollection* StyleEngine::EnsureStyleSheetCollectionFor(
+TreeScopeStyleSheetCollection& StyleEngine::EnsureStyleSheetCollectionFor(
     TreeScope& tree_scope) {
   if (tree_scope == document_)
-    return &GetDocumentStyleSheetCollection();
+    return GetDocumentStyleSheetCollection();
 
   StyleSheetCollectionMap::AddResult result =
       style_sheet_collection_map_.insert(&tree_scope, nullptr);
   if (result.is_new_entry)
     result.stored_value->value =
         new ShadowTreeStyleSheetCollection(ToShadowRoot(tree_scope));
-  return result.stored_value->value.Get();
+  return *result.stored_value->value.Get();
 }
 
 TreeScopeStyleSheetCollection* StyleEngine::StyleSheetCollectionFor(
     TreeScope& tree_scope) {
   if (tree_scope == document_)
     return &GetDocumentStyleSheetCollection();
 
   StyleSheetCollectionMap::iterator it =
       style_sheet_collection_map_.find(&tree_scope);
   if (it == style_sheet_collection_map_.end())
     return nullptr;
   return it->value.Get();
 }
 
 const HeapVector<TraceWrapperMember<StyleSheet>>&
 StyleEngine::StyleSheetsForStyleSheetList(TreeScope& tree_scope) {
   DCHECK(Master());
+  TreeScopeStyleSheetCollection& collection =
+      EnsureStyleSheetCollectionFor(tree_scope);
   if (Master()->IsActive()) {
-    if (IsMaster()) {
-      // TODO(rune@opera.com): Replace with UpdateStyleSheetList().
+    if (all_tree_scopes_dirty_) {
+      // If all tree scopes are dirty, update all of active style. Otherwise, we
+      // would have to mark all tree scopes explicitly dirty for stylesheet list
+      // or repeatedly update the stylesheet list on styleSheets access. Note
+      // that this can only happen once if we kDidLayoutWithPendingSheets in
+      // Document::UpdateStyleAndLayoutTreeIgnoringPendingStyleSheets.
       UpdateActiveStyle();
     } else {
-      UpdateStyleSheetList(tree_scope);
+      collection.UpdateStyleSheetList();
     }
   }
-
-  if (tree_scope == document_)
-    return GetDocumentStyleSheetCollection().StyleSheetsForStyleSheetList();
-
-  DCHECK(IsMaster());
-  return EnsureStyleSheetCollectionFor(tree_scope)
-      ->StyleSheetsForStyleSheetList();
-}
-
-void StyleEngine::UpdateStyleSheetList(TreeScope& tree_scope) {
-  // TODO(rune@opera.com): currently only for import documents.
-  DCHECK(!IsMaster());
-  DCHECK(tree_scope.GetDocument() == GetDocument());
-
-  if (tree_scope != GetDocument())
-    return;
-  if (!ShouldUpdateDocumentStyleSheetCollection())
-    return;
-
-  GetDocumentStyleSheetCollection().CollectStyleSheetsForList();
-  // Avoid updating the styleSheets list repeatedly. Only safe for imports.
-  document_scope_dirty_ = false;
-  DCHECK(!all_tree_scopes_dirty_);
+  return collection.StyleSheetsForStyleSheetList();
 }
 
 void StyleEngine::InjectAuthorSheet(StyleSheetContents* author_sheet) {
   injected_author_style_sheets_.push_back(TraceWrapperMember<CSSStyleSheet>(
       this, CSSStyleSheet::Create(author_sheet, *document_)));
   MarkDocumentDirty();
 }
 
 CSSStyleSheet& StyleEngine::EnsureInspectorStyleSheet() {
   if (inspector_style_sheet_)
@@ skipping 53 matching lines @@
   if (GetDocument().IsActive() || !IsMaster())
     MarkTreeScopeDirty(tree_scope);
 }
 
 void StyleEngine::AddStyleSheetCandidateNode(Node& node) {
   if (!node.isConnected() || GetDocument().IsDetached())
     return;
 
   DCHECK(!IsXSLStyleSheet(node));
   TreeScope& tree_scope = node.GetTreeScope();
-  TreeScopeStyleSheetCollection* collection =
-      EnsureStyleSheetCollectionFor(tree_scope);
-  DCHECK(collection);
-  collection->AddStyleSheetCandidateNode(node);
+  EnsureStyleSheetCollectionFor(tree_scope).AddStyleSheetCandidateNode(node);
 
   SetNeedsActiveStyleUpdate(tree_scope);
   if (tree_scope != document_)
     active_tree_scopes_.insert(&tree_scope);
 }
 
 void StyleEngine::RemoveStyleSheetCandidateNode(
     Node& node,
     ContainerNode& insertion_point) {
   DCHECK(!IsXSLStyleSheet(node));
@@ skipping 72 matching lines @@
   HeapVector<Member<StyleSheet>> sheets_for_list;
   ImportedDocumentStyleSheetCollector subcollector(parent_collector,
                                                    sheets_for_list);
   GetDocumentStyleSheetCollection().CollectStyleSheets(master_engine,
                                                        subcollector);
   GetDocumentStyleSheetCollection().SwapSheetsForSheetList(sheets_for_list);
 
   // all_tree_scopes_dirty_ should only be set on main documents, never html
   // imports.
   DCHECK(!all_tree_scopes_dirty_);
-  // Make sure we don't re-collect sheets for style sheet list.
+  // Mark false for consistency. It is never checked for import documents.
   document_scope_dirty_ = false;
-  // Dirty tree scopes shadow trees do not affect the main document. Just leave
-  // them dirty here and re-collect when styleSheets is queried on shadow roots
-  // inside html import documents.
-  // tree_scopes_removed_ is irrelevant for html imports as the sheets do not
-  // affect style and removing a shadow tree is reflected directly in
-  // StyleSheetList accessing length or items.
 }
 
 void StyleEngine::UpdateActiveStyleSheetsInShadow(
     TreeScope* tree_scope,
     UnorderedTreeScopeSet& tree_scopes_removed) {
   DCHECK_NE(tree_scope, document_);
   ShadowTreeStyleSheetCollection* collection =
       ToShadowTreeStyleSheetCollection(StyleSheetCollectionFor(*tree_scope));
   DCHECK(collection);
   collection->UpdateActiveStyleSheets(*this);
@@ skipping 195 matching lines @@
   if (resolver_)
     resolver_->InvalidateMatchedPropertiesCache();
 }
 
 void StyleEngine::MarkTreeScopeDirty(TreeScope& scope) {
   if (scope == document_) {
     MarkDocumentDirty();
     return;
   }
 
-  DCHECK(style_sheet_collection_map_.Contains(&scope));
+  TreeScopeStyleSheetCollection* collection = StyleSheetCollectionFor(scope);
+  DCHECK(collection);
+  collection->MarkSheetListDirty();
   dirty_tree_scopes_.insert(&scope);
   GetDocument().ScheduleLayoutTreeUpdateIfNeeded();
 }
 
 void StyleEngine::MarkDocumentDirty() {
   document_scope_dirty_ = true;
+  document_style_sheet_collection_->MarkSheetListDirty();
   if (RuntimeEnabledFeatures::cssViewportEnabled())
     ViewportRulesChanged();
   if (GetDocument().ImportLoader())
     GetDocument()
         .ImportsController()
         ->Master()
         ->GetStyleEngine()
         .MarkDocumentDirty();
   else
     GetDocument().ScheduleLayoutTreeUpdateIfNeeded();
@@ skipping 665 matching lines @@
 }
 
 DEFINE_TRACE_WRAPPERS(StyleEngine) {
   for (auto sheet : injected_author_style_sheets_) {
     visitor->TraceWrappers(sheet);
   }
   visitor->TraceWrappers(document_style_sheet_collection_);
 }
 
 }  // namespace blink