Revert of [DevTools] Extract platform module.

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 120 matching lines @@
     var sources = new Array(scriptNames.length);
     var scriptToEval = 0;
     for (var i = 0; i < scriptNames.length; ++i) {
         var scriptName = scriptNames[i];
         var sourceURL = self._importScriptPathPrefix + scriptName;
         var schemaIndex = sourceURL.indexOf("://") + 3;
         sourceURL = sourceURL.substring(0, schemaIndex) + normalizePath(sourceURL.substring(schemaIndex));
         if (_loadedScripts[sourceURL])
             continue;
         urls.push(sourceURL);
-        var thenCallback = scriptSourceLoaded.bind(null, i);
-        promises.push(loadResourcePromise(sourceURL).then(thenCallback, function(e) { thenCallback(undefined); }));
+        promises.push(loadResourcePromise(sourceURL).thenOrCatch(scriptSourceLoaded.bind(null, i)));
     }
     return Promise.all(promises).then(undefined);
 
     /**
      * @param {number} scriptNumber
      * @param {string=} scriptSource
      */
     function scriptSourceLoaded(scriptNumber, scriptSource)
     {
         sources[scriptNumber] = scriptSource || "";
@@ skipping 51 matching lines @@
     this._cachedTypeClasses = {};
 
     /**
      * @type {!Object.<string, !Runtime.ModuleDescriptor>}
      */
     this._descriptorsMap = {};
 
     for (var i = 0; i < descriptors.length; ++i)
         this._registerModule(descriptors[i]);
     if (coreModuleNames)
-        this._loadAutoStartModules(coreModuleNames).catch(Runtime._reportError);
+        this._loadAutoStartModules(coreModuleNames).done();
 }
 
 /**
  * @type {!Object.<string, string>}
  */
 Runtime._queryParamsObject = { __proto__: null };
 
 /**
  * @type {!Object.<string, string>}
  */
@@ skipping 110 matching lines @@
             var name = descriptor["name"];
             var moduleJSON = allDescriptorsByName[name];
             if (moduleJSON)
                 moduleJSONPromises.push(Promise.resolve(moduleJSON));
             else
                 moduleJSONPromises.push(loadResourcePromise(name + "/module.json").then(JSON.parse.bind(JSON)));
             if (descriptor["type"] === "autostart")
                 coreModuleNames.push(name);
         }
 
-        Promise.all(moduleJSONPromises).then(instantiateRuntime).catch(Runtime._reportError);
+        Promise.all(moduleJSONPromises).then(instantiateRuntime).done();
         /**
          * @param {!Array.<!Object>} moduleDescriptors
          */
         function instantiateRuntime(moduleDescriptors)
         {
             for (var i = 0; !Runtime.isReleaseMode() && i < moduleDescriptors.length; ++i)
                 moduleDescriptors[i]["name"] = configuration[i]["name"];
             self.runtime = new Runtime(moduleDescriptors, coreModuleNames);
         }
     }
@@ skipping 14 matching lines @@
 Runtime._experimentsSetting = function()
 {
     try {
         return /** @type {!Object} */ (JSON.parse(self.localStorage && self.localStorage["experiments"] ? self.localStorage["experiments"] : "{}"));
     } catch (e) {
         console.error("Failed to parse localStorage['experiments']");
         return {};
     }
 }
 
