Move HTML canvas and tracks from ExceptionCode to Exception
[WebKit-https.git] / Source / WebCore / html / track / TextTrack.cpp
index 20d53c6..8418058 100644 (file)
@@ -1,6 +1,6 @@
 /*
- * Copyright (C) 2011 Google Inc.  All rights reserved.
- * Copyright (C) 2011 Apple Inc.  All rights reserved.
+ * Copyright (C) 2011, 2013 Google Inc. All rights reserved.
+ * Copyright (C) 2011-2014 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
 #include "TextTrack.h"
 
 #include "Event.h"
-#include "ExceptionCode.h"
 #include "HTMLMediaElement.h"
+#include "SourceBuffer.h"
 #include "TextTrackCueList.h"
 #include "TextTrackList.h"
-#include "TrackBase.h"
+#include "VTTRegion.h"
+#include "VTTRegionList.h"
 
 namespace WebCore {
 
@@ -48,123 +49,208 @@ static const int invalidTrackIndex = -1;
 
 const AtomicString& TextTrack::subtitlesKeyword()
 {
-    DEFINE_STATIC_LOCAL(const AtomicString, subtitles, ("subtitles"));
+    static NeverDestroyed<const AtomicString> subtitles("subtitles", AtomicString::ConstructFromLiteral);
     return subtitles;
 }
 
-const AtomicString& TextTrack::captionsKeyword()
+static const AtomicString& captionsKeyword()
 {
-    DEFINE_STATIC_LOCAL(const AtomicString, captions, ("captions"));
+    static NeverDestroyed<const AtomicString> captions("captions", AtomicString::ConstructFromLiteral);
     return captions;
 }
 
-const AtomicString& TextTrack::descriptionsKeyword()
+static const AtomicString& descriptionsKeyword()
 {
-    DEFINE_STATIC_LOCAL(const AtomicString, descriptions, ("descriptions"));
+    static NeverDestroyed<const AtomicString> descriptions("descriptions", AtomicString::ConstructFromLiteral);
     return descriptions;
 }
 
-const AtomicString& TextTrack::chaptersKeyword()
+static const AtomicString& chaptersKeyword()
 {
-    DEFINE_STATIC_LOCAL(const AtomicString, chapters, ("chapters"));
+    static NeverDestroyed<const AtomicString> chapters("chapters", AtomicString::ConstructFromLiteral);
     return chapters;
 }
 
-const AtomicString& TextTrack::metadataKeyword()
+static const AtomicString& metadataKeyword()
 {
-    DEFINE_STATIC_LOCAL(const AtomicString, metadata, ("metadata"));
+    static NeverDestroyed<const AtomicString> metadata("metadata", AtomicString::ConstructFromLiteral);
     return metadata;
 }
+    
+static const AtomicString& forcedKeyword()
+{
+    static NeverDestroyed<const AtomicString> forced("forced", AtomicString::ConstructFromLiteral);
+    return forced;
+}
+
+TextTrack* TextTrack::captionMenuOffItem()
+{
+    static TextTrack& off = TextTrack::create(nullptr, nullptr, "off menu item", emptyAtom, emptyAtom, emptyAtom).leakRef();
+    return &off;
+}
+
+TextTrack* TextTrack::captionMenuAutomaticItem()
+{
+    static TextTrack& automatic = TextTrack::create(nullptr, nullptr, "automatic menu item", emptyAtom, emptyAtom, emptyAtom).leakRef();
+    return &automatic;
+}
 
-TextTrack::TextTrack(ScriptExecutionContext* context, TextTrackClient* client, const String& kind, const String& label, const String& language, TextTrackType type)
-    : TrackBase(context, TrackBase::TextTrack)
-    , m_mediaElement(0)
-    , m_label(label)
-    , m_language(language)
-    , m_mode(TextTrack::DISABLED)
+TextTrack::TextTrack(ScriptExecutionContext* context, TextTrackClient* client, const AtomicString& kind, const AtomicString& id, const AtomicString& label, const AtomicString& language, TextTrackType type)
+    : TrackBase(TrackBase::TextTrack, id, label, language)
+    , m_scriptExecutionContext(context)
     , m_client(client)
     , m_trackType(type)
-    , m_readinessState(NotLoaded)
-    , m_showingByDefault(false)
     , m_trackIndex(invalidTrackIndex)
+    , m_renderedTrackIndex(invalidTrackIndex)
 {
-    setKind(kind);
+    if (kind == captionsKeyword())
+        m_kind = Kind::Captions;
+    else if (kind == chaptersKeyword())
+        m_kind = Kind::Chapters;
+    else if (kind == descriptionsKeyword())
+        m_kind = Kind::Descriptions;
+    else if (kind == forcedKeyword())
+        m_kind = Kind::Forced;
+    else if (kind == metadataKeyword())
+        m_kind = Kind::Metadata;
 }
 
 TextTrack::~TextTrack()
 {
-    if (m_client && m_cues)
-        m_client->textTrackRemoveCues(this, m_cues.get());
-    clearClient();
+    if (m_cues) {
+        if (m_client)
+            m_client->textTrackRemoveCues(this, m_cues.get());
+
+        for (size_t i = 0; i < m_cues->length(); ++i)
+            m_cues->item(i)->setTrack(nullptr);
+    }
+    if (m_regions) {
+        for (size_t i = 0; i < m_regions->length(); ++i)
+            m_regions->item(i)->setTrack(nullptr);
+    }
 }
 
-bool TextTrack::isValidKindKeyword(const String& value)
+bool TextTrack::enabled() const
 {
-    if (equalIgnoringCase(value, subtitlesKeyword()))
+    return m_mode != Mode::Disabled;
+}
+
+bool TextTrack::isValidKindKeyword(const AtomicString& value)
+{
+    if (value == subtitlesKeyword())
+        return true;
+    if (value == captionsKeyword())
         return true;
-    if (equalIgnoringCase(value, captionsKeyword()))
+    if (value == descriptionsKeyword())
         return true;
-    if (equalIgnoringCase(value, descriptionsKeyword()))
+    if (value == chaptersKeyword())
         return true;
-    if (equalIgnoringCase(value, chaptersKeyword()))
+    if (value == metadataKeyword())
         return true;
-    if (equalIgnoringCase(value, metadataKeyword()))
+    if (value == forcedKeyword())
         return true;
 
     return false;
 }
 
-void TextTrack::setKind(const String& kind)
+const AtomicString& TextTrack::kindKeyword() const
+{
+    switch (m_kind) {
+    case Kind::Captions:
+        return captionsKeyword();
+    case Kind::Chapters:
+        return chaptersKeyword();
+    case Kind::Descriptions:
+        return descriptionsKeyword();
+    case Kind::Forced:
+        return forcedKeyword();
+    case Kind::Metadata:
+        return metadataKeyword();
+    case Kind::Subtitles:
+        return subtitlesKeyword();
+    }
+    ASSERT_NOT_REACHED();
+    return subtitlesKeyword();
+}
+
+void TextTrack::setKind(Kind newKind)
 {
-    String oldKind = m_kind;
+    auto oldKind = m_kind;
+
+    // 10.1 kind, on setting:
+    // 1. If the value being assigned to this attribute does not match one of the text track kinds,
+    // then abort these steps.
 
-    if (isValidKindKeyword(kind))
-        m_kind = kind;
-    else
-        m_kind = subtitlesKeyword();
+    // 2. Update this attribute to the new value.
+    m_kind = newKind;
+
+#if ENABLE(MEDIA_SOURCE)
+    // 3. If the sourceBuffer attribute on this track is not null, then queue a task to fire a simple
+    // event named change at sourceBuffer.textTracks.
+    if (m_sourceBuffer)
+        m_sourceBuffer->textTracks()->scheduleChangeEvent();
+
+    // 4. Queue a task to fire a simple event named change at the TextTrackList object referenced by
+    // the textTracks attribute on the HTMLMediaElement.
+    if (mediaElement())
+        mediaElement()->textTracks().scheduleChangeEvent();
+#endif
 
     if (m_client && oldKind != m_kind)
         m_client->textTrackKindChanged(this);
 }
 
-void TextTrack::setMode(unsigned short mode, ExceptionCode& ec)
+void TextTrack::setKindKeywordIgnoringASCIICase(StringView keyword)
 {
-    // 4.8.10.12.5 On setting the mode, if the new value is not either 0, 1, or 2,
-    // the user agent must throw an INVALID_ACCESS_ERR exception.
-    if (mode > TextTrack::SHOWING) {
-        ec = INVALID_ACCESS_ERR;
+    if (keyword.isNull()) {
+        // The missing value default is the subtitles state.
+        setKind(Kind::Subtitles);
         return;
     }
+    if (equalLettersIgnoringASCIICase(keyword, "captions"))
+        setKind(Kind::Captions);
+    else if (equalLettersIgnoringASCIICase(keyword, "chapters"))
+        setKind(Kind::Chapters);
+    else if (equalLettersIgnoringASCIICase(keyword, "descriptions"))
+        setKind(Kind::Descriptions);
+    else if (equalLettersIgnoringASCIICase(keyword, "forced"))
+        setKind(Kind::Forced);
+    else if (equalLettersIgnoringASCIICase(keyword, "metadata"))
+        setKind(Kind::Metadata);
+    else if (equalLettersIgnoringASCIICase(keyword, "subtitles"))
+        setKind(Kind::Subtitles);
+    else {
+        // The invalid value default is the metadata state.
+        setKind(Kind::Metadata);
+    }
+}
 
-    if (m_mode == static_cast<Mode>(mode))
+void TextTrack::setMode(Mode mode)
+{
+    // On setting, if the new value isn't equal to what the attribute would currently
+    // return, the new value must be processed as follows ...
+    if (m_mode == mode)
         return;
 
     // If mode changes to disabled, remove this track's cues from the client
     // because they will no longer be accessible from the cues() function.
-    if (mode == TextTrack::DISABLED && m_client && m_cues)
+    if (mode == Mode::Disabled && m_client && m_cues)
         m_client->textTrackRemoveCues(this, m_cues.get());
-         
-    if (mode != TextTrack::SHOWING && m_cues)
-        for (size_t i = 0; i < m_cues->length(); ++i)
-            m_cues->item(i)->removeDisplayTree();
 
-    //  ... Note: If the mode had been showing by default, this will change it to showing, 
-    // even though the value of mode would appear not to change.
-    m_mode = static_cast<Mode>(mode);
-    setShowingByDefault(false);
+    if (mode != Mode::Showing && m_cues) {
+        for (size_t i = 0; i < m_cues->length(); ++i) {
+            TextTrackCue* cue = m_cues->item(i);
+            if (cue->isRenderable())
+                toVTTCue(cue)->removeDisplayTree();
+        }
+    }
+
+    m_mode = mode;
 
     if (m_client)
         m_client->textTrackModeChanged(this);
 }
 
-TextTrack::Mode TextTrack::mode() const
-{
-    // The text track "showing" and "showing by default" modes return SHOWING (numeric value 2)
-    if (m_showingByDefault)
-        return SHOWING;
-    return m_mode;
-}
-
 TextTrackCueList* TextTrack::cues()
 {
     // 4.8.10.12.5 If the text track mode ... is not the text track disabled mode,
@@ -172,9 +258,23 @@ TextTrackCueList* TextTrack::cues()
     // Otherwise, it must return null. When an object is returned, the
     // same object must be returned each time.
     // http://www.whatwg.org/specs/web-apps/current-work/#dom-texttrack-cues
-    if (m_mode != TextTrack::DISABLED)
-        return ensureTextTrackCueList();
-    return 0;
+    if (m_mode == Mode::Disabled)
+        return nullptr;
+    return &ensureTextTrackCueList();
+}
+
+void TextTrack::removeAllCues()
+{
+    if (!m_cues)
+        return;
+
+    if (m_client)
+        m_client->textTrackRemoveCues(this, m_cues.get());
+    
+    for (size_t i = 0; i < m_cues->length(); ++i)
+        m_cues->item(i)->setTrack(nullptr);
+    
+    m_cues = nullptr;
 }
 
 TextTrackCueList* TextTrack::activeCues() const
@@ -185,74 +285,139 @@ TextTrackCueList* TextTrack::activeCues() const
     // order. Otherwise, it must return null. When an object is returned, the
     // same object must be returned each time.
     // http://www.whatwg.org/specs/web-apps/current-work/#dom-texttrack-activecues
-    if (m_cues && m_mode != TextTrack::DISABLED)
-        return m_cues->activeCues();
-    return 0;
+    if (!m_cues || m_mode == Mode::Disabled)
+        return nullptr;
+    return m_cues->activeCues();
 }
 
-void TextTrack::addCue(PassRefPtr<TextTrackCue> prpCue, ExceptionCode& ec)
+ExceptionOr<void> TextTrack::addCue(RefPtr<TextTrackCue>&& cue)
 {
-    if (!prpCue)
-        return;
+    if (!cue)
+        return { };
+
+    // 4.7.10.12.6 Text tracks exposing in-band metadata
+    // The UA will use DataCue to expose only text track cue objects that belong to a text track that has a text
+    // track kind of metadata.
+    // If a DataCue is added to a TextTrack via the addCue() method but the text track does not have its text
+    // track kind set to metadata, throw a InvalidNodeTypeError exception and don't add the cue to the TextTrackList
+    // of the TextTrack.
+    if (cue->cueType() == TextTrackCue::Data && m_kind != Kind::Metadata)
+        return Exception { INVALID_NODE_TYPE_ERR };
 
-    RefPtr<TextTrackCue> cue = prpCue;
+    // TODO(93143): Add spec-compliant behavior for negative time values.
+    if (!cue->startMediaTime().isValid() || !cue->endMediaTime().isValid() || cue->startMediaTime() < MediaTime::zeroTime() || cue->endMediaTime() < MediaTime::zeroTime())
+        return { };
 
-    // 4.8.10.12.4 Text track API
+    // 4.8.10.12.5 Text track API
 
     // The addCue(cue) method of TextTrack objects, when invoked, must run the following steps:
 
-    // 1. If the given cue is already associated with a text track other than 
-    // the method's TextTrack object's text track, then throw an InvalidStateError
-    // exception and abort these steps.
+    // 1. If the given cue is in a text track list of cues, then remove cue from that text track
+    // list of cues.
     TextTrack* cueTrack = cue->track();
-    if (cueTrack && cueTrack != this) {
-        ec = INVALID_STATE_ERR;
-        return;
-    }
+    if (cueTrack && cueTrack != this)
+        cueTrack->removeCue(cue.get());
 
-    // 2. Associate cue with the method's TextTrack object's text track, if it is 
-    // not currently associated with a text track.
+    // 2. Add cue to the method's TextTrack object's text track's text track list of cues.
     cue->setTrack(this);
-
-    // 3. If the given cue is already listed in the method's TextTrack object's text
-    // track's text track list of cues, then throw an InvalidStateError exception.
-    // 4. Add cue to the method's TextTrack object's text track's text track list of cues.
-    if (!ensureTextTrackCueList()->add(cue)) {
-        ec = INVALID_STATE_ERR;
-        return;
-    }
+    ensureTextTrackCueList().add(cue);
     
     if (m_client)
-        m_client->textTrackAddCue(this, cue.get());
+        m_client->textTrackAddCue(this, *cue);
+
+    return { };
 }
 
-void TextTrack::removeCue(TextTrackCue* cue, ExceptionCode& ec)
+ExceptionOr<void> TextTrack::removeCue(TextTrackCue* cue)
 {
     if (!cue)
-        return;
+        return { };
 
-    // 4.8.10.12.4 Text track API
+    // 4.8.10.12.5 Text track API
 
     // The removeCue(cue) method of TextTrack objects, when invoked, must run the following steps:
 
-    // 1. If the given cue is not associated with the method's TextTrack 
-    // object's text track, then throw an InvalidStateError exception.
-    if (cue->track() != this) {
-        ec = INVALID_STATE_ERR;
-        return;
-    }
-    
-    // 2. If the given cue is not currently listed in the method's TextTrack 
+    // 1. If the given cue is not currently listed in the method's TextTrack 
     // object's text track's text track list of cues, then throw a NotFoundError exception.
-    // 3. Remove cue from the method's TextTrack object's text track's text track list of cues.
-    if (!m_cues || !m_cues->remove(cue)) {
-        ec = INVALID_STATE_ERR;
+    if (cue->track() != this)
+        return Exception { NOT_FOUND_ERR };
+
+    // 2. Remove cue from the method's TextTrack object's text track's text track list of cues.
+    if (!m_cues || !m_cues->remove(cue))
+        return Exception { INVALID_STATE_ERR };
+
+    cue->setTrack(nullptr);
+    if (m_client)
+        m_client->textTrackRemoveCue(this, *cue);
+
+    return { };
+}
+
+VTTRegionList& TextTrack::ensureVTTRegionList()
+{
+    if (!m_regions)
+        m_regions = VTTRegionList::create();
+
+    return *m_regions;
+}
+
+VTTRegionList* TextTrack::regions()
+{
+    // If the text track mode of the text track that the TextTrack object
+    // represents is not the text track disabled mode, then the regions
+    // attribute must return a live VTTRegionList object that represents
+    // the text track list of regions of the text track. Otherwise, it must
+    // return null. When an object is returned, the same object must be returned
+    // each time.
+    if (m_mode == Mode::Disabled)
+        return nullptr;
+    return &ensureVTTRegionList();
+}
+
+void TextTrack::addRegion(RefPtr<VTTRegion>&& region)
+{
+    if (!region)
+        return;
+
+    auto& regionList = ensureVTTRegionList();
+
+    // 1. If the given region is in a text track list of regions, then remove
+    // region from that text track list of regions.
+    auto* regionTrack = region->track();
+    if (regionTrack && regionTrack != this)
+        regionTrack->removeRegion(region.get());
+
+    // 2. If the method's TextTrack object's text track list of regions contains
+    // a region with the same identifier as region replace the values of that
+    // region's width, height, anchor point, viewport anchor point and scroll
+    // attributes with those of region.
+    auto* existingRegion = regionList.getRegionById(region->id());
+    if (existingRegion) {
+        existingRegion->updateParametersFromRegion(*region);
         return;
     }
 
-    cue->setTrack(0);
-    if (m_client)
-        m_client->textTrackRemoveCue(this, cue);
+    // Otherwise: add region to the method's TextTrack object's text track
+    // list of regions.
+    region->setTrack(this);
+    regionList.add(WTFMove(region));
+}
+
+ExceptionOr<void> TextTrack::removeRegion(VTTRegion* region)
+{
+    if (!region)
+        return { };
+
+    // 1. If the given region is not currently listed in the method's TextTrack
+    // object's text track list of regions, then throw a NotFoundError exception.
+    if (region->track() != this)
+        return Exception { NOT_FOUND_ERR };
+
+    if (!m_regions || !m_regions->remove(region))
+        return Exception { INVALID_STATE_ERR };
+
+    region->setTrack(nullptr);
+    return { };
 }
 
 void TextTrack::cueWillChange(TextTrackCue* cue)
@@ -262,7 +427,7 @@ void TextTrack::cueWillChange(TextTrackCue* cue)
 
     // The cue may need to be repositioned in the media element's interval tree, may need to
     // be re-rendered, etc, so remove it before the modification...
-    m_client->textTrackRemoveCue(this, cue);
+    m_client->textTrackRemoveCue(this, *cue);
 }
 
 void TextTrack::cueDidChange(TextTrackCue* cue)
@@ -270,8 +435,11 @@ void TextTrack::cueDidChange(TextTrackCue* cue)
     if (!m_client)
         return;
 
+    // Make sure the TextTrackCueList order is up-to-date.
+    ensureTextTrackCueList().updateCueIndex(cue);
+
     // ... and add it back again.
-    m_client->textTrackAddCue(this, cue);
+    m_client->textTrackAddCue(this, *cue);
 }
 
 int TextTrack::trackIndex()
@@ -279,7 +447,7 @@ int TextTrack::trackIndex()
     ASSERT(m_mediaElement);
 
     if (m_trackIndex == invalidTrackIndex)
-        m_trackIndex = m_mediaElement->textTracks()->getTrackIndex(this);
+        m_trackIndex = m_mediaElement->textTracks().getTrackIndex(*this);
 
     return m_trackIndex;
 }
@@ -287,16 +455,130 @@ int TextTrack::trackIndex()
 void TextTrack::invalidateTrackIndex()
 {
     m_trackIndex = invalidTrackIndex;
+    m_renderedTrackIndex = invalidTrackIndex;
 }
 
-TextTrackCueList* TextTrack::ensureTextTrackCueList()
+bool TextTrack::isRendered()
+{
+    return (m_kind == Kind::Captions || m_kind == Kind::Subtitles || m_kind == Kind::Forced)
+        && m_mode == Mode::Showing;
+}
+
+TextTrackCueList& TextTrack::ensureTextTrackCueList()
 {
     if (!m_cues)
         m_cues = TextTrackCueList::create();
+    return *m_cues;
+}
 
-    return m_cues.get();
+int TextTrack::trackIndexRelativeToRenderedTracks()
+{
+    ASSERT(m_mediaElement);
+    
+    if (m_renderedTrackIndex == invalidTrackIndex)
+        m_renderedTrackIndex = m_mediaElement->textTracks().getTrackIndexRelativeToRenderedTracks(*this);
+    
+    return m_renderedTrackIndex;
 }
 
+bool TextTrack::hasCue(TextTrackCue* cue, TextTrackCue::CueMatchRules match)
+{
+    if (cue->startMediaTime() < MediaTime::zeroTime() || cue->endMediaTime() < MediaTime::zeroTime())
+        return false;
+    
+    if (!m_cues || !m_cues->length())
+        return false;
+    
+    size_t searchStart = 0;
+    size_t searchEnd = m_cues->length();
+    
+    while (1) {
+        ASSERT(searchStart <= m_cues->length());
+        ASSERT(searchEnd <= m_cues->length());
+        
+        TextTrackCue* existingCue;
+        
+        // Cues in the TextTrackCueList are maintained in start time order.
+        if (searchStart == searchEnd) {
+            if (!searchStart)
+                return false;
+
+            // If there is more than one cue with the same start time, back up to first one so we
+            // consider all of them.
+            while (searchStart >= 2 && cue->hasEquivalentStartTime(*m_cues->item(searchStart - 2)))
+                --searchStart;
+            
+            bool firstCompare = true;
+            while (1) {
+                if (!firstCompare)
+                    ++searchStart;
+                firstCompare = false;
+                if (searchStart > m_cues->length())
+                    return false;
+
+                existingCue = m_cues->item(searchStart - 1);
+                if (!existingCue)
+                    return false;
+
+                if (cue->startMediaTime() > (existingCue->startMediaTime() + startTimeVariance()))
+                    return false;
+
+                if (existingCue->isEqual(*cue, match))
+                    return true;
+            }
+        }
+        
+        size_t index = (searchStart + searchEnd) / 2;
+        existingCue = m_cues->item(index);
+        if ((cue->startMediaTime() + startTimeVariance()) < existingCue->startMediaTime() || (match != TextTrackCue::IgnoreDuration && cue->hasEquivalentStartTime(*existingCue) && cue->endMediaTime() > existingCue->endMediaTime()))
+            searchEnd = index;
+        else
+            searchStart = index + 1;
+    }
+    
+    ASSERT_NOT_REACHED();
+    return false;
+}
+
+bool TextTrack::isMainProgramContent() const
+{
+    // "Main program" content is intrinsic to the presentation of the media file, regardless of locale. Content such as
+    // directors commentary is not "main program" because it is not essential for the presentation. HTML5 doesn't have
+    // a way to express this in a machine-reable form, it is typically done with the track label, so we assume that caption
+    // tracks are main content and all other track types are not.
+    return m_kind == Kind::Captions;
+}
+
+bool TextTrack::containsOnlyForcedSubtitles() const
+{
+    return m_kind == Kind::Forced;
+}
+
+#if ENABLE(MEDIA_SOURCE)
+
+void TextTrack::setLanguage(const AtomicString& language)
+{
+    // 11.1 language, on setting:
+    // 1. If the value being assigned to this attribute is not an empty string or a BCP 47 language
+    // tag[BCP47], then abort these steps.
+    // FIXME(123926): Validate the BCP47-ness of langague.
+
+    // 2. Update this attribute to the new value.
+    TrackBase::setLanguage(language);
+
+    // 3. If the sourceBuffer attribute on this track is not null, then queue a task to fire a simple
+    // event named change at sourceBuffer.textTracks.
+    if (m_sourceBuffer)
+        m_sourceBuffer->textTracks()->scheduleChangeEvent();
+
+    // 4. Queue a task to fire a simple event named change at the TextTrackList object referenced by
+    // the textTracks attribute on the HTMLMediaElement.
+    if (mediaElement())
+        mediaElement()->textTracks().scheduleChangeEvent();
+}
+
+#endif
+
 } // namespace WebCore
 
 #endif