Merge the Sky Engine changes from the SkyDart branch

sky/engine/core/css/FontFace.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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 15 matching lines @@
  * 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 "sky/engine/config.h"
 #include "sky/engine/core/css/FontFace.h"
 
 #include "gen/sky/core/CSSValueKeywords.h"
 #include "gen/sky/platform/FontFamilyNames.h"
-#include "sky/engine/bindings/core/v8/Dictionary.h"
-#include "sky/engine/bindings/core/v8/ExceptionState.h"
-#include "sky/engine/bindings/core/v8/ScriptState.h"
+#include "sky/engine/bindings2/exception_state.h"
 #include "sky/engine/core/css/BinaryDataFontFaceSource.h"
 #include "sky/engine/core/css/CSSFontFace.h"
 #include "sky/engine/core/css/CSSFontFaceSrcValue.h"
 #include "sky/engine/core/css/CSSFontSelector.h"
 #include "sky/engine/core/css/CSSPrimitiveValue.h"
 #include "sky/engine/core/css/CSSUnicodeRangeValue.h"
 #include "sky/engine/core/css/CSSValueList.h"
 #include "sky/engine/core/css/LocalFontFaceSource.h"
 #include "sky/engine/core/css/RemoteFontFaceSource.h"
 #include "sky/engine/core/css/StylePropertySet.h"
@@ skipping 12 matching lines @@
 
 static PassRefPtr<CSSValue> parseCSSValue(const Document* document, const String& s, CSSPropertyID propertyID)
 {
     if (s.isEmpty())
         return nullptr;
     RefPtr<MutableStylePropertySet> parsedStyle = MutableStylePropertySet::create();
     BisonCSSParser::parseValue(parsedStyle.get(), propertyID, s, *document);
     return parsedStyle->getPropertyCSSValue(propertyID);
 }
 
-PassRefPtr<FontFace> FontFace::create(ExecutionContext* context, const AtomicString& family, const String& source, const Dictionary& descriptors)
+PassRefPtr<FontFace> FontFace::create(ExecutionContext* context, const AtomicString& family, const String& source)
 {
-    RefPtr<FontFace> fontFace = adoptRef(new FontFace(context, family, descriptors));
+    RefPtr<FontFace> fontFace = adoptRef(new FontFace(context, family));
 
     RefPtr<CSSValue> src = parseCSSValue(toDocument(context), source, CSSPropertySrc);
     if (!src || !src->isValueList())
         fontFace->setError(DOMException::create(SyntaxError, "The source provided ('" + source + "') could not be parsed as a value list."));
 
     fontFace->initCSSFontFace(toDocument(context), src);
     return fontFace.release();
 }
 
-PassRefPtr<FontFace> FontFace::create(ExecutionContext* context, const AtomicString& family, PassRefPtr<ArrayBuffer> source, const Dictionary& descriptors)
+PassRefPtr<FontFace> FontFace::create(ExecutionContext* context, const AtomicString& family, PassRefPtr<ArrayBuffer> source)
 {
-    RefPtr<FontFace> fontFace = adoptRef(new FontFace(context, family, descriptors));
+    RefPtr<FontFace> fontFace = adoptRef(new FontFace(context, family));
     fontFace->initCSSFontFace(static_cast<const unsigned char*>(source->data()), source->byteLength());
     return fontFace.release();
 }
 
-PassRefPtr<FontFace> FontFace::create(ExecutionContext* context, const AtomicString& family, PassRefPtr<ArrayBufferView> source, const Dictionary& descriptors)
+PassRefPtr<FontFace> FontFace::create(ExecutionContext* context, const AtomicString& family, PassRefPtr<ArrayBufferView> source)
 {
-    RefPtr<FontFace> fontFace = adoptRef(new FontFace(context, family, descriptors));
+    RefPtr<FontFace> fontFace = adoptRef(new FontFace(context, family));
     fontFace->initCSSFontFace(static_cast<const unsigned char*>(source->baseAddress()), source->byteLength());
     return fontFace.release();
 }
 
 PassRefPtr<FontFace> FontFace::create(Document* document, const StyleRuleFontFace* fontFaceRule)
 {
     const StylePropertySet& properties = fontFaceRule->properties();
 
     // Obtain the font-family property and the src property. Both must be defined.
     RefPtr<CSSValue> family = properties.getPropertyCSSValue(CSSPropertyFontFamily);
@@ skipping 18 matching lines @@
         return fontFace.release();
     }
     return nullptr;
 }
 
 FontFace::FontFace()
     : m_status(Unloaded)
 {
 }
 
