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

   1 /*
   2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   4  *           (C) 2001 Dirk Mueller (mueller@kde.org)
   5  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public License
  18  * along with this library; see the file COPYING.LIB.  If not, write to
  19  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  20  * Boston, MA 02110-1301, USA.
  21  */
  22
  23 #include "config.h"
  24 #include "core/html/HTMLScriptElement.h"
  25
  26 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
  27 #include "bindings/core/v8/ScriptEventListener.h"
  28 #include "bindings/core/v8/V8DOMActivityLogger.h"
  29 #include "core/HTMLNames.h"
  30 #include "core/dom/Attribute.h"
  31 #include "core/dom/Document.h"
  32 #include "core/dom/ScriptLoader.h"
  33 #include "core/dom/ScriptRunner.h"
  34 #include "core/dom/Text.h"
  35 #include "core/events/Event.h"
  36 #include "core/frame/UseCounter.h"
  37
  38 namespace blink {
  39
  40 using namespace HTMLNames;
  41
  42 inline HTMLScriptElement::HTMLScriptElement(Document& document, bool wasInsertedByParser, bool alreadyStarted)
  43     : HTMLElement(scriptTag, document)
  44     , m_loader(ScriptLoader::create(this, wasInsertedByParser, alreadyStarted))
  45 {
  46 }
  47
  48 PassRefPtrWillBeRawPtr<HTMLScriptElement> HTMLScriptElement::create(Document& document, bool wasInsertedByParser, bool alreadyStarted)
  49 {
  50     return adoptRefWillBeNoop(new HTMLScriptElement(document, wasInsertedByParser, alreadyStarted));
  51 }
  52
  53 bool HTMLScriptElement::isURLAttribute(const Attribute& attribute) const
  54 {
  55     return attribute.name() == srcAttr || HTMLElement::isURLAttribute(attribute);
  56 }
  57
  58 bool HTMLScriptElement::hasLegalLinkAttribute(const QualifiedName& name) const
  59 {
  60     return name == srcAttr || HTMLElement::hasLegalLinkAttribute(name);
  61 }
  62
  63 const QualifiedName& HTMLScriptElement::subResourceAttributeName() const
  64 {
  65     return srcAttr;
  66 }
  67
  68 void HTMLScriptElement::childrenChanged(const ChildrenChange& change)
  69 {
  70     HTMLElement::childrenChanged(change);
  71     m_loader->childrenChanged();
  72 }
  73
  74 void HTMLScriptElement::didMoveToNewDocument(Document& oldDocument)
  75 {
  76     ScriptRunner::movePendingAsyncScript(oldDocument, document(), m_loader.get());
  77     HTMLElement::didMoveToNewDocument(oldDocument);
  78 }
  79
  80 void HTMLScriptElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
  81 {
  82     if (name == srcAttr)
  83         m_loader->handleSourceAttribute(value);
  84     else if (name == asyncAttr)
  85         m_loader->handleAsyncAttribute();
  86     else
  87         HTMLElement::parseAttribute(name, value);
  88 }
  89
  90 void HTMLScriptElement::attributeWillChange(const QualifiedName& name, const AtomicString& oldValue, const AtomicString& newValue)
  91 {
  92     if (name == srcAttr && inDocument()) {
  93         V8DOMActivityLogger* activityLogger = V8DOMActivityLogger::currentActivityLoggerIfIsolatedWorld();
  94         if (activityLogger) {
  95             Vector<String> argv;
  96             argv.append("script");
  97             argv.append(srcAttr.toString());
  98             argv.append(oldValue);
  99             argv.append(newValue);
 100             activityLogger->logEvent("blinkSetAttribute", argv.size(), argv.data());
 101         }
 102     }
 103     HTMLElement::attributeWillChange(name, oldValue, newValue);
 104 }
 105
 106 Node::InsertionNotificationRequest HTMLScriptElement::insertedInto(ContainerNode* insertionPoint)
 107 {
 108     if (insertionPoint->inDocument()) {
 109         V8DOMActivityLogger* activityLogger = V8DOMActivityLogger::currentActivityLoggerIfIsolatedWorld();
 110         if (activityLogger) {
 111             Vector<String> argv;
 112             argv.append("script");
 113             argv.append(fastGetAttribute(srcAttr));
 114             activityLogger->logEvent("blinkAddElement", argv.size(), argv.data());
 115         }
 116
 117         if (hasSourceAttribute() && !loader()->isScriptTypeSupported(ScriptLoader::DisallowLegacyTypeInTypeAttribute))
 118             UseCounter::count(document(), UseCounter::ScriptElementWithInvalidTypeHasSrc);
 119     }
 120     HTMLElement::insertedInto(insertionPoint);
 121     return InsertionShouldCallDidNotifySubtreeInsertions;
 122 }
 123
 124 void HTMLScriptElement::didNotifySubtreeInsertionsToDocument()
 125 {
 126     m_loader->didNotifySubtreeInsertionsToDocument();
 127 }
 128
 129 void HTMLScriptElement::setText(const String &value)
 130 {
 131     setTextContent(value);
 132 }
 133
 134 void HTMLScriptElement::setAsync(bool async)
 135 {
 136     setBooleanAttribute(asyncAttr, async);
 137     m_loader->handleAsyncAttribute();
 138 }
 139
 140 bool HTMLScriptElement::async() const
 141 {
 142     return fastHasAttribute(asyncAttr) || (m_loader->forceAsync());
 143 }
 144
 145 KURL HTMLScriptElement::src() const
 146 {
 147     return document().completeURL(sourceAttributeValue());
 148 }
 149
 150 String HTMLScriptElement::sourceAttributeValue() const
 151 {
 152     return getAttribute(srcAttr).string();
 153 }
 154
 155 String HTMLScriptElement::charsetAttributeValue() const
 156 {
 157     return getAttribute(charsetAttr).string();
 158 }
 159
 160 String HTMLScriptElement::typeAttributeValue() const
 161 {
 162     return getAttribute(typeAttr).string();
 163 }
 164
 165 String HTMLScriptElement::languageAttributeValue() const
 166 {
 167     return getAttribute(languageAttr).string();
 168 }
 169
 170 String HTMLScriptElement::forAttributeValue() const
 171 {
 172     return getAttribute(forAttr).string();
 173 }
 174
 175 String HTMLScriptElement::eventAttributeValue() const
 176 {
 177     return getAttribute(eventAttr).string();
 178 }
 179
 180 bool HTMLScriptElement::asyncAttributeValue() const
 181 {
 182     return fastHasAttribute(asyncAttr);
 183 }
 184
 185 bool HTMLScriptElement::deferAttributeValue() const
 186 {
 187     return fastHasAttribute(deferAttr);
 188 }
 189
 190 bool HTMLScriptElement::hasSourceAttribute() const
 191 {
 192     return fastHasAttribute(srcAttr);
 193 }
 194
 195 void HTMLScriptElement::dispatchLoadEvent()
 196 {
 197     ASSERT(!m_loader->haveFiredLoadEvent());
 198     dispatchEvent(Event::create(EventTypeNames::load));
 199 }
 200
 201 PassRefPtrWillBeRawPtr<Element> HTMLScriptElement::cloneElementWithoutAttributesAndChildren()
 202 {
 203     return adoptRefWillBeNoop(new HTMLScriptElement(document(), false, m_loader->alreadyStarted()));
 204 }
 205
 206 DEFINE_TRACE(HTMLScriptElement)
 207 {
 208     visitor->trace(m_loader);
 209     HTMLElement::trace(visitor);
 210 }
 211
 212 }