DevTools: remove release mode from runtime.

third_party/WebKit/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 220 matching lines @@
         if (!content) {
             console.error("Failed to load resource: " + path);
             return;
         }
         var sourceURL = appendSourceURL ? Runtime.resolveSourceURL(path) : "";
         Runtime.cachedResources[path] = content + sourceURL;
     }
 }
 
 /**
- * @return {boolean}
- */
-Runtime.isReleaseMode = function()
-{
-    return !!allDescriptors.length;
-}
-
-/**
  * @param {string} appName
  * @return {!Promise.<undefined>}
  */
 Runtime.startApplication = function(appName)
 {
     console.timeStamp("Runtime.startApplication");
 
     var allDescriptorsByName = {};
-    for (var i = 0; Runtime.isReleaseMode() && i < allDescriptors.length; ++i) {
+    for (var i = 0; i < allDescriptors.length; ++i) {
         var d = allDescriptors[i];
         allDescriptorsByName[d["name"]] = d;
     }
 
     var applicationPromise;
     if (applicationDescriptor)
         applicationPromise = Promise.resolve(applicationDescriptor);
     else
         applicationPromise = loadResourcePromise(appName + ".json").then(JSON.parse.bind(JSON));
 
@@ skipping 21 matching lines @@
         }
 
         return Promise.all(moduleJSONPromises).then(instantiateRuntime);
 
         /**
          * @param {!Array.<!Object>} moduleDescriptors
          * @return {!Promise.<undefined>}
          */
         function instantiateRuntime(moduleDescriptors)
         {
-            for (var i = 0; !Runtime.isReleaseMode() && i < moduleDescriptors.length; ++i) {
+            for (var i = 0; i < moduleDescriptors.length; ++i) {
                 moduleDescriptors[i]["name"] = configuration[i]["name"];
                 moduleDescriptors[i]["condition"] = configuration[i]["condition"];
             }
             self.runtime = new Runtime(moduleDescriptors);
             if (coreModuleNames)
                 return /** @type {!Promise<undefined>} */ (self.runtime._loadAutoStartModules(coreModuleNames));
             return Promise.resolve();
         }
     }
 }
@@ skipping 180 matching lines @@
         return this._modulesMap[moduleName]._loadPromise();
     },
 
     /**
      * @param {!Array.<string>} moduleNames
      * @return {!Promise.<!Array.<*>>}
      */
     _loadAutoStartModules: function(moduleNames)
     {
         var promises = [];
-        for (var i = 0; i < moduleNames.length; ++i) {
-            if (Runtime.isReleaseMode())
-                this._modulesMap[moduleNames[i]]._loaded = true;
-            else
-                promises.push(this.loadModulePromise(moduleNames[i]));
-        }
+        for (var i = 0; i < moduleNames.length; ++i)
+            promises.push(this.loadModulePromise(moduleNames[i]));
         return Promise.all(promises);
     },
 
     /**
      * @param {!Runtime.Extension} extension
      * @param {?function(function(new:Object)):boolean} predicate
      * @return {boolean}
      */
     _checkExtensionApplicability: function(extension, predicate)
     {
@@ skipping 254 matching lines @@
         if (!content)
             throw new Error(fullName + " not preloaded. Check module.json");
         return content;
     },
 
     /**
      * @return {!Promise.<undefined>}
      */
     _loadPromise: function()
     {
-        if (this._loaded)
-            return Promise.resolve();
-
         if (!this.enabled())
             return Promise.reject(new Error("Module " + this._name + " is not enabled"));
 
         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._loadResources.bind(this))
             .then(this._loadScripts.bind(this))
-            .then(markAsLoaded.bind(this));
+            .then(() => this._loadedForTest = true);
 
         return this._pendingLoadPromise;
-
-        /**
-         * @this {Runtime.Module}
-         */
-        function markAsLoaded()
-        {
-            delete this._pendingLoadPromise;
-            this._loaded = true;
-        }
     },
 
     /**
      * @return {!Promise.<undefined>}
      * @this {Runtime.Module}
      */
     _loadResources: function()
     {
         var resources = this._descriptor["resources"];
-        if (!resources)
+        if (!resources || !resources.length)
             return Promise.resolve();
         var promises = [];
         for (var i = 0; i < resources.length; ++i) {
             var url = this._modularizeURL(resources[i]);
             promises.push(Runtime.loadResourceIntoCache(url, true));
         }
         return Promise.all(promises).then(undefined);
     },
 
     /**
      * @return {!Promise.<undefined>}
      */
     _loadScripts: function()
     {
-        if (!this._descriptor.scripts)
+        if (!this._descriptor.scripts || !this._descriptor.scripts.length)
             return Promise.resolve();
-
-        if (Runtime.isReleaseMode())
-            return loadScriptsPromise([this._name + "_module.js"], this._remoteBase());
-
-        return loadScriptsPromise(this._descriptor.scripts.map(this._modularizeURL, this));
+        return loadScriptsPromise(this._descriptor.scripts.map(this._modularizeURL, this), this._remoteBase());

[dgozman, 2016/07/27 22:10:46]

This makes it hard to develop remote modules - they will be loaded from the
cloud. Let's remove "remote" bit from descriptor in debug build?

     },
 
     /**
      * @param {string} resourceName
      */
     _modularizeURL: function(resourceName)
     {
         return normalizePath(this._name + "/" + resourceName);
     },
 
@@ skipping 361 matching lines @@
 {
     var sourceURL = self.location.href;
     if (self.location.search)
         sourceURL = sourceURL.replace(self.location.search, "");
     sourceURL = sourceURL.substring(0, sourceURL.lastIndexOf("/") + 1) + path;
     return "\n/*# sourceURL=" + sourceURL + " */";
 }
 
 /** @type {!Runtime} */
 var runtime;