[Font Load Events] Partial implementation of SetClass operations for FontFaceSet

Source/core/css/FontFaceSet.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 13 matching lines @@
  */
 
 #include "config.h"
 #include "core/css/FontFaceSet.h"
 
 #include "RuntimeEnabledFeatures.h"
 #include "bindings/v8/Dictionary.h"
 #include "bindings/v8/ScriptPromiseResolver.h"
 #include "bindings/v8/ScriptScope.h"
 #include "bindings/v8/ScriptState.h"
+#include "core/css/CSSFontFace.h"
 #include "core/css/CSSFontFaceLoadEvent.h"
 #include "core/css/CSSFontFaceSource.h"
 #include "core/css/CSSFontSelector.h"
 #include "core/css/parser/BisonCSSParser.h"
 #include "core/css/CSSSegmentedFontFace.h"
+#include "core/css/CSSSegmentedFontFaceCache.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/dom/Document.h"
 #include "core/frame/Frame.h"
 #include "core/frame/FrameView.h"
 #include "public/platform/Platform.h"
 
 namespace WebCore {
 
 static const int defaultFontSize = 10;
@@ skipping 62 matching lines @@
 
 private:
     FontsReadyPromiseResolver(ScriptPromise promise, ExecutionContext* context)
         : m_scriptState(ScriptState::current())
         , m_resolver(ScriptPromiseResolver::create(promise, context))
     { }
     ScriptState* m_scriptState;
     RefPtr<ScriptPromiseResolver> m_resolver;
 };
 
+static void flushPendingStyleChanges(Document* document)
+{
+    document->ensureStyleResolver();
+}
+
 FontFaceSet::FontFaceSet(Document* document)
     : ActiveDOMObject(document)
     , m_loadingCount(0)
     , m_shouldFireLoadingEvent(false)
     , m_asyncRunner(this, &FontFaceSet::handlePendingEventsAndPromises)
 {
     suspendIfNeeded();
 }
 
 FontFaceSet::~FontFaceSet()
@@ skipping 109 matching lines @@
 
 ScriptPromise FontFaceSet::ready()
 {
     ScriptPromise promise = ScriptPromise::createPending(executionContext());
     OwnPtr<FontsReadyPromiseResolver> resolver = FontsReadyPromiseResolver::create(promise, executionContext());
     m_readyResolvers.append(resolver.release());
     handlePendingEventsAndPromisesSoon();
     return promise;
 }
 
