#include "config.h"
#include "core/dom/DOMImplementation.h"
-#include "HTMLNames.h"
-#include "SVGNames.h"
-#include "bindings/v8/ExceptionState.h"
+#include "bindings/core/v8/ExceptionState.h"
+#include "core/HTMLNames.h"
+#include "core/SVGNames.h"
#include "core/css/CSSStyleSheet.h"
#include "core/css/MediaList.h"
#include "core/css/StyleSheetContents.h"
#include "core/dom/DocumentType.h"
#include "core/dom/Element.h"
#include "core/dom/ExceptionCode.h"
+#include "core/dom/Text.h"
+#include "core/dom/XMLDocument.h"
#include "core/dom/custom/CustomElementRegistrationContext.h"
+#include "core/frame/LocalFrame.h"
+#include "core/frame/UseCounter.h"
#include "core/html/HTMLDocument.h"
+#include "core/html/HTMLHeadElement.h"
#include "core/html/HTMLMediaElement.h"
+#include "core/html/HTMLTitleElement.h"
#include "core/html/HTMLViewSourceDocument.h"
#include "core/html/ImageDocument.h"
#include "core/html/MediaDocument.h"
#include "core/html/PluginDocument.h"
#include "core/html/TextDocument.h"
#include "core/loader/FrameLoader.h"
-#include "core/frame/Frame.h"
#include "core/page/Page.h"
-#include "core/platform/MIMETypeRegistry.h"
-#include "core/platform/graphics/Image.h"
-#include "core/platform/graphics/MediaPlayer.h"
-#include "core/plugins/PluginData.h"
-#include "core/svg/SVGDocument.h"
#include "platform/ContentType.h"
-#include "weborigin/SecurityOrigin.h"
+#include "platform/MIMETypeRegistry.h"
+#include "platform/graphics/Image.h"
+#include "platform/graphics/media/MediaPlayer.h"
+#include "platform/plugins/PluginData.h"
+#include "platform/weborigin/SecurityOrigin.h"
#include "wtf/StdLibExtras.h"
-namespace WebCore {
+namespace blink {
typedef HashSet<String, CaseFoldingHash> FeatureSet;
addString(svgFeatures, "GraphicsAttribute");
addString(svgFeatures, "BaseGraphicsAttribute");
addString(svgFeatures, "Marker");
-// addString(svgFeatures, "ColorProfile"); // requires color-profile, bug 6037
+// addString(svgFeatures, "ColorProfile");
addString(svgFeatures, "Gradient");
addString(svgFeatures, "Pattern");
addString(svgFeatures, "Clip");
addString(svgFeatures, "Cursor");
addString(svgFeatures, "Hyperlinking");
addString(svgFeatures, "XlinkAttribute");
- addString(svgFeatures, "ExternalResourcesRequired");
addString(svgFeatures, "View");
addString(svgFeatures, "Script");
addString(svgFeatures, "Animation");
&& svgFeatures.contains(feature.right(feature.length() - 35));
}
-DOMImplementation::DOMImplementation(Document* document)
+DOMImplementation::DOMImplementation(Document& document)
: m_document(document)
{
- ScriptWrappable::init(this);
}
bool DOMImplementation::hasFeature(const String& feature, const String& version)
return true;
}
-PassRefPtr<DocumentType> DOMImplementation::createDocumentType(const String& qualifiedName,
- const String& publicId, const String& systemId, ExceptionState& es)
+bool DOMImplementation::hasFeatureForBindings(const String& feature, const String& version)
{
- String prefix, localName;
- if (!Document::parseQualifiedName(qualifiedName, prefix, localName, es))
- return 0;
-
- return DocumentType::create(m_document, qualifiedName, publicId, systemId);
+ if (!hasFeature(feature, version)) {
+ UseCounter::count(m_document, UseCounter::DOMImplementationHasFeatureReturnFalse);
+ return false;
+ }
+ return true;
}
-DOMImplementation* DOMImplementation::getInterface(const String& /*feature*/)
+PassRefPtrWillBeRawPtr<DocumentType> DOMImplementation::createDocumentType(const AtomicString& qualifiedName,
+ const String& publicId, const String& systemId, ExceptionState& exceptionState)
{
- return 0;
+ AtomicString prefix, localName;
+ if (!Document::parseQualifiedName(qualifiedName, prefix, localName, exceptionState))
+ return nullptr;
+
+ return DocumentType::create(m_document, qualifiedName, publicId, systemId);
}
-PassRefPtr<Document> DOMImplementation::createDocument(const String& namespaceURI,
- const String& qualifiedName, DocumentType* doctype, ExceptionState& es)
+PassRefPtrWillBeRawPtr<XMLDocument> DOMImplementation::createDocument(const AtomicString& namespaceURI,
+ const AtomicString& qualifiedName, DocumentType* doctype, ExceptionState& exceptionState)
{
- RefPtr<Document> doc;
- DocumentInit init = DocumentInit::fromContext(m_document->contextDocument());
+ RefPtrWillBeRawPtr<XMLDocument> doc = nullptr;
+ DocumentInit init = DocumentInit::fromContext(document().contextDocument());
if (namespaceURI == SVGNames::svgNamespaceURI) {
- doc = SVGDocument::create(init);
+ doc = XMLDocument::createSVG(init);
} else if (namespaceURI == HTMLNames::xhtmlNamespaceURI) {
- doc = Document::createXHTML(init.withRegistrationContext(m_document->registrationContext()));
+ doc = XMLDocument::createXHTML(init.withRegistrationContext(document().registrationContext()));
} else {
- doc = Document::create(init);
+ doc = XMLDocument::create(init);
}
- doc->setSecurityOrigin(m_document->securityOrigin()->isolatedCopy());
- doc->setContextFeatures(m_document->contextFeatures());
+ doc->setSecurityOrigin(document().securityOrigin()->isolatedCopy());
+ doc->setContextFeatures(document().contextFeatures());
- RefPtr<Node> documentElement;
+ RefPtrWillBeRawPtr<Node> documentElement = nullptr;
if (!qualifiedName.isEmpty()) {
- documentElement = doc->createElementNS(namespaceURI, qualifiedName, es);
- if (es.hadException())
- return 0;
+ documentElement = doc->createElementNS(namespaceURI, qualifiedName, exceptionState);
+ if (exceptionState.hadException())
+ return nullptr;
}
if (doctype)
return doc.release();
}
-PassRefPtr<CSSStyleSheet> DOMImplementation::createCSSStyleSheet(const String&, const String& media)
-{
- // FIXME: Title should be set.
- // FIXME: Media could have wrong syntax, in which case we should generate an exception.
- RefPtr<CSSStyleSheet> sheet = CSSStyleSheet::create(StyleSheetContents::create());
- sheet->setMediaQueries(MediaQuerySet::create(media));
- return sheet;
-}
-
bool DOMImplementation::isXMLMIMEType(const String& mimeType)
{
- if (mimeType == "text/xml" || mimeType == "application/xml" || mimeType == "text/xsl")
+ if (equalIgnoringCase(mimeType, "text/xml")
+ || equalIgnoringCase(mimeType, "application/xml")
+ || equalIgnoringCase(mimeType, "text/xsl"))
return true;
- // Per RFCs 3023 and 2045 a mime type is of the form:
+ // Per RFCs 3023 and 2045, an XML MIME type is of the form:
// ^[0-9a-zA-Z_\\-+~!$\\^{}|.%'`#&*]+/[0-9a-zA-Z_\\-+~!$\\^{}|.%'`#&*]+\+xml$
int length = mimeType.length();
if (length < 7)
return false;
- if (mimeType[0] == '/' ||
- mimeType[length - 5] == '/' ||
- mimeType[length - 4] != '+' ||
- mimeType[length - 3] != 'x' ||
- mimeType[length - 2] != 'm' ||
- mimeType[length - 1] != 'l')
+ if (mimeType[0] == '/' || mimeType[length - 5] == '/' || !mimeType.endsWith("+xml", false))
return false;
bool hasSlash = false;
return true;
}
-bool DOMImplementation::isTextMIMEType(const String& mimeType)
+bool DOMImplementation::isJSONMIMEType(const String& mimeType)
{
- if (MIMETypeRegistry::isSupportedJavaScriptMIMEType(mimeType)
- || mimeType == "application/json" // Render JSON as text/plain.
- || (mimeType.startsWith("text/") && mimeType != "text/html"
- && mimeType != "text/xml" && mimeType != "text/xsl"))
+ if (mimeType.startsWith("application/json", false))
return true;
-
+ if (mimeType.startsWith("application/", false)) {
+ size_t subtype = mimeType.find("+json", 12, false);
+ if (subtype != kNotFound) {
+ // Just check that a parameter wasn't matched.
+ size_t parameterMarker = mimeType.find(";");
+ if (parameterMarker == kNotFound) {
+ unsigned endSubtype = static_cast<unsigned>(subtype) + 5;
+ return endSubtype == mimeType.length() || isASCIISpace(mimeType[endSubtype]);
+ }
+ return parameterMarker > subtype;
+ }
+ }
return false;
}
-PassRefPtr<HTMLDocument> DOMImplementation::createHTMLDocument(const String& title)
+static bool isTextPlainType(const String& mimeType)
+{
+ return mimeType.startsWith("text/", false)
+ && !(equalIgnoringCase(mimeType, "text/html")
+ || equalIgnoringCase(mimeType, "text/xml")
+ || equalIgnoringCase(mimeType, "text/xsl"));
+}
+
+bool DOMImplementation::isTextMIMEType(const String& mimeType)
+{
+ return MIMETypeRegistry::isSupportedJavaScriptMIMEType(mimeType) || isJSONMIMEType(mimeType) || isTextPlainType(mimeType);
+}
+
+PassRefPtrWillBeRawPtr<HTMLDocument> DOMImplementation::createHTMLDocument(const String& title)
{
- DocumentInit init = DocumentInit::fromContext(m_document->contextDocument())
- .withRegistrationContext(m_document->registrationContext());
- RefPtr<HTMLDocument> d = HTMLDocument::create(init);
+ DocumentInit init = DocumentInit::fromContext(document().contextDocument())
+ .withRegistrationContext(document().registrationContext());
+ RefPtrWillBeRawPtr<HTMLDocument> d = HTMLDocument::create(init);
d->open();
- d->write("<!doctype html><html><body></body></html>");
- if (!title.isNull())
- d->setTitle(title);
- d->setSecurityOrigin(m_document->securityOrigin()->isolatedCopy());
- d->setContextFeatures(m_document->contextFeatures());
+ d->write("<!doctype html><html><head></head><body></body></html>");
+ if (!title.isNull()) {
+ HTMLHeadElement* headElement = d->head();
+ ASSERT(headElement);
+ RefPtrWillBeRawPtr<HTMLTitleElement> titleElement = HTMLTitleElement::create(*d);
+ headElement->appendChild(titleElement);
+ titleElement->appendChild(d->createTextNode(title), ASSERT_NO_EXCEPTION);
+ }
+ d->setSecurityOrigin(document().securityOrigin()->isolatedCopy());
+ d->setContextFeatures(document().contextFeatures());
return d.release();
}
-PassRefPtr<Document> DOMImplementation::createDocument(const String& type, Frame* frame, const KURL& url, bool inViewSourceMode)
+PassRefPtrWillBeRawPtr<Document> DOMImplementation::createDocument(const String& type, LocalFrame* frame, const KURL& url, bool inViewSourceMode)
{
return createDocument(type, DocumentInit(url, frame), inViewSourceMode);
}
-PassRefPtr<Document> DOMImplementation::createDocument(const String& type, const DocumentInit& init, bool inViewSourceMode)
+PassRefPtrWillBeRawPtr<Document> DOMImplementation::createDocument(const String& type, const DocumentInit& init, bool inViewSourceMode)
{
if (inViewSourceMode)
return HTMLViewSourceDocument::create(init, type);
if (type == "text/html")
return HTMLDocument::create(init);
if (type == "application/xhtml+xml")
- return Document::createXHTML(init);
+ return XMLDocument::createXHTML(init);
PluginData* pluginData = 0;
if (init.frame() && init.frame()->page() && init.frame()->loader().allowPlugins(NotAboutToInstantiatePlugin))
if (isTextMIMEType(type))
return TextDocument::create(init);
if (type == "image/svg+xml")
- return SVGDocument::create(init);
+ return XMLDocument::createSVG(init);
if (isXMLMIMEType(type))
- return Document::create(init);
+ return XMLDocument::create(init);
return HTMLDocument::create(init);
}
+void DOMImplementation::trace(Visitor* visitor)
+{
+ visitor->trace(m_document);
+}
+
}
projects / platform / framework / web / crosswalk.git / blobdiff