Decouple ScriptPromise creation from ScriptPromiseResolver.

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 32 matching lines @@
 #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 LoadFontPromiseResolver : public CSSSegmentedFontFace::LoadFontCallback {
 public:
-    static PassRefPtr<LoadFontPromiseResolver> create(const FontFamily& family, ScriptExecutionContext* context)
+    static PassRefPtr<LoadFontPromiseResolver> create(const FontFamily& family, ScriptPromise promise, ScriptExecutionContext* context)
     {
         int numFamilies = 0;
         for (const FontFamily* f = &family; f; f = f->next())
             numFamilies++;
-        return adoptRef<LoadFontPromiseResolver>(new LoadFontPromiseResolver(numFamilies, context));
+        return adoptRef<LoadFontPromiseResolver>(new LoadFontPromiseResolver(numFamilies, promise, 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:
-    LoadFontPromiseResolver(int numLoading, ScriptExecutionContext* context)
+    LoadFontPromiseResolver(int numLoading, ScriptPromise promise, ScriptExecutionContext* context)
         : m_numLoading(numLoading)
         , m_errorOccured(false)
         , m_scriptState(ScriptState::current())
-        , m_resolver(ScriptPromiseResolver::create(context))
+        , m_resolver(ScriptPromiseResolver::create(promise, context))
     { }
 
     int m_numLoading;
     bool m_errorOccured;
     ScriptState* m_scriptState;
     RefPtr<ScriptPromiseResolver> m_resolver;
 };
 
 void LoadFontPromiseResolver::loaded(Document* document)
 {
@@ skipping 19 matching lines @@
 {
     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());
+        m_resolver->resolve(ScriptValue::createNull());
 }
 
 class FontsReadyPromiseResolver {
 public:
-    static PassOwnPtr<FontsReadyPromiseResolver> create(ScriptExecutionContext* context)
+    static PassOwnPtr<FontsReadyPromiseResolver> create(ScriptPromise promise, ScriptExecutionContext* context)
     {
-        return adoptPtr(new FontsReadyPromiseResolver(context));
+        return adoptPtr(new FontsReadyPromiseResolver(promise, 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;
+        m_resolver->resolve(fontFaceSet);
     }
 
 private:
-    FontsReadyPromiseResolver(ScriptExecutionContext* context)
+    FontsReadyPromiseResolver(ScriptPromise promise, ScriptExecutionContext* context)
         : m_scriptState(ScriptState::current())
-        , m_resolver(ScriptPromiseResolver::create(context))
+        , m_resolver(ScriptPromiseResolver::create(promise, 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)
@@ skipping 128 matching lines @@
     if (!m_loadingCount) {
         ASSERT(!m_shouldFireDoneEvent);
         m_shouldFireDoneEvent = true;
         if (!m_timer.isActive())
             m_timer.startOneShot(0);
     }
 }
 
 ScriptPromise FontFaceSet::ready()
 {
-    OwnPtr<FontsReadyPromiseResolver> resolver = FontsReadyPromiseResolver::create(scriptExecutionContext());
-    ScriptPromise promise = resolver->promise();
+    ScriptPromise promise = ScriptPromise::create(scriptExecutionContext());
+    OwnPtr<FontsReadyPromiseResolver> resolver = FontsReadyPromiseResolver::create(promise, scriptExecutionContext());
     m_readyResolvers.append(resolver.release());
     if (!m_timer.isActive())
         m_timer.startOneShot(0);
     return promise;
 }
 
 void FontFaceSet::fireDoneEventIfPossible()
 {
     if (!m_pendingEvents.isEmpty() || !m_pendingLoadResolvers.isEmpty())
         return;
@@ skipping 52 matching lines @@
 ScriptPromise FontFaceSet::load(const String& fontString, const String&, ExceptionState& es)
 {
     // FIXME: The second parameter (text) is ignored.
     Font font;
     if (!resolveFontStyle(fontString, font)) {
         es.throwUninformativeAndGenericDOMException(SyntaxError);
         return ScriptPromise();
     }
 
     Document* d = document();
-    RefPtr<LoadFontPromiseResolver> resolver = LoadFontPromiseResolver::create(font.family(), scriptExecutionContext());
+    ScriptPromise promise = ScriptPromise::create(scriptExecutionContext());
+    RefPtr<LoadFontPromiseResolver> resolver = LoadFontPromiseResolver::create(font.family(), promise, 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();
+    return 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.throwUninformativeAndGenericDOMException(SyntaxError);
         return false;
     }
@@ skipping 54 matching lines @@
 
 void FontFaceSet::FontLoadHistogram::record()
 {
     if (m_recorded)
         return;
     m_recorded = true;
     HistogramSupport::histogramCustomCounts("WebFont.WebFontsInPage", m_count, 1, 100, 50);
 }
 
 } // namespace WebCore