+bool FontFaceSet::has(FontFace* fontFace, ExceptionState& exceptionState) const
+{
+    if (!fontFace) {
+        exceptionState.throwTypeError("The argument is not a FontFace.");
+        return false;
+    }
+    flushPendingStyleChanges(document());
+    return document()->styleEngine()->fontSelector()->cssSegmentedFontFaceCache()->cssFontFaceList().contains(fontFace->cssFontFace());
+}
+
+void FontFaceSet::forEach(PassOwnPtr<FontFaceSetForEachCallback> callback, ScriptValue& thisArg) const
+{
+    forEachInternal(callback, &thisArg);
+}
+
+void FontFaceSet::forEach(PassOwnPtr<FontFaceSetForEachCallback> callback) const
+{
+    forEachInternal(callback, 0);
+}
+
+void FontFaceSet::forEachInternal(PassOwnPtr<FontFaceSetForEachCallback> callback, ScriptValue* thisArg) const
+{
+    flushPendingStyleChanges(document());
+    const ListHashSet<RefPtr<CSSFontFace> >& faces = document()->styleEngine()->fontSelector()->cssSegmentedFontFaceCache()->cssFontFaceList();
+    Vector<RefPtr<FontFace> > fontFaces;
+    fontFaces.reserveInitialCapacity(faces.size());
+    for (ListHashSet<RefPtr<CSSFontFace> >::const_iterator it = faces.begin(); it != faces.end(); ++it)
+        fontFaces.append((*it)->fontFace());
+
+    for (size_t i = 0; i < fontFaces.size(); ++i) {
+        if (thisArg)
+            callback->handleItem(*thisArg, fontFaces[i].get(), const_cast<FontFaceSet*>(this));
+        else
+            callback->handleItem(fontFaces[i].get(), const_cast<FontFaceSet*>(this));
+    }
+}
+
+unsigned long FontFaceSet::size() const
+{
+    flushPendingStyleChanges(document());
+    return document()->styleEngine()->fontSelector()->cssSegmentedFontFaceCache()->cssFontFaceList().size();
+}
+
 void FontFaceSet::fireDoneEventIfPossible()
 {
     if (m_shouldFireLoadingEvent)
         return;
     if (m_loadingCount || (!hasLoadedFonts() && m_readyResolvers.isEmpty()))
         return;
 
     // If the layout was invalidated in between when we thought layout
     // was updated and when we're ready to fire the event, just wait
     // until after the next layout before firing events.
@@ skipping 32 matching lines @@
 Vector<RefPtr<FontFace> > FontFaceSet::match(const String& fontString, const String& text, ExceptionState& exceptionState)
 {
     Vector<RefPtr<FontFace> > matchedFonts;
 
     Font font;
     if (!resolveFontStyle(fontString, font)) {
         exceptionState.throwDOMException(SyntaxError, "Could not resolve '" + fontString + "' as a font.");
         return matchedFonts;
     }
 
+    CSSSegmentedFontFaceCache* cssSegmentedFontFaceCache = document()->styleEngine()->fontSelector()->cssSegmentedFontFaceCache();
     for (const FontFamily* f = &font.family(); f; f = f->next()) {
-        CSSSegmentedFontFace* face = document()->styleEngine()->fontSelector()->getFontFace(font.fontDescription(), f->family());
+        CSSSegmentedFontFace* face = cssSegmentedFontFaceCache->get(font.fontDescription(), f->family());
         if (face)
             matchedFonts.append(face->fontFaces(nullToSpace(text)));
     }
     return matchedFonts;
 }
 
 ScriptPromise FontFaceSet::load(const String& fontString, const String& text, ExceptionState& exceptionState)
 {
     Font font;
     if (!resolveFontStyle(fontString, font)) {
         exceptionState.throwDOMException(SyntaxError, "Could not resolve '" + fontString + "' as a font.");
         return ScriptPromise();
     }
 
-    Document* d = document();
+    CSSSegmentedFontFaceCache* cssSegmentedFontFaceCache = document()->styleEngine()->fontSelector()->cssSegmentedFontFaceCache();
     ScriptPromise promise = ScriptPromise::createPending(executionContext());
     RefPtr<LoadFontPromiseResolver> resolver = LoadFontPromiseResolver::create(font.family(), promise, executionContext());
     for (const FontFamily* f = &font.family(); f; f = f->next()) {
-        CSSSegmentedFontFace* face = d->styleEngine()->fontSelector()->getFontFace(font.fontDescription(), f->family());
+        CSSSegmentedFontFace* face = cssSegmentedFontFaceCache->get(font.fontDescription(), f->family());
         if (!face) {
             resolver->error();
             continue;
         }
         face->loadFont(font.fontDescription(), nullToSpace(text), resolver);
     }
     return promise;
 }
 
 bool FontFaceSet::check(const String& fontString, const String& text, ExceptionState& exceptionState)
 {
     Font font;
     if (!resolveFontStyle(fontString, font)) {
         exceptionState.throwDOMException(SyntaxError, "Could not resolve '" + fontString + "' as a font.");
         return false;
     }
 
+    CSSSegmentedFontFaceCache* cssSegmentedFontFaceCache = document()->styleEngine()->fontSelector()->cssSegmentedFontFaceCache();
     for (const FontFamily* f = &font.family(); f; f = f->next()) {
-        CSSSegmentedFontFace* face = document()->styleEngine()->fontSelector()->getFontFace(font.fontDescription(), f->family());
+        CSSSegmentedFontFace* face = cssSegmentedFontFaceCache->get(font.fontDescription(), f->family());
         if (!face || !face->checkFont(nullToSpace(text)))
             return false;
     }
     return true;
 }
 
 bool FontFaceSet::resolveFontStyle(const String& fontString, Font& font)
 {
     if (fontString.isEmpty())
         return false;
@@ skipping 64 matching lines @@
 }
 
 void FontFaceSet::didLayout(Document* document)
 {
     if (FontFaceSet* fonts = static_cast<FontFaceSet*>(SupplementType::from(document, supplementName())))
         fonts->didLayout();
 }
 
 
 } // namespace WebCore