DevTools: Get rid of synchronous XHRs in the frontend code

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 17 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 // This gets all concatenated module descriptors in the release mode.
 var allDescriptors = [];
 var applicationDescriptor;
 var _loadedScripts = {};
 
 /**
  * @param {string} url
- * @return {string}
- */
-function loadResource(url)
-{
-    var xhr = new XMLHttpRequest();
-    xhr.open("GET", url, false);
-    try {
-        xhr.send(null);
-    } catch (e) {
-        console.error(url + " -> " + new Error().stack);
-        throw e;
-    }
-    // xhr.status === 0 if loading from bundle.
-    return xhr.status < 400 ? xhr.responseText : "";
-}
-
-/**
- * @param {string} url
  * @return {!Promise.<string>}
  */
 function loadResourcePromise(url)
 {
     return new Promise(load);
 
     /**
      * @param {function(?)} fulfill
      * @param {function(*)} reject
      */
@@ skipping 159 matching lines @@
 
 /**
  * @return {boolean}
  */
 Runtime.isReleaseMode = function()
 {
     return !!allDescriptors.length;
 }
 
 /**
- * @param {string} moduleName
- * @param {string} workerName
- * @return {!SharedWorker}
- */
-Runtime.startSharedWorker = function(moduleName, workerName)
-{
-    if (Runtime.isReleaseMode())
-        return new SharedWorker(moduleName + "_module.js", workerName);
-
-    var content = loadResource(moduleName + "/module.json");
-    if (!content)
-        throw new Error("Worker is not defined: " + moduleName + " " + new Error().stack);
-    var scripts = JSON.parse(content)["scripts"];
-    if (scripts.length !== 1)
-        throw Error("Runtime.startSharedWorker supports modules with only one script!");
-    return new SharedWorker(moduleName + "/" + scripts[0], workerName);
-}
-
-/**
- * @param {string} moduleName
- * @return {!Worker}
- */
-Runtime.startWorker = function(moduleName)
-{
-    if (Runtime.isReleaseMode())
-        return new Worker(moduleName + "_module.js");
-
-    var content = loadResource(moduleName + "/module.json");
-    if (!content)
-        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 {
-        window.URL.revokeObjectURL(workerURL);
-    }
-}
-
-/**
  * @param {string} appName
  */
 Runtime.startApplication = function(appName)
 {
     console.timeStamp("Runtime.startApplication");
 
     var allDescriptorsByName = {};
     for (var i = 0; Runtime.isReleaseMode() && i < allDescriptors.length; ++i) {
         var d = allDescriptors[i];
         allDescriptorsByName[d["name"]] = d;
@@ skipping 405 matching lines @@
 
         if (this._pendingLoadPromise)
             return this._pendingLoadPromise;
 
         var dependencies = this._descriptor.dependencies;
         var dependencyPromises = [];
         for (var i = 0; dependencies && i < dependencies.length; ++i)
             dependencyPromises.push(this._manager._modulesMap[dependencies[i]]._loadPromise());
 
         this._pendingLoadPromise = Promise.all(dependencyPromises)
+            .then(this._loadStylesheets.bind(this))
             .then(this._loadScripts.bind(this))
             .then(markAsLoaded.bind(this));
 
         return this._pendingLoadPromise;
 
         /**
          * @this {Runtime.Module}
          */
         function markAsLoaded()
         {
             delete this._pendingLoadPromise;
             this._loaded = true;
         }
     },
 
     /**
      * @return {!Promise.<undefined>}
+     * @this {Runtime.Module}
+     */
+    _loadStylesheets: function()
+    {
+        var stylesheets = this._descriptor["stylesheets"];
+        if (!stylesheets)
+            return Promise.resolve();
+        var promises = [];
+        for (var i = 0; i < stylesheets.length; ++i) {
+            var url = this._modularizeURL(stylesheets[i]);
+            promises.push(loadResourcePromise(url).then(cacheStylesheet.bind(this, url), cacheStylesheet.bind(this, url, undefined)));
+        }
+        return Promise.all(promises).then(undefined);
+
+        /**
+         * @param {string} path
+         * @param {string=} content
+         */
+        function cacheStylesheet(path, content)
+        {
+            if (!content) {
+                console.error("Failed to load stylesheet: " + path);
+                return;
+            }
+            Runtime.cachedResources[path] = content;
+        }
+    },
+
+    /**
+     * @return {!Promise.<undefined>}
      */
     _loadScripts: function()
     {
         if (!this._descriptor.scripts)
-            return Promise.resolve(undefined);
+            return Promise.resolve();
 
         if (Runtime.isReleaseMode())
             return loadScriptsPromise([this._name + "_module.js"]);
 
-        return loadScriptsPromise(this._descriptor.scripts.map(modularizeURL, this)).catch(Runtime._reportError);
-
-        /**
-         * @param {string} scriptName
-         * @this {Runtime.Module}
-         */
-        function modularizeURL(scriptName)
-        {
-            return this._name + "/" + scriptName;
-        }
+        return loadScriptsPromise(this._descriptor.scripts.map(this._modularizeURL, this)).catch(Runtime._reportError);
     },
 
     /**
+     * @param {string} resourceName
+     */
+    _modularizeURL: function(resourceName)
+    {
+        return normalizePath(this._name + "/" + resourceName);
+    },
+
+    /**
      * @param {string} className
      * @return {?Object}
      */
     _instance: function(className)
     {
         if (className in this._instanceMap)
             return this._instanceMap[className];
 
         var constructorFunction = window.eval(className);
         if (!(constructorFunction instanceof Function)) {
@@ skipping 270 matching lines @@
         }
     }
 })();}
 
 
 // This must be constructed after the query parameters have been parsed.
 Runtime.experiments = new Runtime.ExperimentsSupport();
 
 /** @type {!Runtime} */
 var runtime;