-/**
- * @param {!Array.<!Promise.<T, !Error>>} promises
- * @return {!Promise.<!Array.<T>>}
- * @template T
- */
-Runtime._some = function(promises)
-{
-    var all = [];
-    var wasRejected = [];
-    for (var i = 0; i < promises.length; ++i) {
-        // Workaround closure compiler bug.
-        var handlerFunction = /** @type {function()} */ (handler.bind(promises[i], i));
-        all.push(promises[i].catch(handlerFunction));
-    }
-
-    return Promise.all(all).then(filterOutFailuresResults);
-
-    /**
-     * @param {!Array.<T>} results
-     * @return {!Array.<T>}
-     * @template T
-     */
-    function filterOutFailuresResults(results)
-    {
-        var filtered = [];
-        for (var i = 0; i < results.length; ++i) {
-            if (!wasRejected[i])
-                filtered.push(results[i]);
-        }
-        return filtered;
-    }
-
-    /**
-     * @this {!Promise}
-     * @param {number} index
-     * @param {!Error} e
-     */
-    function handler(index, e)
-    {
-        wasRejected[index] = true;
-        console.error(e.stack);
-    }
-}
-
-Runtime._console = console;
-Runtime._originalAssert = console.assert;
-Runtime._assert = function(value, message)
-{
-    if (value)
-        return;
-    Runtime._originalAssert.call(Runtime._console, value, message);
-}
-
-/**
- * @param {*} e
- */
-Runtime._reportError = function(e)
-{
-    if (e instanceof Error)
-        console.error(e.stack);
-    else
-        console.error(e);
-}
-
 Runtime.prototype = {
 
     /**
      * @param {!Runtime.ModuleDescriptor} descriptor
      */
     _registerModule: function(descriptor)
     {
         var module = new Runtime.Module(this, descriptor);
         this._modules.push(module);
         this._modulesMap[descriptor["name"]] = module;
@@ skipping 141 matching lines @@
      * @param {*} type
      * @param {?Object=} context
      * @return {!Promise.<!Array.<!Object>>}
      */
     instancesPromise: function(type, context)
     {
         var extensions = this.extensions(type, context);
         var promises = [];
         for (var i = 0; i < extensions.length; ++i)
             promises.push(extensions[i].instancePromise());
-        return Runtime._some(promises);
+        return Promise.some(promises);
     },
 
     /**
      * @param {*} type
      * @param {?Object=} context
      * @return {!Promise.<!Object>}
      */
     instancePromise: function(type, context)
     {
         var extension = this.extension(type, context);
@@ skipping 129 matching lines @@
      * @return {!Promise.<undefined>}
      */
     _loadScripts: function()
     {
         if (!this._descriptor.scripts)
             return Promise.resolve(undefined);
 
         if (Runtime.isReleaseMode())
             return loadScriptsPromise([this._name + "_module.js"]);
 
-        return loadScriptsPromise(this._descriptor.scripts.map(modularizeURL, this)).catch(Runtime._reportError);
+        return loadScriptsPromise(this._descriptor.scripts.map(modularizeURL, this)).catchAndReport();
 
         /**
          * @param {string} scriptName
          * @this {Runtime.Module}
          */
         function modularizeURL(scriptName)
         {
             return this._name + "/" + scriptName;
         }
     },
@@ skipping 145 matching lines @@
         self.localStorage["experiments"] = JSON.stringify(value);
     },
 
     /**
      * @param {string} experimentName
      * @param {string} experimentTitle
      * @param {boolean=} hidden
      */
     register: function(experimentName, experimentTitle, hidden)
     {
-        Runtime._assert(!this._experimentNames[experimentName], "Duplicate registration of experiment " + experimentName);
+        console.assert(!this._experimentNames[experimentName], "Duplicate registration of experiment " + experimentName);
         this._experimentNames[experimentName] = true;
         this._experiments.push(new Runtime.Experiment(this, experimentName, experimentTitle, !!hidden));
     },
 
     /**
      * @param {string} experimentName
      * @return {boolean}
      */
     isEnabled: function(experimentName)
     {
@@ skipping 49 matching lines @@
                 cleanedUpExperimentSetting[experimentName] = true;
         }
         this._setExperimentsSetting(cleanedUpExperimentSetting);
     },
 
     /**
      * @param {string} experimentName
      */
     _checkExperiment: function(experimentName)
     {
-        Runtime._assert(this._experimentNames[experimentName], "Unknown experiment " + experimentName);
+        console.assert(this._experimentNames[experimentName], "Unknown experiment " + experimentName);
     }
 }
 
 /**
  * @constructor
  * @param {!Runtime.ExperimentsSupport} experiments
  * @param {string} name
  * @param {string} title
  * @param {boolean} hidden
  */
@@ skipping 40 matching lines @@
         try {
             var settings = JSON.parse(window.decodeURI(settingsParam));
             for (var key in settings)
                 window.localStorage[key] = settings[key];
         } catch(e) {
             // Ignore malformed settings.
         }
     }
 })();}
 
+/**
+ * @param {string} error
+ * @return {!Promise.<T>}
+ * @template T
+ */
+Promise.rejectWithError = function(error)
+{
+    return Promise.reject(new Error(error));
+}
+
+/**
+ * @param {function((T|undefined))} callback
+ * @return {!Promise.<T>}
+ * @template T
+ */
+Promise.prototype.thenOrCatch = function(callback)
+{
+    return this.then(callback, reject.bind(this));
+
+    /**
+     * @param {*} e
+     */
+    function reject(e)
+    {
+        this._reportError(e);
+        callback(undefined);
+    }
+}
+
+Promise.prototype.done = function()
+{
+    this.catchAndReport();
+}
+
+Promise.prototype.catchAndReport = function()
+{
+    return this.catch(this._reportError.bind(this));
+}
+
+/**
+ * @param {*} e
+ */
+Promise.prototype._reportError = function(e)
+{
+    if (e instanceof Error)
+        console.error(e.stack);
+    else
+        console.error(e);
+}
+
+/**
+ * @param {!Array.<!Promise.<T, !Error>>} promises
+ * @return {!Promise.<!Array.<T>>}
+ * @template T
+ */
+Promise.some = function(promises)
+{
+    var all = [];
+    var wasRejected = [];
+    for (var i = 0; i < promises.length; ++i) {
+        // Workaround closure compiler bug.
+        var handlerFunction = /** @type {function()} */ (handler.bind(promises[i], i));
+        all.push(promises[i].catch(handlerFunction));
+    }
+
+    return Promise.all(all).then(filterOutFailuresResults);
+
+    /**
+     * @param {!Array.<T>} results
+     * @return {!Array.<T>}
+     * @template T
+     */
+    function filterOutFailuresResults(results)
+    {
+        var filtered = [];
+        for (var i = 0; i < results.length; ++i) {
+            if (!wasRejected[i])
+                filtered.push(results[i]);
+        }
+        return filtered;
+    }
+
+    /**
+     * @this {!Promise}
+     * @param {number} index
+     * @param {!Error} e
+     */
+    function handler(index, e)
+    {
+        wasRejected[index] = true;
+        this._reportError(e);
+    }
+}
+
+// FIXME: This performance optimization should be moved to blink so that all developers could enjoy it.
+// console is retrieved with V8Window.getAttribute method which is slow. Here we copy it to a js variable for faster access.
+console = console;
+console.__originalAssert = console.assert;
+console.assert = function(value, message)
+{
+    if (value)
+        return;
+    console.__originalAssert(value, message);
+}
 
 // This must be constructed after the query parameters have been parsed.
 Runtime.experiments = new Runtime.ExperimentsSupport();
 
 /** @type {!Runtime} */
 var runtime;