De-Element ScriptLoader

third_party/WebKit/Source/core/html/HTMLScriptElement.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights
  * reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "core/html/HTMLScriptElement.h"
 
 #include "bindings/core/v8/ExceptionState.h"
+#include "bindings/core/v8/HTMLScriptElementOrSVGScriptElement.h"
 #include "bindings/core/v8/ScriptEventListener.h"
 #include "core/HTMLNames.h"
 #include "core/dom/Attribute.h"
 #include "core/dom/Document.h"
 #include "core/dom/ScriptLoader.h"
 #include "core/dom/ScriptRunner.h"
 #include "core/dom/Text.h"
 #include "core/events/Event.h"
 #include "core/frame/UseCounter.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 inline HTMLScriptElement::HTMLScriptElement(Document& document,
                                             bool wasInsertedByParser,
                                             bool alreadyStarted,
                                             bool createdDuringDocumentWrite)
-    : HTMLElement(scriptTag, document),
-      m_loader(ScriptLoader::create(this,
-                                    wasInsertedByParser,
-                                    alreadyStarted,
-                                    createdDuringDocumentWrite)) {}
+    : HTMLElement(scriptTag, document) {
+  initializeScriptLoader(wasInsertedByParser, alreadyStarted,
+                         createdDuringDocumentWrite);
+}
 
 HTMLScriptElement* HTMLScriptElement::create(Document& document,
                                              bool wasInsertedByParser,
                                              bool alreadyStarted,
                                              bool createdDuringDocumentWrite) {
   return new HTMLScriptElement(document, wasInsertedByParser, alreadyStarted,
                                createdDuringDocumentWrite);
 }
 
 bool HTMLScriptElement::isURLAttribute(const Attribute& attribute) const {
@@ skipping 89 matching lines @@
 }
 
 String HTMLScriptElement::forAttributeValue() const {
   return getAttribute(forAttr).getString();
 }
 
 String HTMLScriptElement::eventAttributeValue() const {
   return getAttribute(eventAttr).getString();
 }
 
+String HTMLScriptElement::crossOriginAttributeValue() const {
+  return getAttribute(crossoriginAttr);
+}
+
+String HTMLScriptElement::integrityAttributeValue() const {
+  return getAttribute(integrityAttr);
+}
+
+String HTMLScriptElement::textFromChildren() {
+  return Element::textFromChildren();
+}
+
+String HTMLScriptElement::textContent() const {
+  return Element::textContent();
+}
+
 bool HTMLScriptElement::asyncAttributeValue() const {
   return fastHasAttribute(asyncAttr);
 }
 
 bool HTMLScriptElement::deferAttributeValue() const {
   return fastHasAttribute(deferAttr);
 }
 
 bool HTMLScriptElement::hasSourceAttribute() const {
   return fastHasAttribute(srcAttr);
 }
 
+bool HTMLScriptElement::isConnected() const {
+  return Node::isConnected();
+}
+
+bool HTMLScriptElement::hasChildren() const {
+  return Node::hasChildren();
+}
+
+bool HTMLScriptElement::isNonceableElement() const {
+  return ContentSecurityPolicy::isNonceableElement(this);
+}
+
+bool HTMLScriptElement::allowInlineScriptForCSP(
+    const AtomicString& nonce,
+    const WTF::OrdinalNumber& contextLine,
+    const String& scriptContent) {
+  return document().contentSecurityPolicy()->allowInlineScript(
+      this, document().url(), nonce, contextLine, scriptContent);
+}
+
+AtomicString HTMLScriptElement::initiatorName() const {
+  return Element::localName();
+}
+
+Document& HTMLScriptElement::document() const {
+  return Node::document();
+}
+
 void HTMLScriptElement::dispatchLoadEvent() {
   DCHECK(!m_loader->haveFiredLoadEvent());
   dispatchEvent(Event::create(EventTypeNames::load));
 }
 
+void HTMLScriptElement::dispatchErrorEvent() {
+  dispatchEvent(Event::create(EventTypeNames::error));
+}
+
+void HTMLScriptElement::setScriptElementForBinding(
+    HTMLScriptElementOrSVGScriptElement& element) {
+  if (!isInV1ShadowTree())
+    element.setHTMLScriptElement(this);
+}
+
 Element* HTMLScriptElement::cloneElementWithoutAttributesAndChildren() {
   return new HTMLScriptElement(document(), false, m_loader->alreadyStarted(),
                                false);
 }
 
 DEFINE_TRACE(HTMLScriptElement) {
-  visitor->trace(m_loader);
   HTMLElement::trace(visitor);
+  ScriptElementBase::trace(visitor);
 }
 
 }  // namespace blink