Make ScriptLoader into a ResourceOwner

Source/core/dom/ScriptLoader.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.
  * Copyright (C) 2008 Nikolas Zimmermann <zimmermann@kde.org>
  *
  * 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
@@ skipping 36 matching lines @@
 #include "platform/MIMETypeRegistry.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/StringHash.h"
 
 namespace WebCore {
 
 ScriptLoader::ScriptLoader(Element* element, bool parserInserted, bool alreadyStarted)
     : m_element(element)
-    , m_resource(0)
     , m_startLineNumber(WTF::OrdinalNumber::beforeFirst())
     , m_parserInserted(parserInserted)
     , m_isExternalScript(false)
     , m_alreadyStarted(alreadyStarted)
     , m_haveFiredLoad(false)
     , m_willBeParserExecuted(false)
     , m_readyToBeParserExecuted(false)
     , m_willExecuteWhenDocumentFinishedParsing(false)
     , m_forceAsync(!parserInserted)
     , m_willExecuteInOrder(false)
 {
     ASSERT(m_element);
     if (parserInserted && element->document().scriptableDocumentParser() && !element->document().isInDocumentWrite())
         m_startLineNumber = element->document().scriptableDocumentParser()->lineNumber();
 }
 
 ScriptLoader::~ScriptLoader()
 {
-    stopLoadRequest();
 }
 
 void ScriptLoader::didNotifySubtreeInsertionsToDocument()
 {
     if (!m_parserInserted)
         prepareScript(); // FIXME: Provide a real starting line number here.
 }
 
 void ScriptLoader::childrenChanged()
 {
@@ skipping 71 matching lines @@
         if (MIMETypeRegistry::isSupportedJavaScriptMIMEType(type) || isLegacySupportedJavaScriptLanguage(language))
             return true;
     } else if (MIMETypeRegistry::isSupportedJavaScriptMIMEType(type.stripWhiteSpace()) || (supportLegacyTypes == AllowLegacyTypeInTypeAttribute && isLegacySupportedJavaScriptLanguage(type))) {
         return true;
     }
 
     return false;
 }
 
 // http://dev.w3.org/html5/spec/Overview.html#prepare-a-script
-bool ScriptLoader::prepareScript(const TextPosition& scriptStartPosition, LegacyTypeSupport supportLegacyTypes)
+ScriptPrep ScriptLoader::prepareScript(const TextPosition& scriptStartPosition, LegacyTypeSupport supportLegacyTypes)
 {
     if (m_alreadyStarted)
-        return false;
+        return ScriptPrep::failed();
 
     ScriptLoaderClient* client = this->client();
 
     bool wasParserInserted;
     if (m_parserInserted) {
         wasParserInserted = true;
         m_parserInserted = false;
     } else {
         wasParserInserted = false;
     }
 
     if (wasParserInserted && !client->asyncAttributeValue())
         m_forceAsync = true;
 
     // FIXME: HTML5 spec says we should check that all children are either comments or empty text nodes.
     if (!client->hasSourceAttribute() && !m_element->firstChild())
-        return false;
+        return ScriptPrep::failed();
 
     if (!m_element->inDocument())
-        return false;
+        return ScriptPrep::failed();
 
     if (!isScriptTypeSupported(supportLegacyTypes))
-        return false;
+        return ScriptPrep::failed();
 
     if (wasParserInserted) {
         m_parserInserted = true;
         m_forceAsync = false;
     }
 
     m_alreadyStarted = true;
 
     // FIXME: If script is parser inserted, verify it's still in the original document.
     Document& elementDocument = m_element->document();
     Document* contextDocument = elementDocument.contextDocument().get();
 
     if (!contextDocument || !contextDocument->allowExecutingScripts(m_element))
-        return false;
+        return ScriptPrep::failed();
 
     if (!isScriptForEventSupported())
-        return false;
+        return ScriptPrep::failed();
 
     if (!client->charsetAttributeValue().isEmpty())
         m_characterEncoding = client->charsetAttributeValue();
     else
         m_characterEncoding = elementDocument.charset();
 
+    ResourcePtr<ScriptResource> resource;
     if (client->hasSourceAttribute()) {
-        if (!fetchScript(client->sourceAttributeValue()))
-            return false;
+        resource = fetchScript(client->sourceAttributeValue());
+        if (!resource) {
+            dispatchErrorEvent();
+            return ScriptPrep::failed();
+        }
+
     }
 
     if (client->hasSourceAttribute() && client->deferAttributeValue() && m_parserInserted && !client->asyncAttributeValue()) {
         m_willExecuteWhenDocumentFinishedParsing = true;
         m_willBeParserExecuted = true;
     } else if (client->hasSourceAttribute() && m_parserInserted && !client->asyncAttributeValue()) {
         m_willBeParserExecuted = true;
     } else if (!client->hasSourceAttribute() && m_parserInserted && !elementDocument.isRenderingReady()) {
         m_willBeParserExecuted = true;
         m_readyToBeParserExecuted = true;
     } else if (client->hasSourceAttribute() && !client->asyncAttributeValue() && !m_forceAsync) {
         m_willExecuteInOrder = true;
-        contextDocument->scriptRunner()->queueScriptForExecution(this, m_resource, ScriptRunner::IN_ORDER_EXECUTION);
-        m_resource->addClient(this);
+        contextDocument->scriptRunner()->queueScriptForExecution(this, resource, ScriptRunner::IN_ORDER_EXECUTION);
     } else if (client->hasSourceAttribute()) {
-        contextDocument->scriptRunner()->queueScriptForExecution(this, m_resource, ScriptRunner::ASYNC_EXECUTION);
-        m_resource->addClient(this);
+        contextDocument->scriptRunner()->queueScriptForExecution(this, resource, ScriptRunner::ASYNC_EXECUTION);
     } else {
         // Reset line numbering for nested writes.
         TextPosition position = elementDocument.isInDocumentWrite() ? TextPosition() : scriptStartPosition;
         KURL scriptURL = (!elementDocument.isInDocumentWrite() && m_parserInserted) ? elementDocument.url() : KURL();
         executeScript(ScriptSourceCode(scriptContent(), scriptURL, position));
     }
 
-    return true;
+    // FIXME: This second "subscribing" parameter is a mess. We shouldn't have to need this.
+    if (resource)
+        setResource(resource, !m_willBeParserExecuted);
+
+    // We have to return fetchedResource instead of let callers ask ScriptLoader::resource()
+    // because resource() can be null when it is accessed: Following setResource() can trigger clearResource().
+    return ScriptPrep(true, resource);
 }
 
