Delete ScriptableDocumentParser

sky/engine/core/html/parser/HTMLConstructionSite.cpp

 /*
  * Copyright (C) 2010 Google, Inc. All Rights Reserved.
  * Copyright (C) 2011 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 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
@@ skipping 28 matching lines @@
 #include "core/html/parser/HTMLToken.h"
 #include "core/loader/FrameLoaderClient.h"
 #include "platform/NotImplemented.h"
 #include "platform/text/TextBreakIterator.h"
 #include <limits>
 
 namespace blink {
 
 static const unsigned maximumHTMLParserDOMTreeDepth = 512;
 
-static inline void setAttributes(Element* element, AtomicHTMLToken* token, ParserContentPolicy parserContentPolicy)
+static inline void setAttributes(Element* element, AtomicHTMLToken* token)
 {
-    if (!scriptingContentIsAllowed(parserContentPolicy))
-        element->stripScriptingAttributes(token->attributes());
+    element->stripScriptingAttributes(token->attributes());
     element->parserSetAttributes(token->attributes());
 }
 
 static bool shouldUseLengthLimit(const ContainerNode& node)
 {
     return !isHTMLScriptElement(node)
         && !isHTMLStyleElement(node);
 }
 
 static unsigned textLengthLimitForContainer(const ContainerNode& node)
@@ skipping 141 matching lines @@
 
 void HTMLConstructionSite::queueTask(const HTMLConstructionSiteTask& task)
 {
     flushPendingText();
     ASSERT(m_pendingText.isEmpty());
     m_taskQueue.append(task);
 }
 
 void HTMLConstructionSite::attachLater(ContainerNode* parent, PassRefPtrWillBeRawPtr<Node> prpChild, bool selfClosing)
 {
-    ASSERT(scriptingContentIsAllowed(m_parserContentPolicy) || !prpChild.get()->isElementNode());
-
     HTMLConstructionSiteTask task(HTMLConstructionSiteTask::Insert);
     task.parent = parent;
     task.child = prpChild;
     task.selfClosing = selfClosing;
 
     // Add as a sibling of the parent if we have reached the maximum depth allowed.
     if (m_openElements.stackDepth() > maximumHTMLParserDOMTreeDepth && task.parent->parentNode())
         task.parent = task.parent->parentNode();
 
     ASSERT(task.parent);
@@ skipping 12 matching lines @@
     // re-enters the parser.
     TaskQueue queue;
     queue.swap(m_taskQueue);
 
     for (size_t i = 0; i < size; ++i)
         executeTask(queue[i]);
 
     // We might be detached now.
 }
 
-HTMLConstructionSite::HTMLConstructionSite(Document* document, ParserContentPolicy parserContentPolicy)
+HTMLConstructionSite::HTMLConstructionSite(Document* document)
     : m_document(document)
     , m_attachmentRoot(document)
-    , m_parserContentPolicy(parserContentPolicy)
 {
 }
 
-HTMLConstructionSite::HTMLConstructionSite(DocumentFragment* fragment, ParserContentPolicy parserContentPolicy)
+HTMLConstructionSite::HTMLConstructionSite(DocumentFragment* fragment)
     : m_document(&fragment->document())
     , m_attachmentRoot(fragment)
-    , m_parserContentPolicy(parserContentPolicy)
 {
 }
 
 HTMLConstructionSite::~HTMLConstructionSite()
 {
     // Depending on why we're being destroyed it might be OK
     // to forget queued tasks, but currently we don't expect to.
     ASSERT(m_taskQueue.isEmpty());
     // Currently we assume that text will never be the last token in the
     // document and that we'll always queue some additional task to cause it to flush.
@@ skipping 46 matching lines @@
     // but self-closing elements are never in the element stack so the stack
     // doesn't get a chance to tell them that we're done parsing their children.
     attachLater(currentNode(), createHTMLElement(token), true);
     // FIXME: Do we want to acknowledge the token's self-closing flag?
     // http://www.whatwg.org/specs/web-apps/current-work/multipage/tokenization.html#acknowledge-self-closing-flag
 }
 
 void HTMLConstructionSite::insertScriptElement(AtomicHTMLToken* token)
 {
     RefPtrWillBeRawPtr<HTMLScriptElement> element = HTMLScriptElement::create(ownerDocumentForCurrentNode());
-    setAttributes(element.get(), token, m_parserContentPolicy);
-    if (scriptingContentIsAllowed(m_parserContentPolicy))
-        attachLater(currentNode(), element);
+    setAttributes(element.get(), token);
+    attachLater(currentNode(), element);
     m_openElements.push(element.release());
 }
 
 void HTMLConstructionSite::insertTextNode(const String& string, WhitespaceMode whitespaceMode)
 {
     HTMLConstructionSiteTask dummyTask(HTMLConstructionSiteTask::Insert);
     dummyTask.parent = currentNode();
 
     // FIXME: This probably doesn't need to be done both here and in insert(Task).
     if (isHTMLTemplateElement(*dummyTask.parent))
         dummyTask.parent = toHTMLTemplateElement(dummyTask.parent.get())->content();
 
     // Unclear when parent != case occurs. Somehow we insert text into two separate nodes while processing the same Token.
     // The nextChild != dummy.nextChild case occurs whenever foster parenting happened and we hit a new text node "<table>a</table>b"
     // In either case we have to flush the pending text into the task queue before making more.
     if (!m_pendingText.isEmpty() && (m_pendingText.parent != dummyTask.parent ||  m_pendingText.nextChild != dummyTask.nextChild))
         flushPendingText();
     m_pendingText.append(dummyTask.parent, dummyTask.nextChild, string, whitespaceMode);
 }
 
 PassRefPtrWillBeRawPtr<Element> HTMLConstructionSite::createElement(AtomicHTMLToken* token, const AtomicString& namespaceURI)
 {
     QualifiedName tagName(token->name());
     RefPtrWillBeRawPtr<Element> element = ownerDocumentForCurrentNode().createElement(tagName, true);
-    setAttributes(element.get(), token, m_parserContentPolicy);
+    setAttributes(element.get(), token);
     return element.release();
 }
 
 inline Document& HTMLConstructionSite::ownerDocumentForCurrentNode()
 {
     if (isHTMLTemplateElement(*currentNode()))
         return toHTMLTemplateElement(currentElement())->content()->document();
     return currentNode()->document();
 }
 
 PassRefPtrWillBeRawPtr<HTMLElement> HTMLConstructionSite::createHTMLElement(AtomicHTMLToken* token)
 {
     Document& document = ownerDocumentForCurrentNode();
     RefPtrWillBeRawPtr<HTMLElement> element = HTMLElementFactory::createHTMLElement(token->name(), document, true);
-    setAttributes(element.get(), token, m_parserContentPolicy);
+    setAttributes(element.get(), token);
     return element.release();
 }
 
 void HTMLConstructionSite::PendingText::trace(Visitor* visitor)
 {
     visitor->trace(parent);
     visitor->trace(nextChild);
 }
 
 }