DevTools: Get rid of module initializers in the source tree

Source/devtools/front_end/Runtime.js

 /*
  * Copyright (C) 2014 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 10 matching lines @@
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-var _importedScripts = {};
+// This gets all concatenated module descriptors in the release mode.
+var allDescriptors = [];
+var _loadedScripts = {};
 
 /**
  * @param {string} url
  * @return {string}
  */
 function loadResource(url)
 {
     var xhr = new XMLHttpRequest();
     xhr.open("GET", url, false);
     try {
@@ skipping 32 matching lines @@
         return normalizedPath;
     if (path[0] === "/" && normalizedPath)
         normalizedPath = "/" + normalizedPath;
     if ((path[path.length - 1] === "/") || (segments[segments.length - 1] === ".") || (segments[segments.length - 1] === ".."))
         normalizedPath = normalizedPath + "/";
 
     return normalizedPath;
 }
 
 /**
- * This function behavior depends on the "debug_devtools" flag value.
- * - In debug mode it loads scripts synchronously via xhr request.
- * - In release mode every occurrence of "importScript" in the js files
- *   that have been whitelisted in the build system gets replaced with
- *   the script source code on the compilation phase.
- *   The build system will throw an exception if it finds an importScript() call
- *   in other files.
- *
- * To load scripts lazily in release mode call "loadScript" function.
  * @param {string} scriptName
  */
-function importScript(scriptName)
+function loadScript(scriptName)
 {
     var sourceURL = self._importScriptPathPrefix + scriptName;
     var schemaIndex = sourceURL.indexOf("://") + 3;
     sourceURL = sourceURL.substring(0, schemaIndex) + normalizePath(sourceURL.substring(schemaIndex));
-    if (_importedScripts[sourceURL])
+    if (_loadedScripts[sourceURL])
         return;
-    _importedScripts[sourceURL] = true;
+    _loadedScripts[sourceURL] = true;
     var scriptSource = loadResource(sourceURL);
     if (!scriptSource)
         throw "empty response arrived for script '" + sourceURL + "'";
     var oldPrefix = self._importScriptPathPrefix;
     self._importScriptPathPrefix += scriptName.substring(0, scriptName.lastIndexOf("/") + 1);
     try {
         self.eval(scriptSource + "\n//# sourceURL=" + sourceURL);
     } finally {
         self._importScriptPathPrefix = oldPrefix;
     }
 }
 
 (function() {
     var baseUrl = location.origin + location.pathname;
     self._importScriptPathPrefix = baseUrl.substring(0, baseUrl.lastIndexOf("/") + 1);
 })();
 
-var loadScript = importScript;
-
 /**
  * @constructor
- * @param {!Array.<!Runtime.ModuleDescriptor>} descriptors
  */
-var Runtime = function(descriptors)
+var Runtime = function()
 {
     /**
      * @type {!Array.<!Runtime.Module>}
      */
     this._modules = [];
     /**
      * @type {!Object.<string, !Runtime.Module>}
      */
     this._modulesMap = {};
     /**
      * @type {!Array.<!Runtime.Extension>}
      */
     this._extensions = [];
 
     /**
      * @type {!Object.<string, !function(new:Object)>}
      */
     this._cachedTypeClasses = {};
 
     /**
      * @type {!Object.<string, !Runtime.ModuleDescriptor>}
      */
     this._descriptorsMap = {};
-    for (var i = 0; i < descriptors.length; ++i)
-        this._descriptorsMap[descriptors[i]["name"]] = descriptors[i];
+    for (var i = 0; i < allDescriptors.length; ++i)
+        this._descriptorsMap[allDescriptors[i]["name"]] = allDescriptors[i];
 }
 
 /**
+ * @return {boolean}
+ */
+Runtime.isReleaseMode = function()
+{
+    return !!allDescriptors.length;
+}
+
+/**
  * @param {string} moduleName
  * @return {!Worker}
  */
 Runtime.startWorker = function(moduleName)
 {
-    return new Worker(moduleName + "/_module.js");
+    if (Runtime.isReleaseMode())
+        return new Worker(moduleName + ".js");
+
+    var content = loadResource(moduleName + "/module.json");
+    if (!content)

[vsevik, 2014/08/18 12:04:31]

We'd better do console.error and silently return instead.

[apavlov, 2014/08/18 12:21:43]

Since we return a Worker instance, we'll have to check/cast the result in all
the call sites. The current version is a quick-and-dirty solution for the
debug_devtools=1 scenario.

+        throw new Error("Worker is not defined: " + moduleName + " " + new Error().stack);
+    var message = [];
+    var scripts = JSON.parse(content)["scripts"];
+    for (var i = 0; i < scripts.length; ++i) {
+        var url = self._importScriptPathPrefix + moduleName + "/" + scripts[i];
+        var parts = url.split("://");
+        url = parts.length === 1 ? url : parts[0] + "://" + normalizePath(parts[1]);
+        message.push({
+            source: loadResource(moduleName + "/" + scripts[i]),
+            url: url
+        });
+    }
+
+    /**
+     * @suppress {checkTypes}
+     */
+    var loader = function() {
+        self.onmessage = function(event) {
+            self.onmessage = null;
+            var scripts = event.data;
+            for (var i = 0; i < scripts.length; ++i) {
+                var source = scripts[i]["source"];
+                self.eval(source + "\n//# sourceURL=" + scripts[i]["url"]);
+            }
+        };
+    };
+
+    var blob = new Blob(["(" + loader.toString() + ")()\n//# sourceURL=" + moduleName], { type: "text/javascript" });
+    var workerURL = window.URL.createObjectURL(blob);
+    try {
+        var worker = new Worker(workerURL);
+        worker.postMessage(message);
+        return worker;
+    } finally {

[vsevik, 2014/08/18 12:04:31]

I don't think we actually care about revoking object URL in case the code above
throws.

[apavlov, 2014/08/18 12:21:43]

lushnikov@ asked for this. Anyway, this seems like a good surefire way out.

+        window.URL.revokeObjectURL(workerURL);
+    }
 }
 
 Runtime.prototype = {
     /**
      * @param {!Array.<string>} configuration
      */
     registerModules: function(configuration)
     {
         for (var i = 0; i < configuration.length; ++i)
             this._registerModule(configuration[i]);
@@ skipping 300 matching lines @@
             Error.stackTraceLimit = 50;
             console.assert(false, "Module " + this._name + " is loaded from itself: " + new Error().stack);
             Error.stackTraceLimit = oldStackTraceLimit;
             return;
         }
 
         this._isLoading = true;
         var dependencies = this._descriptor.dependencies;
         for (var i = 0; dependencies && i < dependencies.length; ++i)
             this._manager.loadModule(dependencies[i]);
-        if (this._descriptor.scripts)
-            loadScript(this._name + "/_module.js");
+        if (this._descriptor.scripts) {
+            if (Runtime.isReleaseMode()) {
+                loadScript(this._name + ".js");
+            } else {
+                var scripts = this._descriptor.scripts;
+                for (var i = 0; i < scripts.length; ++i)
+                    loadScript(this._name + "/" + scripts[i]);
+            }
+        }
         this._isLoading = false;
         this._loaded = true;
     }
 }
 
 /**
  * @constructor
  * @param {!Runtime.Module} module
  * @param {!Runtime.ExtensionDescriptor} descriptor
  */
@@ skipping 65 matching lines @@
             this._instance = new constructorFunction();
         }
         return this._instance;
     }
 }
 
 /**
  * @type {!Runtime}
  */
 var runtime;