-bool ScriptLoader::fetchScript(const String& sourceUrl)
+ResourcePtr<ScriptResource> ScriptLoader::fetchScript(const String& sourceUrl)
 {
     ASSERT(m_element);
 
     RefPtrWillBeRawPtr<Document> elementDocument(m_element->document());
     if (!m_element->inDocument() || m_element->document() != elementDocument)
-        return false;
+        return ResourcePtr<ScriptResource>();
 
-    ASSERT(!m_resource);
+    ASSERT(!resource());
+    ResourcePtr<ScriptResource> resource;
     if (!stripLeadingAndTrailingHTMLSpaces(sourceUrl).isEmpty()) {
         FetchRequest request(ResourceRequest(elementDocument->completeURL(sourceUrl)), m_element->localName());
 
         AtomicString crossOriginMode = m_element->fastGetAttribute(HTMLNames::crossoriginAttr);
         if (!crossOriginMode.isNull())
             request.setCrossOriginAccessControl(elementDocument->securityOrigin(), crossOriginMode);
         request.setCharset(scriptCharset());
 
         bool isValidScriptNonce = elementDocument->contentSecurityPolicy()->allowScriptNonce(m_element->fastGetAttribute(HTMLNames::nonceAttr));
         if (isValidScriptNonce)
             request.setContentSecurityCheck(DoNotCheckContentSecurityPolicy);
 
-        m_resource = elementDocument->fetcher()->fetchScript(request);
+        resource = elementDocument->fetcher()->fetchScript(request);
         m_isExternalScript = true;
     }
 
-    if (m_resource)
-        return true;
-
-    dispatchErrorEvent();
-    return false;
+    return resource;
 }
 
 bool isHTMLScriptLoader(Element* element)
 {
     ASSERT(element);
     return isHTMLScriptElement(*element);
 }
 
 bool isSVGScriptLoader(Element* element)
 {
@@ skipping 14 matching lines @@
         return;
 
     LocalFrame* frame = contextDocument->frame();
 
     bool shouldBypassMainWorldContentSecurityPolicy = (frame && frame->script().shouldBypassMainWorldContentSecurityPolicy()) || elementDocument->contentSecurityPolicy()->allowScriptNonce(m_element->fastGetAttribute(HTMLNames::nonceAttr)) || elementDocument->contentSecurityPolicy()->allowScriptHash(sourceCode.source());
 
     if (!m_isExternalScript && (!shouldBypassMainWorldContentSecurityPolicy && !elementDocument->contentSecurityPolicy()->allowInlineScript(elementDocument->url(), m_startLineNumber)))
         return;
 
     if (m_isExternalScript) {
-        ScriptResource* resource = m_resource ? m_resource.get() : sourceCode.resource();
+        ScriptResource* resource = this->resource() ? this->resource() : sourceCode.resource();
         if (resource && !resource->mimeTypeAllowedByNosniff()) {
             contextDocument->addConsoleMessage(SecurityMessageSource, ErrorMessageLevel, "Refused to execute script from '" + resource->url().elidedString() + "' because its MIME type ('" + resource->mimeType() + "') is not executable, and strict MIME type checking is enabled.");
             return;
         }
     }
 
     if (frame) {
         const bool isImportedScript = contextDocument != elementDocument;
         // http://www.whatwg.org/specs/web-apps/current-work/#execute-the-script-block step 2.3
         // with additional support for HTML imports.
@@ skipping 11 matching lines @@
         // Note: This is where the script is compiled and actually executed.
         frame->script().executeScriptInMainWorld(sourceCode, corsCheck);
 
         if (isHTMLScriptLoader(m_element)) {
             ASSERT(contextDocument->currentScript() == m_element);
             contextDocument->popCurrentScript();
         }
     }
 }
 
