1 files changed, 45 insertions, 32 deletions

diff --git a/Source/WebCore/css/CSSFontSelector.h b/Source/WebCore/css/CSSFontSelector.h
index 8ad74cd77..623f2486a 100644
--- a/Source/WebCore/css/CSSFontSelector.h
+++ b/Source/WebCore/css/CSSFontSelector.h
@@ -10,10 +10,10 @@
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
- * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
@@ -23,84 +23,97 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef CSSFontSelector_h
-#define CSSFontSelector_h
+#pragma once
 
+#include "CSSFontFace.h"
+#include "CSSFontFaceSet.h"
 #include "CachedResourceHandle.h"
+#include "Font.h"
 #include "FontSelector.h"
-#include "SimpleFontData.h"
 #include "Timer.h"
 #include <memory>
 #include <wtf/Forward.h>
-#include <wtf/HashMap.h>
 #include <wtf/HashSet.h>
 #include <wtf/RefPtr.h>
 #include <wtf/text/StringHash.h>
 
 namespace WebCore {
 
-class CSSFontFace;
 class CSSFontFaceRule;
+class CSSPrimitiveValue;
 class CSSSegmentedFontFace;
+class CSSValueList;
 class CachedFont;
 class Document;
-class FontDescription;
 class StyleRuleFontFace;
 
-class CSSFontSelector final : public FontSelector {
+class CSSFontSelector final : public FontSelector, public CSSFontFaceSetClient {
 public:
-    static PassRefPtr<CSSFontSelector> create(Document* document)
+    static Ref<CSSFontSelector> create(Document& document)
     {
-        return adoptRef(new CSSFontSelector(document));
+        return adoptRef(*new CSSFontSelector(document));
     }
     virtual ~CSSFontSelector();
     
-    virtual unsigned version() const override { return m_version; }
-    virtual unsigned uniqueId() const override { return m_uniqueId; }
+    unsigned version() const final { return m_version; }
+    unsigned uniqueId() const final { return m_uniqueId; }
 
-    virtual PassRefPtr<FontData> getFontData(const FontDescription&, const AtomicString&) override;
-    virtual size_t fallbackFontDataCount() override;
-    virtual PassRefPtr<FontData> getFallbackFontData(const FontDescription&, size_t) override;
-    CSSSegmentedFontFace* getFontFace(const FontDescription&, const AtomicString& family);
-
-    virtual bool resolvesFamilyFor(const FontDescription&) const override;
+    FontRanges fontRangesForFamily(const FontDescription&, const AtomicString&) final;
+    size_t fallbackFontCount() final;
+    RefPtr<Font> fallbackFontAt(const FontDescription&, size_t) final;
 
     void clearDocument();
+    void buildStarted();
+    void buildCompleted();
 
-    void addFontFaceRule(const StyleRuleFontFace*);
+    void addFontFaceRule(StyleRuleFontFace&, bool isInitiatingElementInUserAgentShadowTree);
 
     void fontLoaded();
-    virtual void fontCacheInvalidated() override;
+    void fontCacheInvalidated() final;
 
     bool isEmpty() const;
 
-    virtual void registerForInvalidationCallbacks(FontSelectorClient*) override;
-    virtual void unregisterForInvalidationCallbacks(FontSelectorClient*) override;
+    void registerForInvalidationCallbacks(FontSelectorClient&) final;
+    void unregisterForInvalidationCallbacks(FontSelectorClient&) final;
 
     Document* document() const { return m_document; }
 
-    void beginLoadingFontSoon(CachedFont*);
+    void beginLoadingFontSoon(CachedFont&);
+
+    FontFaceSet& fontFaceSet();
+
+    void setIsComputingRootStyleFont(bool value) { m_isComputingRootStyleFont = value; }
 
 private:
-    CSSFontSelector(Document*);
+    explicit CSSFontSelector(Document&);
 
     void dispatchInvalidationCallbacks();
 
-    void beginLoadTimerFired(Timer<CSSFontSelector>&);
+    void fontModified() final;
+
+    void beginLoadTimerFired();
+
+    struct PendingFontFaceRule {
+        StyleRuleFontFace& styleRuleFontFace;
+        bool isInitiatingElementInUserAgentShadowTree;
+    };
+    Vector<PendingFontFaceRule> m_stagingArea;
 
     Document* m_document;
-    HashMap<String, std::unique_ptr<Vector<RefPtr<CSSFontFace>>>, CaseFoldingHash> m_fontFaces;
-    HashMap<String, std::unique_ptr<Vector<RefPtr<CSSFontFace>>>, CaseFoldingHash> m_locallyInstalledFontFaces;
-    HashMap<String, std::unique_ptr<HashMap<unsigned, RefPtr<CSSSegmentedFontFace>>>, CaseFoldingHash> m_fonts;
+    RefPtr<FontFaceSet> m_fontFaceSet;
+    Ref<CSSFontFaceSet> m_cssFontFaceSet;
     HashSet<FontSelectorClient*> m_clients;
 
     Vector<CachedResourceHandle<CachedFont>> m_fontsToBeginLoading;
-    Timer<CSSFontSelector> m_beginLoadingTimer;
+    HashSet<RefPtr<CSSFontFace>> m_cssConnectionsPossiblyToRemove;
+    HashSet<RefPtr<StyleRuleFontFace>> m_cssConnectionsEncounteredDuringBuild;
+    Timer m_beginLoadingTimer;
 
     unsigned m_uniqueId;
     unsigned m_version;
+    bool m_creatingFont { false };
+    bool m_buildIsUnderway { false };
+    bool m_isComputingRootStyleFont { false };
 };
 
 } // namespace WebCore
-
-#endif // CSSFontSelector_h