Fix promise resolution of FontFaceSet#load()

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 31 matching lines @@
 #include "core/dom/StyleEngine.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "public/platform/Platform.h"
 
 namespace WebCore {
 
 static const int defaultFontSize = 10;
 static const char defaultFontFamily[] = "sans-serif";
 
-class LoadFontPromiseResolver : public CSSSegmentedFontFace::LoadFontCallback {
+class LoadFontPromiseResolver : public FontFace::LoadFontCallback {
 public:
-    static PassRefPtr<LoadFontPromiseResolver> create(const FontFamily& family, ExecutionContext* context)
+    static PassRefPtr<LoadFontPromiseResolver> create(FontFaceArray faces, ExecutionContext* context)
     {
-        int numFamilies = 0;
-        for (const FontFamily* f = &family; f; f = f->next())
-            numFamilies++;
-        return adoptRef<LoadFontPromiseResolver>(new LoadFontPromiseResolver(numFamilies, context));
+        return adoptRef(new LoadFontPromiseResolver(faces, context));
     }
 
+    void loadFonts(ExecutionContext*);
     ScriptPromise promise() { return m_resolver->promise(); }
 
-    virtual void notifyLoaded(CSSSegmentedFontFace*) OVERRIDE { loaded(); }
-    virtual void notifyError(CSSSegmentedFontFace*) OVERRIDE { error(); }
-    void loaded();
-    void error();
+    virtual void notifyLoaded(FontFace*) OVERRIDE;
+    virtual void notifyError(FontFace*) OVERRIDE;
 
 private:
-    LoadFontPromiseResolver(int numLoading, ExecutionContext* context)
-        : m_numLoading(numLoading)
+    LoadFontPromiseResolver(FontFaceArray faces, ExecutionContext* context)
+        : m_numLoading(faces.size())
         , m_errorOccured(false)
         , m_scriptState(ScriptState::current())
         , m_resolver(ScriptPromiseResolver::create(context))
-    { }
+    {
+        m_fontFaces.swap(faces);
+    }
 
+    FontFaceArray m_fontFaces;
     int m_numLoading;
     bool m_errorOccured;
     ScriptState* m_scriptState;
     RefPtr<ScriptPromiseResolver> m_resolver;
 };
 
-void LoadFontPromiseResolver::loaded()
+void LoadFontPromiseResolver::loadFonts(ExecutionContext* context)
+{
+    if (!m_numLoading) {
+        m_resolver->resolve(m_fontFaces);
+        return;
+    }
+
+    for (size_t i = 0; i < m_fontFaces.size(); i++)
+        m_fontFaces[i]->load(this, context);
+}
+
+void LoadFontPromiseResolver::notifyLoaded(FontFace* fontFace)
 {
     m_numLoading--;
-    if (m_numLoading)
+    if (m_numLoading || m_errorOccured)
         return;
 
     ScriptScope scope(m_scriptState);
-    if (m_errorOccured)
-        m_resolver->reject(ScriptValue::createNull());
-    else
-        m_resolver->resolve(ScriptValue::createNull());
+    m_resolver->resolve(m_fontFaces);
 }
 
-void LoadFontPromiseResolver::error()
+void LoadFontPromiseResolver::notifyError(FontFace* fontFace)
 {
-    m_errorOccured = true;
-    loaded();
+    m_numLoading--;
+    if (!m_errorOccured) {
+        m_errorOccured = true;
+        ScriptScope scope(m_scriptState);
+        m_resolver->reject(fontFace->error());
+    }
 }
 
 class FontsReadyPromiseResolver {
 public:
     static PassOwnPtr<FontsReadyPromiseResolver> create(ExecutionContext* context)
     {
         return adoptPtr(new FontsReadyPromiseResolver(context));
     }
 
     void resolve(PassRefPtr<FontFaceSet> fontFaceSet)
@@ skipping 306 matching lines @@
             resolvers[index]->resolve(this);
     }
 }
 
 static const String& nullToSpace(const String& s)
 {
     DEFINE_STATIC_LOCAL(String, space, (" "));
     return s.isNull() ? space : s;
 }
 
-ScriptPromise FontFaceSet::load(const String& fontString, const String& text, ExceptionState& exceptionState)
+ScriptPromise FontFaceSet::load(const String& fontString, const String& text)
 {
     if (!inActiveDocumentContext())
         return ScriptPromise();
 
     Font font;
     if (!resolveFontStyle(fontString, font)) {
-        exceptionState.throwDOMException(SyntaxError, "Could not resolve '" + fontString + "' as a font.");
-        return ScriptPromise();
+        RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(executionContext());
+        ScriptPromise promise = resolver->promise();
+        resolver->reject(DOMError::create(SyntaxError, "Could not resolve '" + fontString + "' as a font."));
+        return promise;
     }
 
-    CSSFontSelector* fontSelector = document()->styleEngine()->fontSelector();
-    FontFaceCache* fontFaceCache = fontSelector->fontFaceCache();
-    RefPtr<LoadFontPromiseResolver> resolver = LoadFontPromiseResolver::create(font.fontDescription().family(), executionContext());
+    FontFaceCache* fontFaceCache = document()->styleEngine()->fontSelector()->fontFaceCache();
+    FontFaceArray faces;
+    for (const FontFamily* f = &font.fontDescription().family(); f; f = f->next()) {
+        CSSSegmentedFontFace* segmentedFontFace = fontFaceCache->get(font.fontDescription(), f->family());
+        if (segmentedFontFace)
+            segmentedFontFace->match(nullToSpace(text), faces);
+    }
+
+    RefPtr<LoadFontPromiseResolver> resolver = LoadFontPromiseResolver::create(faces, executionContext());
     ScriptPromise promise = resolver->promise();
-    for (const FontFamily* f = &font.fontDescription().family(); f; f = f->next()) {
-        CSSSegmentedFontFace* face = fontFaceCache->get(font.fontDescription(), f->family());
-        if (!face) {
-            resolver->error();
-            continue;
-        }
-        face->loadFont(font.fontDescription(), nullToSpace(text), resolver);
-    }
-    fontSelector->loadPendingFonts();
+    resolver->loadFonts(executionContext()); // After this, resolver->promise() may return null.
     return promise;
 }
 
 bool FontFaceSet::check(const String& fontString, const String& text, ExceptionState& exceptionState)
 {
     if (!inActiveDocumentContext())
         return false;
 
     Font font;
     if (!resolveFontStyle(fontString, font)) {
@@ skipping 95 matching lines @@
 }
 
 void FontFaceSet::didLayout(Document& document)
 {
     if (FontFaceSet* fonts = static_cast<FontFaceSet*>(SupplementType::from(document, supplementName())))
         fonts->didLayout();
 }
 
 
 } // namespace WebCore