Rename ScriptElement to ScriptLoader

Source/core/html/parser/HTMLScriptRunner.cpp

 /*
  * Copyright (C) 2010 Google, 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 13 matching lines @@
  */
 
 #include "config.h"
 #include "core/html/parser/HTMLScriptRunner.h"
 
 #include "bindings/v8/ScriptSourceCode.h"
 #include "core/dom/Element.h"
 #include "core/dom/Event.h"
 #include "core/dom/IgnoreDestructiveWriteCountIncrementer.h"
 #include "core/dom/Microtask.h"
-#include "core/dom/ScriptElement.h"
+#include "core/dom/ScriptLoader.h"
 #include "core/html/parser/HTMLInputStream.h"
 #include "core/html/parser/HTMLScriptRunnerHost.h"
 #include "core/html/parser/NestingLevelIncrementer.h"
 #include "core/loader/cache/CachedScript.h"
 #include "core/page/Frame.h"
 #include "core/platform/NotImplemented.h"
 
 namespace WebCore {
 
 using namespace HTMLNames;
@@ skipping 78 matching lines @@
 
     // Stop watching loads before executeScript to prevent recursion if the script reloads itself.
     if (pendingScript.cachedScript() && pendingScript.watchingForLoad())
         stopWatchingForLoad(pendingScript);
 
     if (!isExecutingScript())
         Microtask::performCheckpoint();
 
     // Clear the pending script before possible rentrancy from executeScript()
     RefPtr<Element> element = pendingScript.releaseElementAndClear();
-    if (ScriptElement* scriptElement = toScriptElementIfPossible(element.get())) {
+    if (ScriptLoader* scriptLoader = toScriptLoaderIfPossible(element.get())) {
         NestingLevelIncrementer nestingLevelIncrementer(m_scriptNestingLevel);
         IgnoreDestructiveWriteCountIncrementer ignoreDestructiveWriteCountIncrementer(m_document);
         if (errorOccurred)
-            scriptElement->dispatchErrorEvent();
+            scriptLoader->dispatchErrorEvent();
         else {
             ASSERT(isExecutingScript());
-            scriptElement->executeScript(sourceCode);
+            scriptLoader->executeScript(sourceCode);
             element->dispatchEvent(createScriptLoadEvent());
         }
     }
     ASSERT(!isExecutingScript());
 }
 
 void HTMLScriptRunner::watchForLoad(PendingScript& pendingScript)
 {
     ASSERT(!pendingScript.watchingForLoad());
     m_host->watchForLoad(pendingScript.cachedScript());
@@ skipping 101 matching lines @@
 
     ASSERT(pendingScript.cachedScript());
     m_scriptsToExecuteAfterParsing.append(pendingScript);
 }
 
 bool HTMLScriptRunner::requestPendingScript(PendingScript& pendingScript, Element* script) const
 {
     ASSERT(!pendingScript.element());
     pendingScript.setElement(script);
     // This should correctly return 0 for empty or invalid srcValues.
-    CachedScript* cachedScript = toScriptElementIfPossible(script)->cachedScript().get();
+    CachedScript* cachedScript = toScriptLoaderIfPossible(script)->cachedScript().get();
     if (!cachedScript) {
         notImplemented(); // Dispatch error event.
         return false;
     }
     pendingScript.setCachedScript(cachedScript);
     return true;
 }
 
 // This method is meant to match the HTML5 definition of "running a script"
 // http://www.whatwg.org/specs/web-apps/current-work/multipage/scripting-1.html#running-a-script
 void HTMLScriptRunner::runScript(Element* script, const TextPosition& scriptStartPosition)
 {
     ASSERT(m_document);
     ASSERT(!hasParserBlockingScript());
     {
-        ScriptElement* scriptElement = toScriptElementIfPossible(script);
+        ScriptLoader* scriptLoader = toScriptLoaderIfPossible(script);
 
         // This contains both and ASSERTION and a null check since we should not
         // be getting into the case of a null script element, but seem to be from
         // time to time. The assertion is left in to help find those cases and
         // is being tracked by <https://bugs.webkit.org/show_bug.cgi?id=60559>.
-        ASSERT(scriptElement);
-        if (!scriptElement)
+        ASSERT(scriptLoader);
+        if (!scriptLoader)
             return;
 
         // FIXME: This may be too agressive as we always deliver mutations at
         // every script element, even if it's not ready to execute yet. There's
         // unfortuantely no obvious way to tell if prepareScript is going to
         // execute the script from out here.
         if (!isExecutingScript())
             Microtask::performCheckpoint();
 
         InsertionPointRecord insertionPointRecord(m_host->inputStream());
         NestingLevelIncrementer nestingLevelIncrementer(m_scriptNestingLevel);
 
-        scriptElement->prepareScript(scriptStartPosition);
+        scriptLoader->prepareScript(scriptStartPosition);
 
-        if (!scriptElement->willBeParserExecuted())
+        if (!scriptLoader->willBeParserExecuted())
             return;
 
-        if (scriptElement->willExecuteWhenDocumentFinishedParsing())
+        if (scriptLoader->willExecuteWhenDocumentFinishedParsing()) {
             requestDeferredScript(script);
-        else if (scriptElement->readyToBeParserExecuted()) {
+        } else if (scriptLoader->readyToBeParserExecuted()) {
             if (m_scriptNestingLevel == 1) {
                 m_parserBlockingScript.setElement(script);
                 m_parserBlockingScript.setStartingPosition(scriptStartPosition);
             } else {
                 ScriptSourceCode sourceCode(script->textContent(), documentURLForScriptExecution(m_document), scriptStartPosition);
-                scriptElement->executeScript(sourceCode);
+                scriptLoader->executeScript(sourceCode);
             }
-        } else
+        } else {
             requestParsingBlockingScript(script);
+        }
     }
 }
 
 }