-void ScriptLoader::stopLoadRequest()
-{
-    if (m_resource) {
-        if (!m_willBeParserExecuted)
-            m_resource->removeClient(this);
-        m_resource = 0;
-    }
-}
-
 void ScriptLoader::execute(ScriptResource* resource)
 {
     ASSERT(!m_willBeParserExecuted);
     ASSERT(resource);
     if (resource->errorOccurred()) {
         dispatchErrorEvent();
     } else if (!resource->wasCanceled()) {
         executeScript(ScriptSourceCode(resource));
         dispatchLoadEvent();
     }
-    resource->removeClient(this);
+
+    clearResource();
 }
 
 void ScriptLoader::cancel(Document* contextDocument)
 {
-    if (!m_resource)
+    if (!resource())
         return;
     finishLoading(contextDocument, FinishWithCancel);
 }
 
 void ScriptLoader::notifyFinished(Resource* resource)
 {
     // Resource possibly invokes this notifyFinished() more than
     // once because ScriptLoader doesn't unsubscribe itself from
     // Resource here and does it in execute() instead.
-    // We use m_resource to check if this function is already called.
-    ASSERT_UNUSED(resource, resource == m_resource);
-    if (!m_resource)
+    // We use resource() to check if this function is already called.
+    ASSERT_UNUSED(resource, resource == this->resource());
+    if (!this->resource())
         return;
 
+    RefPtr<Element> protect(m_element);
     RefPtr<Document> elementDocument(m_element->document());
     RefPtr<Document> contextDocument = elementDocument->contextDocument().get();
     finishLoading(contextDocument.get(), resource->errorOccurred() ? FinishWithError : FinishSuccessfully);
 }
 
 void ScriptLoader::finishLoading(Document* contextDocument, ScriptLoader::FinishType type)
 {
-    if (!contextDocument)
-        return;
+    if (!m_willBeParserExecuted && contextDocument)
+        notifyRunnerFinishLoading(contextDocument->scriptRunner(), type);
+    clearResource();
+}
 
+void ScriptLoader::notifyRunnerFinishLoading(ScriptRunner* runner, ScriptLoader::FinishType type)
+{
     switch (type) {
     case FinishWithCancel:
-        if (!m_willBeParserExecuted)
-            contextDocument->scriptRunner()->notifyScriptLoadError(this, m_willExecuteInOrder ? ScriptRunner::IN_ORDER_EXECUTION : ScriptRunner::ASYNC_EXECUTION);
-        stopLoadRequest();
+        runner->notifyScriptLoadError(this, m_willExecuteInOrder ? ScriptRunner::IN_ORDER_EXECUTION : ScriptRunner::ASYNC_EXECUTION);
         break;
     case FinishWithError:
-        ASSERT(!m_willBeParserExecuted);
         dispatchErrorEvent();
-        contextDocument->scriptRunner()->notifyScriptLoadError(this, m_willExecuteInOrder ? ScriptRunner::IN_ORDER_EXECUTION : ScriptRunner::ASYNC_EXECUTION);
-        m_resource = 0;
+        runner->notifyScriptLoadError(this, m_willExecuteInOrder ? ScriptRunner::IN_ORDER_EXECUTION : ScriptRunner::ASYNC_EXECUTION);
         break;
     case FinishSuccessfully:
-        ASSERT(!m_willBeParserExecuted);
-        contextDocument->scriptRunner()->notifyScriptReady(this, m_willExecuteInOrder ? ScriptRunner::IN_ORDER_EXECUTION : ScriptRunner::ASYNC_EXECUTION);
-        m_resource = 0;
+        runner->notifyScriptReady(this, m_willExecuteInOrder ? ScriptRunner::IN_ORDER_EXECUTION : ScriptRunner::ASYNC_EXECUTION);
         break;
     }
 }
 
+
 bool ScriptLoader::ignoresLoadRequest() const
 {
     return m_alreadyStarted || m_isExternalScript || m_parserInserted || !element() || !element()->inDocument();
 }
 
 bool ScriptLoader::isScriptForEventSupported() const
 {
     String eventAttribute = client()->eventAttributeValue();
     String forAttribute = client()->forAttributeValue();
     if (!eventAttribute.isEmpty() && !forAttribute.isEmpty()) {
@@ skipping 30 matching lines @@
     if (isHTMLScriptLoader(element))
         return toHTMLScriptElement(element)->loader();
 
     if (isSVGScriptLoader(element))
         return toSVGScriptElement(element)->loader();
 
     return 0;
 }
 
 }