-FontFace::FontFace(ExecutionContext* context, const AtomicString& family, const Dictionary& descriptors)
+FontFace::FontFace(ExecutionContext* context, const AtomicString& family)
     : m_family(family)
     , m_status(Unloaded)
 {
-    Document* document = toDocument(context);
-    String value;
-    if (DictionaryHelper::get(descriptors, "style", value))
-        setPropertyFromString(document, value, CSSPropertyFontStyle);
-    if (DictionaryHelper::get(descriptors, "weight", value))
-        setPropertyFromString(document, value, CSSPropertyFontWeight);
-    if (DictionaryHelper::get(descriptors, "stretch", value))
-        setPropertyFromString(document, value, CSSPropertyFontStretch);
-    if (DictionaryHelper::get(descriptors, "unicodeRange", value))
-        setPropertyFromString(document, value, CSSPropertyUnicodeRange);
-    if (DictionaryHelper::get(descriptors, "variant", value))
-        setPropertyFromString(document, value, CSSPropertyFontVariant);
-    if (DictionaryHelper::get(descriptors, "featureSettings", value))
-        setPropertyFromString(document, value, CSSPropertyWebkitFontFeatureSettings);
 }
 
 FontFace::~FontFace()
 {
 }
 
 String FontFace::style() const
 {
     return m_style ? m_style->cssText() : "normal";
 }
@@ skipping 54 matching lines @@
 }
 
 void FontFace::setPropertyFromString(const Document* document, const String& s, CSSPropertyID propertyID, ExceptionState* exceptionState)
 {
     RefPtr<CSSValue> value = parseCSSValue(document, s, propertyID);
     if (value && setPropertyValue(value, propertyID))
         return;
 
     String message = "Failed to set '" + s + "' as a property value.";
     if (exceptionState)
-        exceptionState->throwDOMException(SyntaxError, message);
+        exceptionState->ThrowDOMException(SyntaxError, message);
     else
         setError(DOMException::create(SyntaxError, message));
 }
 
 bool FontFace::setPropertyFromStyle(const StylePropertySet& properties, CSSPropertyID propertyID)
 {
     return setPropertyValue(properties.getPropertyCSSValue(propertyID), propertyID);
 }
 
 bool FontFace::setPropertyValue(PassRefPtr<CSSValue> value, CSSPropertyID propertyID)
@@ skipping 82 matching lines @@
     }
     return emptyString();
 }
 
 void FontFace::setLoadStatus(LoadStatus status)
 {
     m_status = status;
     ASSERT(m_status != Error || m_error);
 
     if (m_status == Loaded || m_status == Error) {
-        if (m_loadedProperty) {
-            if (m_status == Loaded)
-                m_loadedProperty->resolve(this);
-            else
-                m_loadedProperty->reject(m_error.get());
-        }
-
         Vector<RefPtr<LoadFontCallback> > callbacks;
         m_callbacks.swap(callbacks);
         for (size_t i = 0; i < callbacks.size(); ++i) {
             if (m_status == Loaded)
                 callbacks[i]->notifyLoaded(this);
             else
                 callbacks[i]->notifyError(this);
         }
     }
 }
 
 void FontFace::setError(PassRefPtr<DOMException> error)
 {
     if (!m_error)
         m_error = error ? error : DOMException::create(NetworkError);
     setLoadStatus(Error);
 }
 
-ScriptPromise FontFace::fontStatusPromise(ScriptState* scriptState)
-{
-    if (!m_loadedProperty) {
-        m_loadedProperty = adoptPtr(new LoadedProperty(scriptState->executionContext(), this, LoadedProperty::Loaded));
-        if (m_status == Loaded)
-            m_loadedProperty->resolve(this);
-        else if (m_status == Error)
-            m_loadedProperty->reject(m_error.get());
-    }
-    return m_loadedProperty->promise(scriptState->world());
-}
-
-ScriptPromise FontFace::load(ScriptState* scriptState)
-{
-    loadInternal(scriptState->executionContext());
-    return fontStatusPromise(scriptState);
-}
-
 void FontFace::loadWithCallback(PassRefPtr<LoadFontCallback> callback, ExecutionContext* context)
 {
     loadInternal(context);
     if (m_status == Loaded)
         callback->notifyLoaded(this);
     else if (m_status == Error)
         callback->notifyError(this);
     else
         m_callbacks.append(callback);
 }
@@ skipping 166 matching lines @@
         setError(DOMException::create(SyntaxError, "Invalid font data in ArrayBuffer."));
     m_cssFontFace->addSource(source.release());
 }
 
 bool FontFace::hadBlankText() const
 {
     return m_cssFontFace->hadBlankText();
 }
 
 } // namespace blink