[Font Load Events] Implement FontFaceSet methods

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
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``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 INC. OR ITS 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 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  * DAMAGE.
  */
 
 #include "config.h"
 #include "core/css/FontFaceSet.h"
 
 #include "RuntimeEnabledFeatures.h"
+#include "V8FontFaceSet.h"
 #include "bindings/v8/Dictionary.h"
+#include "bindings/v8/ScriptPromiseResolver.h"
+#include "bindings/v8/ScriptScope.h"
+#include "bindings/v8/ScriptState.h"
 #include "core/css/CSSFontFaceLoadEvent.h"
 #include "core/css/CSSFontFaceSource.h"
 #include "core/css/CSSFontSelector.h"
 #include "core/css/CSSParser.h"
 #include "core/css/CSSSegmentedFontFace.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/dom/Document.h"
 #include "core/page/FrameView.h"
 #include "core/platform/HistogramSupport.h"
 
 namespace WebCore {
 
 static const int defaultFontSize = 10;
 static const char* const defaultFontFamily = "sans-serif";
 
-class LoadFontCallback : public CSSSegmentedFontFace::LoadFontCallback {
+class LoadFontPromiseResolver : public CSSSegmentedFontFace::LoadFontCallback {
 public:
-    static PassRefPtr<LoadFontCallback> create(int numLoading, PassRefPtr<VoidCallback> loadCallback, PassRefPtr<VoidCallback> errorCallback)
+    static PassRefPtr<LoadFontPromiseResolver> create(const FontFamily& family, ScriptExecutionContext* context)
     {
-        return adoptRef<LoadFontCallback>(new LoadFontCallback(numLoading, loadCallback, errorCallback));
-    }
-
-    static PassRefPtr<LoadFontCallback> createFromParams(const Dictionary& params, const FontFamily& family)
-    {
-        RefPtr<VoidCallback> onsuccess;
-        RefPtr<VoidCallback> onerror;
-        params.get("onsuccess", onsuccess);
-        params.get("onerror", onerror);
-        if (!onsuccess && !onerror)
-            return 0;
         int numFamilies = 0;
         for (const FontFamily* f = &family; f; f = f->next())
             numFamilies++;
-        return LoadFontCallback::create(numFamilies, onsuccess, onerror);
+        return adoptRef<LoadFontPromiseResolver>(new LoadFontPromiseResolver(numFamilies, context));
     }
 
     virtual void notifyLoaded(CSSSegmentedFontFace*) OVERRIDE;
     virtual void notifyError(CSSSegmentedFontFace*) OVERRIDE;
     void loaded(Document*);
     void error(Document*);
+    void resolve();
+
+    ScriptPromise promise()
+    {
+        ScriptPromise promise = m_resolver->promise();
+        m_resolver->detachPromise();
+        return promise;
+    }
+
 private:
-    LoadFontCallback(int numLoading, PassRefPtr<VoidCallback> loadCallback, PassRefPtr<VoidCallback> errorCallback)
+    LoadFontPromiseResolver(int numLoading, ScriptExecutionContext* context)
         : m_numLoading(numLoading)
         , m_errorOccured(false)
-        , m_loadCallback(loadCallback)
-        , m_errorCallback(errorCallback)
+        , m_scriptState(ScriptState::current())
+        , m_resolver(ScriptPromiseResolver::create(context))
     { }
 
     int m_numLoading;
     bool m_errorOccured;
-    RefPtr<VoidCallback> m_loadCallback;
-    RefPtr<VoidCallback> m_errorCallback;
+    ScriptState* m_scriptState;
+    RefPtr<ScriptPromiseResolver> m_resolver;
 };
 
-void LoadFontCallback::loaded(Document* document)
+void LoadFontPromiseResolver::loaded(Document* document)
 {
     m_numLoading--;
     if (m_numLoading || !document)
         return;
 
-    if (m_errorOccured) {
-        if (m_errorCallback)
-            document->fonts()->scheduleCallback(m_errorCallback.release());
-    } else {
-        if (m_loadCallback)
-            document->fonts()->scheduleCallback(m_loadCallback.release());
-    }
+    document->fonts()->scheduleResolve(this);
 }
 
-void LoadFontCallback::error(Document* document)
+void LoadFontPromiseResolver::error(Document* document)
 {
     m_errorOccured = true;
     loaded(document);
 }
 
-void LoadFontCallback::notifyLoaded(CSSSegmentedFontFace* face)
+void LoadFontPromiseResolver::notifyLoaded(CSSSegmentedFontFace* face)
 {
     loaded(face->fontSelector()->document());
 }
 
-void LoadFontCallback::notifyError(CSSSegmentedFontFace* face)
+void LoadFontPromiseResolver::notifyError(CSSSegmentedFontFace* face)
 {
     error(face->fontSelector()->document());
 }
 
+void LoadFontPromiseResolver::resolve()
+{
+    ScriptScope scope(m_scriptState);
+    if (m_errorOccured)
+        m_resolver->reject(ScriptValue::createNull());
+    else
+        m_resolver->fulfill(ScriptValue::createNull());
+}
+
+class FontsReadyPromiseResolver {
+public:
+    static PassOwnPtr<FontsReadyPromiseResolver> create(ScriptExecutionContext* context)
+    {
+        return adoptPtr(new FontsReadyPromiseResolver(context));
+    }
+
+    void call(PassRefPtr<FontFaceSet> fontFaceSet)
+    {
+        ScriptScope scope(m_scriptState);
+        m_resolver->fulfill(fontFaceSet);
+    }
+
+    ScriptPromise promise()
+    {
+        ScriptPromise promise = m_resolver->promise();
+        m_resolver->detachPromise();
+        return promise;
+    }
+
+private:
+    FontsReadyPromiseResolver(ScriptExecutionContext* context)
+        : m_scriptState(ScriptState::current())
+        , m_resolver(ScriptPromiseResolver::create(context))
+    { }
+    ScriptState* m_scriptState;
+    RefPtr<ScriptPromiseResolver> m_resolver;
+};
+
 FontFaceSet::FontFaceSet(Document* document)
     : ActiveDOMObject(document)
     , m_loadingCount(0)
     , m_shouldFireDoneEvent(false)
     , m_timer(this, &FontFaceSet::timerFired)
 {
     suspendIfNeeded();
 }
 
 FontFaceSet::~FontFaceSet()
@@ skipping 25 matching lines @@
     return ActiveDOMObject::scriptExecutionContext();
 }
 
 void FontFaceSet::didLayout()
 {
     Document* d = document();
     if (d->page() && d->page()->mainFrame() == d->frame())
         m_histogram.record();
     if (!RuntimeEnabledFeatures::fontLoadEventsEnabled())
         return;
-    if (m_loadingCount || (!m_shouldFireDoneEvent && m_fontsReadyCallbacks.isEmpty()))
+    if (m_loadingCount || (!m_shouldFireDoneEvent && m_readyResolvers.isEmpty()))
         return;
     if (!m_timer.isActive())
         m_timer.startOneShot(0);
 }
 
 void FontFaceSet::timerFired(Timer<FontFaceSet>*)
 {
     firePendingEvents();
-    firePendingCallbacks();
+    resolvePendingLoadPromises();
     fireDoneEventIfPossible();
 }
 
 void FontFaceSet::scheduleEvent(PassRefPtr<Event> event)
 {
     m_pendingEvents.append(event);
     if (!m_timer.isActive())
         m_timer.startOneShot(0);
 }
 
 void FontFaceSet::firePendingEvents()
 {
     if (m_pendingEvents.isEmpty())
         return;
 
     Vector<RefPtr<Event> > pendingEvents;
     m_pendingEvents.swap(pendingEvents);
     for (size_t index = 0; index < pendingEvents.size(); ++index)
         dispatchEvent(pendingEvents[index].release());
 }
 
-void FontFaceSet::scheduleCallback(PassRefPtr<VoidCallback> callback)
+void FontFaceSet::scheduleResolve(LoadFontPromiseResolver* resolver)
 {
-    m_pendingCallbacks.append(callback);
+    m_pendingLoadResolvers.append(resolver);
     if (!m_timer.isActive())
         m_timer.startOneShot(0);
 }
 
-void FontFaceSet::firePendingCallbacks()
+void FontFaceSet::resolvePendingLoadPromises()
 {
-    if (m_pendingCallbacks.isEmpty())
+    if (m_pendingLoadResolvers.isEmpty())
         return;
 
-    Vector<RefPtr<VoidCallback> > pendingCallbacks;
-    m_pendingCallbacks.swap(pendingCallbacks);
-    for (size_t index = 0; index < pendingCallbacks.size(); ++index)
-        pendingCallbacks[index]->handleEvent();
+    Vector<RefPtr<LoadFontPromiseResolver> > resolvers;
+    m_pendingLoadResolvers.swap(resolvers);
+    for (size_t index = 0; index < resolvers.size(); ++index)
+        resolvers[index]->resolve();
 }
 
 void FontFaceSet::beginFontLoading(FontFace* fontFace)
 {
     m_histogram.incrementCount();
     if (!RuntimeEnabledFeatures::fontLoadEventsEnabled())
         return;
 
     ++m_loadingCount;
     if (m_loadingCount == 1 && !m_shouldFireDoneEvent)
@@ skipping 22 matching lines @@
     ASSERT(m_loadingCount > 0);
     --m_loadingCount;
     if (!m_loadingCount) {
         ASSERT(!m_shouldFireDoneEvent);
         m_shouldFireDoneEvent = true;
         if (!m_timer.isActive())
             m_timer.startOneShot(0);
     }
 }
 
-void FontFaceSet::notifyWhenFontsReady(PassRefPtr<VoidCallback> callback)
+ScriptPromise FontFaceSet::ready()
 {
-    m_fontsReadyCallbacks.append(callback);
+    OwnPtr<FontsReadyPromiseResolver> resolver = FontsReadyPromiseResolver::create(scriptExecutionContext());
+    ScriptPromise promise = resolver->promise();
+    m_readyResolvers.append(resolver.release());
     if (!m_timer.isActive())
         m_timer.startOneShot(0);
+    return promise;
 }
 
 void FontFaceSet::fireDoneEventIfPossible()
 {
-    if (!m_pendingEvents.isEmpty() || !m_pendingCallbacks.isEmpty())
+    if (!m_pendingEvents.isEmpty() || !m_pendingLoadResolvers.isEmpty())
         return;
-    if (m_loadingCount || (!m_shouldFireDoneEvent && m_fontsReadyCallbacks.isEmpty()))
+    if (m_loadingCount || (!m_shouldFireDoneEvent && 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.
     Document* d = document();
     if (!d->view() || d->view()->needsLayout())
         return;
 
     if (m_shouldFireDoneEvent) {
         m_shouldFireDoneEvent = false;
         RefPtr<CSSFontFaceLoadEvent> doneEvent;
         RefPtr<CSSFontFaceLoadEvent> errorEvent;
         doneEvent = CSSFontFaceLoadEvent::createForFontFaces(eventNames().loadingdoneEvent, m_loadedFonts);
         m_loadedFonts.clear();
         if (!m_failedFonts.isEmpty()) {
             errorEvent = CSSFontFaceLoadEvent::createForFontFaces(eventNames().loadingerrorEvent, m_failedFonts);
             m_failedFonts.clear();
         }
         dispatchEvent(doneEvent);
         if (errorEvent)
             dispatchEvent(errorEvent);
     }
 
-    if (!m_fontsReadyCallbacks.isEmpty()) {
-        Vector<RefPtr<VoidCallback> > callbacks;
-        m_fontsReadyCallbacks.swap(callbacks);
-        for (size_t index = 0; index < callbacks.size(); ++index)
-            callbacks[index]->handleEvent();
+    if (!m_readyResolvers.isEmpty()) {
+        Vector<OwnPtr<FontsReadyPromiseResolver> > resolvers;
+        m_readyResolvers.swap(resolvers);
+        for (size_t index = 0; index < resolvers.size(); ++index)
+            resolvers[index]->call(this);
     }
 }
 
-void FontFaceSet::loadFont(const Dictionary& params)
+Vector<RefPtr<FontFace> > FontFaceSet::match(const String& fontString, const String&, ExceptionState& es)
 {
-    // FIXME: The text member of params is ignored.
-    String fontString;
-    if (!params.get("font", fontString))
-        return;
+    // FIXME: The second parameter (text) is ignored.
+    Vector<RefPtr<FontFace> > matchedFonts;
+
     Font font;
-    if (!resolveFontStyle(fontString, font))
-        return;
-    RefPtr<LoadFontCallback> callback = LoadFontCallback::createFromParams(params, font.family());
+    if (!resolveFontStyle(fontString, font)) {
+        es.throwDOMException(SyntaxError);
+        return matchedFonts;
+    }
 
     for (const FontFamily* f = &font.family(); f; f = f->next()) {
-        Document* d = document();
-        CSSSegmentedFontFace* face = d->styleResolver()->fontSelector()->getFontFace(font.fontDescription(), f->family());
-        if (!face) {
-            if (callback)
-                callback->error(d);
-            continue;
-        }
-        face->loadFont(font.fontDescription(), callback);
+        CSSSegmentedFontFace* face = document()->styleResolver()->fontSelector()->getFontFace(font.fontDescription(), f->family());
+        if (face)
+            matchedFonts.append(face->fontFaces());
     }
+    return matchedFonts;
 }
 
-bool FontFaceSet::checkFont(const String& fontString, const String&)
+ScriptPromise FontFaceSet::load(const String& fontString, const String&, ExceptionState& es)
 {
     // FIXME: The second parameter (text) is ignored.
     Font font;
-    if (!resolveFontStyle(fontString, font))
+    if (!resolveFontStyle(fontString, font)) {
+        es.throwDOMException(SyntaxError);
+        return ScriptPromise();
+    }
+
+    Document* d = document();
+    RefPtr<LoadFontPromiseResolver> resolver = LoadFontPromiseResolver::create(font.family(), scriptExecutionContext());
+    for (const FontFamily* f = &font.family(); f; f = f->next()) {
+        CSSSegmentedFontFace* face = d->styleResolver()->fontSelector()->getFontFace(font.fontDescription(), f->family());
+        if (!face) {
+            resolver->error(d);
+            continue;
+        }
+        face->loadFont(font.fontDescription(), resolver);
+    }
+    return resolver->promise();
+}
+
+bool FontFaceSet::check(const String& fontString, const String&, ExceptionState& es)
+{
+    // FIXME: The second parameter (text) is ignored.
+    Font font;
+    if (!resolveFontStyle(fontString, font)) {
+        es.throwDOMException(SyntaxError);
         return false;
+    }
+
     for (const FontFamily* f = &font.family(); f; f = f->next()) {
         CSSSegmentedFontFace* face = document()->styleResolver()->fontSelector()->getFontFace(font.fontDescription(), f->family());
         if (!face || !face->checkFont())
             return false;
     }
     return true;
 }
 
 bool FontFaceSet::resolveFontStyle(const String& fontString, Font& font)
 {
+    if (fontString.isEmpty())

[eseidel, 2013/09/19 04:11:18]

I believe (!fontString) is equivalent, but this is fine too.

[Kunihiko Sakamoto, 2013/09/19 04:49:31]

!s is equivalent to !s.isNull(), but we don't want to pass empty string to
CSSParser::parseValue().

+        return false;
+
     // Interpret fontString in the same way as the 'font' attribute of CanvasRenderingContext2D.
     RefPtr<MutableStylePropertySet> parsedStyle = MutableStylePropertySet::create();
     CSSParser::parseValue(parsedStyle.get(), CSSPropertyFont, fontString, true, CSSStrictMode, 0);
     if (parsedStyle->isEmpty())
         return false;
 
     String fontValue = parsedStyle->getPropertyValue(CSSPropertyFont);
     if (fontValue == "inherit" || fontValue == "initial")
         return false;
 
@@ skipping 30 matching lines @@
 
 void FontFaceSet::FontLoadHistogram::record()
 {
     if (m_recorded)
         return;
     m_recorded = true;
     HistogramSupport::histogramCustomCounts("WebFont.WebFontsInPage", m_count, 1, 100, 50);
 }
 
 } // namespace WebCore