#pragma once
#include "Timer.h"
#include <memory>
#include <wtf/FastMalloc.h>
#include <wtf/HashMap.h>
#include <wtf/ListHashSet.h>
#include <wtf/RefPtr.h>
#include <wtf/Vector.h>
#include <wtf/text/WTFString.h>
namespace WebCore {
class CSSStyleSheet;
class Document;
class Element;
class Node;
class StyleResolver;
class StyleSheet;
class StyleSheetContents;
class StyleSheetList;
class ShadowRoot;
class TreeScope;
namespace Style {
enum class ScopeOrdinal : int {
ContainingHost = -1, Element = 0, FirstSlot = 1, Shadow = std::numeric_limits<int>::max(), };
class Scope {
WTF_MAKE_FAST_ALLOCATED;
public:
explicit Scope(Document&);
explicit Scope(ShadowRoot&);
~Scope();
const Vector<RefPtr<CSSStyleSheet>>& activeStyleSheets() const { return m_activeStyleSheets; }
const Vector<RefPtr<StyleSheet>>& styleSheetsForStyleSheetList();
const Vector<RefPtr<CSSStyleSheet>> activeStyleSheetsForInspector();
void addStyleSheetCandidateNode(Node&, bool createdByParser);
void removeStyleSheetCandidateNode(Node&);
String preferredStylesheetSetName() const { return m_preferredStylesheetSetName; }
String selectedStylesheetSetName() const { return m_selectedStylesheetSetName; }
void setPreferredStylesheetSetName(const String&);
void setSelectedStylesheetSetName(const String&);
void addPendingSheet() { m_pendingStyleSheetCount++; }
enum RemovePendingSheetNotificationType {
RemovePendingSheetNotifyImmediately,
RemovePendingSheetNotifyLater
};
void removePendingSheet(RemovePendingSheetNotificationType = RemovePendingSheetNotifyImmediately);
bool hasPendingSheets() const { return m_pendingStyleSheetCount > 0; }
bool usesStyleBasedEditability() { return m_usesStyleBasedEditability; }
bool activeStyleSheetsContains(const CSSStyleSheet*) const;
void didChangeActiveStyleSheetCandidates();
void didChangeStyleSheetContents();
WEBCORE_EXPORT void didChangeStyleSheetEnvironment();
bool hasPendingUpdate() const { return m_pendingUpdate || m_hasDescendantWithPendingUpdate; }
void flushPendingUpdate();
StyleResolver& resolver();
StyleResolver* resolverIfExists();
void clearResolver();
const Document& document() const { return m_document; }
static Scope& forNode(Node&);
static Scope* forOrdinal(Element&, ScopeOrdinal);
private:
bool shouldUseSharedUserAgentShadowTreeStyleResolver() const;
enum class UpdateType { ActiveSet, ContentsOrInterpretation };
void updateActiveStyleSheets(UpdateType);
void scheduleUpdate(UpdateType);
WEBCORE_EXPORT void flushPendingSelfUpdate();
WEBCORE_EXPORT void flushPendingDescendantUpdates();
void collectActiveStyleSheets(Vector<RefPtr<StyleSheet>>&);
enum StyleResolverUpdateType {
Reconstruct,
Reset,
Additive
};
StyleResolverUpdateType analyzeStyleSheetChange(const Vector<RefPtr<CSSStyleSheet>>& newStylesheets, bool& requiresFullStyleRecalc);
void updateStyleResolver(Vector<RefPtr<CSSStyleSheet>>&, StyleResolverUpdateType);
void pendingUpdateTimerFired();
void clearPendingUpdate();
Document& m_document;
ShadowRoot* m_shadowRoot { nullptr };
std::unique_ptr<StyleResolver> m_resolver;
Vector<RefPtr<StyleSheet>> m_styleSheetsForStyleSheetList;
Vector<RefPtr<CSSStyleSheet>> m_activeStyleSheets;
Timer m_pendingUpdateTimer;
mutable std::unique_ptr<HashSet<const CSSStyleSheet*>> m_weakCopyOfActiveStyleSheetListForFastLookup;
int m_pendingStyleSheetCount { 0 };
bool m_didUpdateActiveStyleSheets { false };
std::optional<UpdateType> m_pendingUpdate;
bool m_hasDescendantWithPendingUpdate { false };
ListHashSet<Node*> m_styleSheetCandidateNodes;
String m_preferredStylesheetSetName;
String m_selectedStylesheetSetName;
bool m_usesStyleBasedEditability { false };
bool m_isUpdatingStyleResolver { false };
};
inline void Scope::flushPendingUpdate()
{
if (m_hasDescendantWithPendingUpdate)
flushPendingDescendantUpdates();
if (m_pendingUpdate)
flushPendingSelfUpdate();
}
inline ScopeOrdinal& operator++(ScopeOrdinal& ordinal)
{
ASSERT(ordinal < ScopeOrdinal::Shadow);
return ordinal = static_cast<ScopeOrdinal>(static_cast<int>(ordinal) + 1);
}
}
}