src/third_party/WebKit/Source/core/dom/StyleEngine.h

   1 /*
   2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   4  *           (C) 2001 Dirk Mueller (mueller@kde.org)
   5  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
   6  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012 Apple Inc. All rights reserved.
   7  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
   8  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
   9  * Copyright (C) 2011 Google Inc. All rights reserved.
  10  *
  11  * This library is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Library General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2 of the License, or (at your option) any later version.
  15  *
  16  * This library is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Library General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Library General Public License
  22  * along with this library; see the file COPYING.LIB.  If not, write to
  23  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  24  * Boston, MA 02110-1301, USA.
  25  *
  26  */
  27
  28 #ifndef StyleEngine_h
  29 #define StyleEngine_h
  30
  31 #include "core/css/CSSFontSelectorClient.h"
  32 #include "core/css/resolver/StyleResolver.h"
  33 #include "core/dom/Document.h"
  34 #include "core/dom/DocumentOrderedList.h"
  35 #include "core/dom/DocumentStyleSheetCollection.h"
  36 #include "platform/heap/Handle.h"
  37 #include "wtf/FastAllocBase.h"
  38 #include "wtf/ListHashSet.h"
  39 #include "wtf/RefPtr.h"
  40 #include "wtf/TemporaryChange.h"
  41 #include "wtf/Vector.h"
  42 #include "wtf/text/WTFString.h"
  43
  44 namespace blink {
  45
  46 class CSSFontSelector;
  47 class CSSStyleSheet;
  48 class Node;
  49 class RuleFeatureSet;
  50 class ShadowTreeStyleSheetCollection;
  51 class StyleRuleFontFace;
  52 class StyleSheet;
  53 class StyleSheetContents;
  54
  55 class StyleEngine final : public CSSFontSelectorClient  {
  56     WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED;
  57 public:
  58
  59     class IgnoringPendingStylesheet : public TemporaryChange<bool> {
  60     public:
  61         IgnoringPendingStylesheet(StyleEngine* engine)
  62             : TemporaryChange<bool>(engine->m_ignorePendingStylesheets, true)
  63         {
  64         }
  65     };
  66
  67     friend class IgnoringPendingStylesheet;
  68
  69     static PassOwnPtrWillBeRawPtr<StyleEngine> create(Document& document) { return adoptPtrWillBeNoop(new StyleEngine(document)); }
  70
  71     ~StyleEngine();
  72
  73 #if !ENABLE(OILPAN)
  74     void detachFromDocument();
  75 #endif
  76
  77     const WillBeHeapVector<RefPtrWillBeMember<StyleSheet> >& styleSheetsForStyleSheetList(TreeScope&);
  78     const WillBeHeapVector<RefPtrWillBeMember<CSSStyleSheet> >& activeAuthorStyleSheets() const;
  79
  80     const WillBeHeapVector<RefPtrWillBeMember<CSSStyleSheet> >& documentAuthorStyleSheets() const { return m_authorStyleSheets; }
  81     const WillBeHeapVector<RefPtrWillBeMember<CSSStyleSheet> >& injectedAuthorStyleSheets() const;
  82
  83     const WillBeHeapVector<RefPtrWillBeMember<CSSStyleSheet> > activeStyleSheetsForInspector() const;
  84
  85     void modifiedStyleSheet(StyleSheet*);
  86     void addStyleSheetCandidateNode(Node*, bool createdByParser);
  87     void removeStyleSheetCandidateNode(Node*);
  88     void removeStyleSheetCandidateNode(Node*, TreeScope&);
  89     void modifiedStyleSheetCandidateNode(Node*);
  90     void enableExitTransitionStylesheets();
  91     void addXSLStyleSheet(ProcessingInstruction*, bool createdByParser);
  92     void removeXSLStyleSheet(ProcessingInstruction*);
  93
  94     void invalidateInjectedStyleSheetCache();
  95     void updateInjectedStyleSheetCache() const;
  96
  97     void compatibilityModeChanged();
  98
  99     void addAuthorSheet(PassRefPtrWillBeRawPtr<StyleSheetContents> authorSheet);
 100
 101     void clearMediaQueryRuleSetStyleSheets();
 102     void updateStyleSheetsInImport(DocumentStyleSheetCollector& parentCollector);
 103     void updateActiveStyleSheets(StyleResolverUpdateMode);
 104
 105     String preferredStylesheetSetName() const { return m_preferredStylesheetSetName; }
 106     String selectedStylesheetSetName() const { return m_selectedStylesheetSetName; }
 107     void setPreferredStylesheetSetName(const String& name) { m_preferredStylesheetSetName = name; }
 108     void setSelectedStylesheetSetName(const String& name) { m_selectedStylesheetSetName = name; }
 109
 110     void selectStylesheetSetName(const String& name)
 111     {
 112         setPreferredStylesheetSetName(name);
 113         setSelectedStylesheetSetName(name);
 114     }
 115
 116     void addPendingSheet();
 117     void removePendingSheet(Node* styleSheetCandidateNode);
 118
 119     bool hasPendingSheets() const { return m_pendingStylesheets > 0; }
 120     bool haveStylesheetsLoaded() const { return !hasPendingSheets() || m_ignorePendingStylesheets; }
 121     bool ignoringPendingStylesheets() const { return m_ignorePendingStylesheets; }
 122
 123     unsigned maxDirectAdjacentSelectors() const { return m_maxDirectAdjacentSelectors; }
 124     bool usesSiblingRules() const { return m_usesSiblingRules || m_usesSiblingRulesOverride; }
 125     void setUsesSiblingRulesOverride(bool b) { m_usesSiblingRulesOverride = b; }
 126     bool usesFirstLineRules() const { return m_usesFirstLineRules; }
 127     bool usesFirstLetterRules() const { return m_usesFirstLetterRules; }
 128     void setUsesFirstLetterRules(bool b) { m_usesFirstLetterRules = b; }
 129     bool usesRemUnits() const { return m_usesRemUnits; }
 130     void setUsesRemUnit(bool b) { m_usesRemUnits = b; }
 131
 132     void combineCSSFeatureFlags(const RuleFeatureSet&);
 133     void resetCSSFeatureFlags(const RuleFeatureSet&);
 134
 135     void didRemoveShadowRoot(ShadowRoot*);
 136     void appendActiveAuthorStyleSheets();
 137
 138     StyleResolver* resolver() const
 139     {
 140         return m_resolver.get();
 141     }
 142
 143     StyleResolver& ensureResolver()
 144     {
 145         if (!m_resolver) {
 146             createResolver();
 147         } else if (m_resolver->hasPendingAuthorStyleSheets()) {
 148             m_resolver->appendPendingAuthorStyleSheets();
 149         }
 150         return *m_resolver.get();
 151     }
 152
 153     bool hasResolver() const { return m_resolver.get(); }
 154     void clearResolver();
 155     void clearMasterResolver();
 156
 157     CSSFontSelector* fontSelector() { return m_fontSelector.get(); }
 158     void removeFontFaceRules(const WillBeHeapVector<RawPtrWillBeMember<const StyleRuleFontFace> >&);
 159     void clearFontCache();
 160     // updateGenericFontFamilySettings is used from WebSettingsImpl.
 161     void updateGenericFontFamilySettings();
 162
 163     void didDetach();
 164     bool shouldClearResolver() const;
 165     void resolverChanged(StyleResolverUpdateMode);
 166     unsigned resolverAccessCount() const;
 167
 168     void markDocumentDirty();
 169
 170     PassRefPtrWillBeRawPtr<CSSStyleSheet> createSheet(Element*, const String& text, TextPosition startPosition, bool createdByParser);
 171     void removeSheet(StyleSheetContents*);
 172
 173     void addScopedStyleResolver(const ScopedStyleResolver* resolver) { m_scopedStyleResolvers.add(resolver); }
 174     void removeScopedStyleResolver(const ScopedStyleResolver* resolver) { m_scopedStyleResolvers.remove(resolver); }
 175     bool hasOnlyScopedResolverForDocument() const { return m_scopedStyleResolvers.size() == 1; }
 176     void collectScopedStyleFeaturesTo(RuleFeatureSet&) const;
 177
 178     virtual void trace(Visitor*) override;
 179
 180 private:
 181     // CSSFontSelectorClient implementation.
 182     virtual void fontsNeedUpdate(CSSFontSelector*) override;
 183
 184 private:
 185     StyleEngine(Document&);
 186
 187     TreeScopeStyleSheetCollection* ensureStyleSheetCollectionFor(TreeScope&);
 188     TreeScopeStyleSheetCollection* styleSheetCollectionFor(TreeScope&);
 189     bool shouldUpdateDocumentStyleSheetCollection(StyleResolverUpdateMode) const;
 190     bool shouldUpdateShadowTreeStyleSheetCollection(StyleResolverUpdateMode) const;
 191     bool shouldApplyXSLTransform() const;
 192
 193     void markTreeScopeDirty(TreeScope&);
 194
 195     bool isMaster() const { return m_isMaster; }
 196     Document* master();
 197     Document& document() const { return *m_document; }
 198
 199     typedef ListHashSet<TreeScope*, 16> TreeScopeSet;
 200     static void insertTreeScopeInDocumentOrder(TreeScopeSet&, TreeScope*);
 201     void clearMediaQueryRuleSetOnTreeScopeStyleSheets(TreeScopeSet treeScopes);
 202
 203     void createResolver();
 204
 205     static PassRefPtrWillBeRawPtr<CSSStyleSheet> parseSheet(Element*, const String& text, TextPosition startPosition, bool createdByParser);
 206
 207     const DocumentStyleSheetCollection* documentStyleSheetCollection() const
 208     {
 209         return m_documentStyleSheetCollection.get();
 210     }
 211
 212     DocumentStyleSheetCollection* documentStyleSheetCollection()
 213     {
 214         return m_documentStyleSheetCollection.get();
 215     }
 216
 217     RawPtrWillBeMember<Document> m_document;
 218     bool m_isMaster;
 219
 220     // Track the number of currently loading top-level stylesheets needed for rendering.
 221     // Sheets loaded using the @import directive are not included in this count.
 222     // We use this count of pending sheets to detect when we can begin attaching
 223     // elements and when it is safe to execute scripts.
 224     int m_pendingStylesheets;
 225
 226     mutable WillBeHeapVector<RefPtrWillBeMember<CSSStyleSheet> > m_injectedAuthorStyleSheets;
 227     mutable bool m_injectedStyleSheetCacheValid;
 228
 229     WillBeHeapVector<RefPtrWillBeMember<CSSStyleSheet> > m_authorStyleSheets;
 230
 231     OwnPtrWillBeMember<DocumentStyleSheetCollection> m_documentStyleSheetCollection;
 232
 233     typedef WillBeHeapHashMap<RawPtrWillBeWeakMember<TreeScope>, OwnPtrWillBeMember<ShadowTreeStyleSheetCollection> > StyleSheetCollectionMap;
 234     StyleSheetCollectionMap m_styleSheetCollectionMap;
 235     typedef WillBeHeapHashSet<RawPtrWillBeMember<const ScopedStyleResolver> > ScopedStyleResolverSet;
 236     ScopedStyleResolverSet m_scopedStyleResolvers;
 237
 238     bool m_documentScopeDirty;
 239     TreeScopeSet m_dirtyTreeScopes;
 240     TreeScopeSet m_activeTreeScopes;
 241
 242     String m_preferredStylesheetSetName;
 243     String m_selectedStylesheetSetName;
 244
 245     bool m_usesSiblingRules;
 246     bool m_usesSiblingRulesOverride;
 247     bool m_usesFirstLineRules;
 248     bool m_usesFirstLetterRules;
 249     bool m_usesRemUnits;
 250     unsigned m_maxDirectAdjacentSelectors;
 251
 252     bool m_ignorePendingStylesheets;
 253     bool m_didCalculateResolver;
 254     OwnPtrWillBeMember<StyleResolver> m_resolver;
 255
 256     RefPtrWillBeMember<CSSFontSelector> m_fontSelector;
 257
 258     WillBeHeapHashMap<AtomicString, RawPtrWillBeMember<StyleSheetContents> > m_textToSheetCache;
 259     WillBeHeapHashMap<RawPtrWillBeMember<StyleSheetContents>, AtomicString> m_sheetToTextCache;
 260
 261     RefPtrWillBeMember<ProcessingInstruction> m_xslStyleSheet;
 262 };
 263
 264 }
 265
 266 #endif