RubyGems - middleman-wizard-template - Versions diffs - 1.0.0.pre.1 - Mend

middleman-wizard-template 1.0.0.pre.1

Files changed (1739) hide show

data/lib/middleman-wizard-template/template/closure/library/closure/goog/module/moduleloader_test.html ADDED Viewed

@@ -0,0 +1,436 @@
+<html>
+<!--
+Copyright 2009 The Closure Library Authors. All Rights Reserved.
+Use of this source code is governed by the Apache License, Version 2.0.
+See the COPYING file for details.
+-->
+<!--
+  A regression test for goog.module.ModuleLoader.
+  Unlike the unit tests for goog.module.ModuleManager, this uses
+  asynchronous test cases and real XHRs.
+  Author: nicksantos@google.com (Nick Santos)
+-->
+<head>
+<meta http-equiv="X-UA-Compatible" content="IE=edge">
+<title>JsUnit tests for goog.module.ModuleLoader</title>
+<script src='../base.js'></script>
+<script>
+goog.require('goog.array');
+goog.require('goog.dom');
+goog.require('goog.functions');
+goog.require('goog.module.ModuleLoader');
+goog.require('goog.module.ModuleManager');
+goog.require('goog.module.ModuleManager.CallbackType');
+goog.require('goog.object');
+goog.require('goog.testing.AsyncTestCase');
+goog.require('goog.testing.PropertyReplacer');
+goog.require('goog.testing.events.EventObserver');
+goog.require('goog.testing.jsunit');
+goog.require('goog.testing.recordFunction');
+goog.require('goog.userAgent.product');
+</script>
+</head>
+<body>
+<b>Note:</b>: If you are running this test off local disk on Chrome, it
+will fail unless you start Chrome with
+<code>--allow-file-access-from-files</code>.
+<script>
+var modA1Loaded = false;
+var modA2Loaded = false;
+var modB1Loaded = false;
+var moduleLoader = null;
+var moduleManager = null;
+var stubs = new goog.testing.PropertyReplacer();
+var testCase = goog.testing.AsyncTestCase.createAndInstall(document.title);
+testCase.stepTimeout = 5 * 1000; // 5 seconds
+var EventType = goog.module.ModuleLoader.EventType;
+var observer;
+testCase.setUp = function() {
+  modA1Loaded = false;
+  modA2Loaded = false;
+  modB1Loaded = false;
+  goog.provide = goog.nullFunction;
+  moduleManager = goog.module.ModuleManager.getInstance();
+  stubs.replace(moduleManager, 'getBackOff_', goog.functions.constant(0));
+  moduleLoader = new goog.module.ModuleLoader();
+  observer = new goog.testing.events.EventObserver();
+  goog.events.listen(
+      moduleLoader, goog.object.getValues(EventType), observer);
+  moduleManager.setLoader(moduleLoader);
+  moduleManager.setAllModuleInfo({
+      'modA': [],
+      'modB': ['modA']
+  });
+  moduleManager.setModuleUris({
+      'modA': ['testdata/modA_1.js', 'testdata/modA_2.js'],
+      'modB': ['testdata/modB_1.js']
+  });
+  assertNotLoaded('modA');
+  assertNotLoaded('modB');
+  assertFalse(modA1Loaded);
+};
+testCase.tearDown = function() {
+  stubs.reset();
+  // Ensure that the module manager was created.
+  assertNotNull(goog.module.ModuleManager.getInstance());
+  moduleManager = goog.module.ModuleManager.instance_ = null;
+  // tear down the module loaded flag.
+  modA1Loaded = false;
+  // Remove all the fake scripts.
+  var scripts = goog.array.clone(
+      document.getElementsByTagName('SCRIPT'));
+  for (var i = 0; i < scripts.length; i++) {
+    if (scripts[i].src.indexOf('testdata') != -1) {
+      goog.dom.removeNode(scripts[i]);
+    }
+  }
+};
+function testLoadModuleA() {
+  testCase.waitForAsync('wait for module A load');
+  moduleManager.execOnLoad('modA', function() {
+    testCase.continueTesting();
+    assertLoaded('modA');
+    assertNotLoaded('modB');
+    assertTrue(modA1Loaded);
+    assertEquals('EVALUATE_CODE',
+        0, observer.getEvents(EventType.EVALUATE_CODE).length);
+    assertEquals('REQUEST_SUCCESS',
+        1, observer.getEvents(EventType.REQUEST_SUCCESS).length);
+    assertArrayEquals(
+        ['modA'], observer.getEvents(EventType.REQUEST_SUCCESS)[0].moduleIds);
+    assertEquals('REQUEST_ERROR',
+        0, observer.getEvents(EventType.REQUEST_ERROR).length);
+  });
+}
+function testLoadModuleB() {
+  testCase.waitForAsync('wait for module B load');
+  moduleManager.execOnLoad('modB', function() {
+    testCase.continueTesting();
+    assertLoaded('modA');
+    assertLoaded('modB');
+    assertTrue(modA1Loaded);
+  });
+}
+function testLoadDebugModuleA() {
+  testCase.waitForAsync('wait for module A load');
+  moduleLoader.setDebugMode(true);
+  moduleManager.execOnLoad('modA', function() {
+    testCase.continueTesting();
+    assertLoaded('modA');
+    assertNotLoaded('modB');
+    assertTrue(modA1Loaded);
+  });
+}
+function testLoadDebugModuleB() {
+  testCase.waitForAsync('wait for module B load');
+  moduleLoader.setDebugMode(true);
+  moduleManager.execOnLoad('modB', function() {
+    testCase.continueTesting();
+    assertLoaded('modA');
+    assertLoaded('modB');
+    assertTrue(modA1Loaded);
+  });
+}
+function testLoadDebugModuleAThenB() {
+  // Swap the script tags of module A, to introduce a race condition.
+  // See the comments on this in ModuleLoader's debug loader.
+  moduleManager.setModuleUris({
+      'modA': ['testdata/modA_2.js', 'testdata/modA_1.js'],
+      'modB': ['testdata/modB_1.js']
+  });
+  testCase.waitForAsync('wait for module B load');
+  moduleLoader.setDebugMode(true);
+  moduleManager.execOnLoad('modB', function() {
+    testCase.continueTesting();
+    assertLoaded('modA');
+    assertLoaded('modB');
+    var scripts = goog.array.clone(
+        document.getElementsByTagName('SCRIPT'));
+    var seenLastScriptOfModuleA = false;
+    for (var i = 0; i < scripts.length; i++) {
+      var uri = scripts[i].src;
+      if (uri.indexOf('modA_1.js') >= 0) {
+        seenLastScriptOfModuleA = true;
+      } else if (uri.indexOf('modB') >= 0) {
+        assertTrue(seenLastScriptOfModuleA);
+      }
+    }
+  });
+}
+function testSourceInjection() {
+  testCase.waitForAsync('wait for module B load');
+  moduleLoader.setSourceUrlInjection(true);
+  moduleManager.execOnLoad('modB', function() {
+    testCase.continueTesting();
+    assertTrue(!!throwErrorInModuleB);
+    var ex = null;
+    try {
+      throwErrorInModuleB();
+    } catch (e) {
+      ex = e;
+    }
+    assertNotNull(ex);
+    // Chrome is currently the only browser that uses sourceURL
+    // when serializing stack traces.
+    if (goog.userAgent.product.CHROME) {
+      assertContains('modB_1.js', ex.stack.toString());
+    }
+  });
+}
+function testModuleLoaderRecursesTooDeep(opt_numModules) {
+  // There was a bug in the module loader where it would retry recursively
+  // whenever there was a synchronous failure in the module load. When you
+  // asked for modB, it would try to load its dependency modA. When modA
+  // failed, it would move onto modB, and then start over, repeating until it
+  // ran out of stack.
+  var numModules = opt_numModules || 1;
+  var uris = {};
+  var deps = {};
+  var mods = [];
+  for (var num = 0; num < numModules; num++) {
+    var modName = 'mod' + num;
+    mods.unshift(modName);
+    uris[modName] = [];
+    deps[modName] = num ? ['mod' + (num - 1)] : [];
+    for (var i = 0; i < 5; i++) {
+      uris[modName].push(
+          'http://www.google.com/crossdomain' + num + 'x' + i + '.js');
+    }
+  }
+  moduleManager.setAllModuleInfo(deps);
+  moduleManager.setModuleUris(uris);
+  // Make all XHRs throw an error, so that we test the error-handling
+  // functionality.
+  var oldXmlHttp = goog.net.XmlHttp;
+  stubs.set(goog.net, 'XmlHttp', function() {
+    return {
+       open: goog.functions.error('mock error'),
+       abort: goog.nullFunction
+    };
+  });
+  goog.object.extend(goog.net.XmlHttp, oldXmlHttp);
+  var errorCount = 0;
+  var errorIds = [];
+  var errorHandler = function(ignored, modId) {
+    errorCount++;
+    errorIds.push(modId);
+  };
+  moduleManager.registerCallback(
+      goog.module.ModuleManager.CallbackType.ERROR,
+      errorHandler);
+  moduleManager.execOnLoad(mods[0], function() {
+    fail('modB should not load successfully');
+  });
+  assertEquals(mods.length, errorCount);
+  goog.array.sort(mods);
+  goog.array.sort(errorIds);
+  assertArrayEquals(mods, errorIds);
+  assertArrayEquals([], moduleManager.requestedModuleIdsQueue_);
+  assertArrayEquals([], moduleManager.userInitiatedLoadingModuleIds_);
+}
+function testModuleLoaderRecursesTooDeep2modules() {
+  testModuleLoaderRecursesTooDeep(2);
+}
+function testModuleLoaderRecursesTooDeep3modules() {
+  testModuleLoaderRecursesTooDeep(3);
+}
+function testModuleLoaderRecursesTooDeep4modules() {
+  testModuleLoaderRecursesTooDeep(3);
+}
+function testErrback() {
+  // Don't run this test on IE, because the way the test runner catches
+  // errors on IE plays badly with the simulated errors in the test.
+  if (goog.userAgent.IE) return;
+  // Modules will throw an exception if this boolean is set to true.
+  modA1Loaded = true;
+  var errorHandler = function() {
+    testCase.continueTesting();
+    assertNotLoaded('modA');
+  };
+  moduleManager.registerCallback(
+      goog.module.ModuleManager.CallbackType.ERROR,
+      errorHandler);
+  moduleManager.execOnLoad('modA', function() {
+    fail('modA should not load successfully');
+  });
+  testCase.waitForAsync('wait for the error callback');
+}
+function testPrefetchThenLoadModuleA() {
+  moduleManager.prefetchModule('modA');
+  stubs.set(goog.net.BulkLoader.prototype, 'load', function() {
+    fail('modA should not be reloaded')
+  });
+  testCase.waitForAsync('wait for module A load');
+  moduleManager.execOnLoad('modA', function() {
+    testCase.continueTesting();
+    assertLoaded('modA');
+    assertEquals('REQUEST_SUCCESS',
+        1, observer.getEvents(EventType.REQUEST_SUCCESS).length);
+    assertArrayEquals(
+        ['modA'], observer.getEvents(EventType.REQUEST_SUCCESS)[0].moduleIds);
+    assertEquals('REQUEST_ERROR',
+        0, observer.getEvents(EventType.REQUEST_ERROR).length);
+  });
+}
+function testPrefetchThenLoadModuleB() {
+  moduleManager.prefetchModule('modB');
+  stubs.set(goog.net.BulkLoader.prototype, 'load', function() {
+    fail('modA and modB should not be reloaded')
+  });
+  testCase.waitForAsync('wait for module B load');
+  moduleManager.execOnLoad('modB', function() {
+    testCase.continueTesting();
+    assertLoaded('modA');
+    assertLoaded('modB');
+    assertEquals('REQUEST_SUCCESS',
+        2, observer.getEvents(EventType.REQUEST_SUCCESS).length);
+    assertArrayEquals(
+        ['modA'], observer.getEvents(EventType.REQUEST_SUCCESS)[0].moduleIds);
+    assertArrayEquals(
+        ['modB'], observer.getEvents(EventType.REQUEST_SUCCESS)[1].moduleIds);
+    assertEquals('REQUEST_ERROR',
+        0, observer.getEvents(EventType.REQUEST_ERROR).length);
+  });
+}
+function testPrefetchModuleAThenLoadModuleB() {
+  moduleManager.prefetchModule('modA');
+  testCase.waitForAsync('wait for module A load');
+  moduleManager.execOnLoad('modB', function() {
+    testCase.continueTesting();
+    assertLoaded('modA');
+    assertLoaded('modB');
+    assertEquals('REQUEST_SUCCESS',
+        2, observer.getEvents(EventType.REQUEST_SUCCESS).length);
+    assertArrayEquals(
+        ['modA'], observer.getEvents(EventType.REQUEST_SUCCESS)[0].moduleIds);
+    assertArrayEquals(
+        ['modB'], observer.getEvents(EventType.REQUEST_SUCCESS)[1].moduleIds);
+    assertEquals('REQUEST_ERROR',
+        0, observer.getEvents(EventType.REQUEST_ERROR).length);
+  });
+}
+function testLoadModuleBThenPrefetchModuleA() {
+  testCase.waitForAsync('wait for module A load');
+  moduleManager.execOnLoad('modB', function() {
+    testCase.continueTesting();
+    assertLoaded('modA');
+    assertLoaded('modB');
+    assertEquals('REQUEST_SUCCESS',
+        2, observer.getEvents(EventType.REQUEST_SUCCESS).length);
+    assertArrayEquals(
+        ['modA'], observer.getEvents(EventType.REQUEST_SUCCESS)[0].moduleIds);
+    assertArrayEquals(
+        ['modB'], observer.getEvents(EventType.REQUEST_SUCCESS)[1].moduleIds);
+    assertEquals('REQUEST_ERROR',
+        0, observer.getEvents(EventType.REQUEST_ERROR).length);
+    assertThrows('Module load already requested: modB',
+        function() {
+          moduleManager.prefetchModule('modA')
+        });
+  });
+}
+function testPrefetchModuleWithBatchModeEnabled() {
+  moduleManager.setBatchModeEnabled(true);
+  assertThrows('Modules prefetching is not supported in batch mode',
+      function() {
+        moduleManager.prefetchModule('modA');
+      });
+}
+function testLoadErrorCallbackExecutedWhenPrefetchFails() {
+  // Make all XHRs throw an error, so that we test the error-handling
+  // functionality.
+  var oldXmlHttp = goog.net.XmlHttp;
+  stubs.set(goog.net, 'XmlHttp', function() {
+    return {
+       open: goog.functions.error('mock error'),
+       abort: goog.nullFunction
+    };
+  });
+  goog.object.extend(goog.net.XmlHttp, oldXmlHttp);
+  var errorCount = 0;
+  var errorHandler = function() {
+    errorCount++;
+  };
+  moduleManager.registerCallback(
+      goog.module.ModuleManager.CallbackType.ERROR,
+      errorHandler);
+  moduleLoader.prefetchModule('modA', moduleManager.moduleInfoMap_['modA']);
+  moduleLoader.loadModules(['modA'], moduleManager.moduleInfoMap_,
+    function() {
+      fail('modA should not load successfully')
+    }, errorHandler);
+  assertEquals(1, errorCount);
+}
+function assertLoaded(id) {
+  assertTrue(moduleManager.getModuleInfo(id).isLoaded());
+}
+function assertNotLoaded(id) {
+  assertFalse(moduleManager.getModuleInfo(id).isLoaded());
+}
+</script>
+</body>
+</html>

data/lib/middleman-wizard-template/template/closure/library/closure/goog/module/modulemanager.js ADDED Viewed

@@ -0,0 +1,1257 @@
+// Copyright 2008 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+/**
+ * @fileoverview A singleton object for managing Javascript code modules.
+ *
+ */
+goog.provide('goog.module.ModuleManager');
+goog.provide('goog.module.ModuleManager.CallbackType');
+goog.provide('goog.module.ModuleManager.FailureType');
+goog.require('goog.Disposable');
+goog.require('goog.array');
+goog.require('goog.asserts');
+goog.require('goog.async.Deferred');
+goog.require('goog.debug.Logger');
+goog.require('goog.debug.Trace');
+goog.require('goog.module.ModuleInfo');
+goog.require('goog.module.ModuleLoadCallback');
+goog.require('goog.object');
+/**
+ * The ModuleManager keeps track of all modules in the environment.
+ * Since modules may not have their code loaded, we must keep track of them.
+ * @constructor
+ * @extends {goog.Disposable}
+ */
+goog.module.ModuleManager = function() {
+  goog.Disposable.call(this);
+  /**
+   * A mapping from module id to ModuleInfo object.
+   * @type {Object}
+   * @private
+   */
+  this.moduleInfoMap_ = {};
+  /**
+   * The ids of the currently loading modules. If batch mode is disabled, then
+   * this array will never contain more than one element at a time.
+   * @type {Array.<string>}
+   * @private
+   */
+  this.loadingModuleIds_ = [];
+  /**
+   * The requested ids of the currently loading modules. This does not include
+   * module dependencies that may also be loading.
+   * @type {Array.<string>}
+   * @private
+   */
+  this.requestedLoadingModuleIds_ = [];
+  /**
+   * A queue of the ids of requested but not-yet-loaded modules. The zero
+   * position is the front of the queue. This is a 2-D array to group modules
+   * together with other modules that should be batch loaded with them, if
+   * batch loading is enabled.
+   * @type {Array.<Array.<string>>}
+   * @private
+   */
+  this.requestedModuleIdsQueue_ = [];
+  /**
+   * The ids of the currently loading modules which have been initiated by user
+   * actions.
+   * @type {Array.<string>}
+   * @private
+   */
+  this.userInitiatedLoadingModuleIds_ = [];
+  /**
+   * A map of callback types to the functions to call for the specified
+   * callback type.
+   * @type {Object}
+   * @private
+   */
+  this.callbackMap_ = {};
+  /**
+   * Module info for the base module (the one that contains the module
+   * manager code), which we set as the loading module so one can
+   * register initialization callbacks in the base module.
+   *
+   * The base module is considered loaded when #setAllModuleInfo is called or
+   * #setModuleContext is called, whichever comes first.
+   *
+   * @type {goog.module.ModuleInfo}
+   * @private
+   */
+  this.baseModuleInfo_ = new goog.module.ModuleInfo([], '');
+  /**
+   * The module that is currently loading, or null if not loading anything.
+   * @type {goog.module.ModuleInfo}
+   * @private
+   */
+  this.currentlyLoadingModule_ = this.baseModuleInfo_;
+};
+goog.inherits(goog.module.ModuleManager, goog.Disposable);
+goog.addSingletonGetter(goog.module.ModuleManager);
+/**
+* The type of callbacks that can be registered with the module manager,.
+* @enum {string}
+*/
+goog.module.ModuleManager.CallbackType = {
+  /**
+   * Fired when an error has occurred.
+   */
+  ERROR: 'error',
+  /**
+   * Fired when it becomes idle and has no more module loads to process.
+   */
+  IDLE: 'idle',
+  /**
+   * Fired when it becomes active and has module loads to process.
+   */
+  ACTIVE: 'active',
+  /**
+   * Fired when it becomes idle and has no more user-initiated module loads to
+   * process.
+   */
+  USER_IDLE: 'userIdle',
+  /**
+   * Fired when it becomes active and has user-initiated module loads to
+   * process.
+   */
+  USER_ACTIVE: 'userActive'
+};
+/**
+ * A non-HTTP status code indicating a corruption in loaded module.
+ * This should be used by a ModuleLoader as a replacement for the HTTP code
+ * given to the error handler function to indicated that the module was
+ * corrupted.
+ * This will set the forceReload flag on the loadModules method when retrying
+ * module loading.
+ * @type {number}
+ */
+goog.module.ModuleManager.CORRUPT_RESPONSE_STATUS_CODE = 8001;
+/**
+ * A logger.
+ * @type {goog.debug.Logger}
+ * @private
+ */
+goog.module.ModuleManager.prototype.logger_ = goog.debug.Logger.getLogger(
+    'goog.module.ModuleManager');
+/**
+ * Whether the batch mode (i.e. the loading of multiple modules with just one
+ * request) has been enabled.
+ * @type {boolean}
+ * @private
+ */
+goog.module.ModuleManager.prototype.batchModeEnabled_ = false;
+/**
+ * A loader for the modules that implements loadModules(ids, moduleInfoMap,
+ * opt_successFn, opt_errorFn, opt_timeoutFn, opt_forceReload) method.
+ * @type {goog.module.AbstractModuleLoader}
+ * @private
+ */
+goog.module.ModuleManager.prototype.loader_ = null;
+// TODO(user): Remove tracer.
+/**
+ * Tracer that measures how long it takes to load a module.
+ * @type {?number}
+ * @private
+ */
+goog.module.ModuleManager.prototype.loadTracer_ = null;
+/**
+ * The number of consecutive failures that have happened upon module load
+ * requests.
+ * @type {number}
+ * @private
+ */
+goog.module.ModuleManager.prototype.consecutiveFailures_ = 0;
+/**
+ * Determines if the module manager was just active before the processing of
+ * the last data.
+ * @type {boolean}
+ * @private
+ */
+goog.module.ModuleManager.prototype.lastActive_ = false;
+/**
+ * Determines if the module manager was just user active before the processing
+ * of the last data. The module manager is user active if any of the
+ * user-initiated modules are loading or queued up to load.
+ * @type {boolean}
+ * @private
+ */
+goog.module.ModuleManager.prototype.userLastActive_ = false;
+/**
+ * The module context needed for module initialization.
+ * @type {Object}
+ * @private
+ */
+goog.module.ModuleManager.prototype.moduleContext_ = null;
+/**
+ * Sets the batch mode as enabled or disabled for the module manager.
+ * @param {boolean} enabled Whether the batch mode is to be enabled or not.
+ */
+goog.module.ModuleManager.prototype.setBatchModeEnabled = function(
+    enabled) {
+  this.batchModeEnabled_ = enabled;
+};
+/**
+ * Sets the module info for all modules. Should only be called once.
+ *
+ * @param {Object.<Array.<string>>} infoMap An object that contains a mapping
+ *    from module id (String) to list of required module ids (Array).
+ */
+goog.module.ModuleManager.prototype.setAllModuleInfo = function(infoMap) {
+  for (var id in infoMap) {
+    this.moduleInfoMap_[id] = new goog.module.ModuleInfo(infoMap[id], id);
+  }
+  this.maybeFinishBaseLoad_();
+};
+/**
+ * Sets the module info for all modules. Should only be called once. Also
+ * marks modules that are currently being loaded.
+ *
+ * @param {string=} opt_info A string representation of the module dependency
+ *      graph, in the form: module1:dep1,dep2/module2:dep1,dep2 etc.
+ *     Where depX is the base-36 encoded position of the dep in the module list.
+ * @param {Array.<string>=} opt_loadingModuleIds A list of moduleIds that
+ *     are currently being loaded.
+ */
+goog.module.ModuleManager.prototype.setAllModuleInfoString = function(
+    opt_info, opt_loadingModuleIds) {
+  if (!goog.isString(opt_info)) {
+    // The call to this method is generated in two steps, the argument is added
+    // after some of the compilation passes.  This means that the initial code
+    // doesn't have any arguments and causes compiler errors.  We make it
+    // optional to satisfy this constraint.
+    return;
+  }
+  var modules = opt_info.split('/');
+  var moduleIds = [];
+  // Split the string into the infoMap of id->deps
+  for (var i = 0; i < modules.length; i++) {
+    var parts = modules[i].split(':');
+    var id = parts[0];
+    var deps;
+    if (parts[1]) {
+      deps = parts[1].split(',');
+      for (var j = 0; j < deps.length; j++) {
+        var index = parseInt(deps[j], 36);
+        goog.asserts.assert(
+            moduleIds[index], 'No module @ %s, dep of %s @ %s', index, id, i);
+        deps[j] = moduleIds[index];
+      }
+    } else {
+      deps = [];
+    }
+    moduleIds.push(id);
+    this.moduleInfoMap_[id] = new goog.module.ModuleInfo(deps, id);
+  }
+  if (opt_loadingModuleIds) {
+    goog.array.extend(this.loadingModuleIds_, opt_loadingModuleIds);
+  }
+  this.maybeFinishBaseLoad_();
+};
+/**
+ * Gets a module info object by id.
+ * @param {string} id A module identifier.
+ * @return {goog.module.ModuleInfo} The module info.
+ */
+goog.module.ModuleManager.prototype.getModuleInfo = function(id) {
+  return this.moduleInfoMap_[id];
+};
+/**
+ * Sets the module uris.
+ *
+ * @param {Object} moduleUriMap The map of id/uris pairs for each module.
+ */
+goog.module.ModuleManager.prototype.setModuleUris = function(moduleUriMap) {
+  for (var id in moduleUriMap) {
+    this.moduleInfoMap_[id].setUris(moduleUriMap[id]);
+  }
+};
+/**
+ * Gets the application-specific module loader.
+ * @return {goog.module.AbstractModuleLoader} An object that has a
+ *     loadModules(ids, moduleInfoMap, opt_successFn, opt_errFn,
+ *         opt_timeoutFn, opt_forceReload) method.
+ */
+goog.module.ModuleManager.prototype.getLoader = function() {
+  return this.loader_;
+};
+/**
+ * Sets the application-specific module loader.
+ * @param {goog.module.AbstractModuleLoader} loader An object that has a
+ *     loadModules(ids, moduleInfoMap, opt_successFn, opt_errFn,
+ *         opt_timeoutFn, opt_forceReload) method.
+ */
+goog.module.ModuleManager.prototype.setLoader = function(loader) {
+  this.loader_ = loader;
+};
+/**
+ * Gets the module context to use to initialize the module.
+ * @return {Object} The context.
+ */
+goog.module.ModuleManager.prototype.getModuleContext = function() {
+  return this.moduleContext_;
+};
+/**
+ * Sets the module context to use to initialize the module.
+ * @param {Object} context The context.
+ */
+goog.module.ModuleManager.prototype.setModuleContext = function(context) {
+  this.moduleContext_ = context;
+  this.maybeFinishBaseLoad_();
+};
+/**
+ * Determines if the ModuleManager is active
+ * @return {boolean} TRUE iff the ModuleManager is active (i.e., not idle).
+ */
+goog.module.ModuleManager.prototype.isActive = function() {
+  return this.loadingModuleIds_.length > 0;
+};
+/**
+ * Determines if the ModuleManager is user active
+ * @return {boolean} TRUE iff the ModuleManager is user active (i.e., not idle).
+ */
+goog.module.ModuleManager.prototype.isUserActive = function() {
+  return this.userInitiatedLoadingModuleIds_.length > 0;
+};
+/**
+ * Dispatches an ACTIVE or IDLE event if necessary.
+ * @private
+ */
+goog.module.ModuleManager.prototype.dispatchActiveIdleChangeIfNeeded_ =
+    function() {
+  var lastActive = this.lastActive_;
+  var active = this.isActive();
+  if (active != lastActive) {
+    this.executeCallbacks_(active ?
+        goog.module.ModuleManager.CallbackType.ACTIVE :
+        goog.module.ModuleManager.CallbackType.IDLE);
+    // Flip the last active value.
+    this.lastActive_ = active;
+  }
+  // Check if the module manager is user active i.e., there are user initiated
+  // modules being loaded or queued up to be loaded.
+  var userLastActive = this.userLastActive_;
+  var userActive = this.isUserActive();
+  if (userActive != userLastActive) {
+    this.executeCallbacks_(userActive ?
+        goog.module.ModuleManager.CallbackType.USER_ACTIVE :
+        goog.module.ModuleManager.CallbackType.USER_IDLE);
+    // Flip the last user active value.
+    this.userLastActive_ = userActive;
+  }
+};
+/**
+ * Preloads a module after a short delay.
+ *
+ * @param {string} id The id of the module to preload.
+ * @param {number=} opt_timeout The number of ms to wait before adding the
+ *     module id to the loading queue (defaults to 0 ms). Note that the module
+ *     will be loaded asynchronously regardless of the value of this parameter.
+ * @return {goog.async.Deferred} A deferred object.
+ */
+goog.module.ModuleManager.prototype.preloadModule = function(
+    id, opt_timeout) {
+  var d = new goog.async.Deferred();
+  window.setTimeout(
+      goog.bind(this.addLoadModule_, this, id, d),
+      opt_timeout || 0);
+  return d;
+};
+/**
+ * Prefetches a JavaScript module and its dependencies, which means that the
+ * module will be downloaded, but not evaluated. To complete the module load,
+ * the caller should also call load or execOnLoad after prefetching the module.
+ *
+ * @param {string} id The id of the module to prefetch.
+ */
+goog.module.ModuleManager.prototype.prefetchModule = function(id) {
+  var moduleInfo = this.getModuleInfo(id);
+  if (moduleInfo.isLoaded() || this.isModuleLoading(id)) {
+    throw Error('Module load already requested: ' + id);
+  } else if (this.batchModeEnabled_) {
+    throw Error('Modules prefetching is not supported in batch mode');
+  } else {
+    var idWithDeps = this.getNotYetLoadedTransitiveDepIds_(id);
+    for (var i = 0; i < idWithDeps.length; i++) {
+      this.loader_.prefetchModule(idWithDeps[i],
+          this.moduleInfoMap_[idWithDeps[i]]);
+    }
+  }
+};
+/**
+ * Loads a single module for use with a given deferred.
+ *
+ * @param {string} id The id of the module to load.
+ * @param {goog.async.Deferred} d A deferred object.
+ * @private
+ */
+goog.module.ModuleManager.prototype.addLoadModule_ = function(id, d) {
+  var moduleInfo = this.getModuleInfo(id);
+  if (moduleInfo.isLoaded()) {
+    d.callback(this.moduleContext_);
+    return;
+  }
+  this.registerModuleLoadCallbacks_(id, moduleInfo, false, d);
+  if (!this.isModuleLoading(id)) {
+    this.loadModulesOrEnqueue_([id]);
+  }
+};
+/**
+ * Loads a list of modules or, if some other module is currently being loaded,
+ * appends the ids to the queue of requested module ids. Registers callbacks a
+ * module that is currently loading and returns a fired deferred for a module
+ * that is already loaded.
+ *
+ * @param {Array.<string>} ids The id of the module to load.
+ * @param {boolean=} opt_userInitiated If the load is a result of a user action.
+ * @return {Object.<!goog.async.Deferred>} A mapping from id (String) to
+ *     deferred objects that will callback or errback when the load for that
+ *     id is finished.
+ * @private
+ */
+goog.module.ModuleManager.prototype.loadModulesOrEnqueueIfNotLoadedOrLoading_ =
+    function(ids, opt_userInitiated) {
+  var uniqueIds = [];
+  goog.array.removeDuplicates(ids, uniqueIds);
+  var idsToLoad = [];
+  var deferredMap = {};
+  for (var i = 0; i < uniqueIds.length; i++) {
+    var id = uniqueIds[i];
+    var moduleInfo = this.getModuleInfo(id);
+    var d = new goog.async.Deferred();
+    deferredMap[id] = d;
+    if (moduleInfo.isLoaded()) {
+      d.callback(this.moduleContext_);
+    } else {
+      this.registerModuleLoadCallbacks_(id, moduleInfo, !!opt_userInitiated, d);
+      if (!this.isModuleLoading(id)) {
+        idsToLoad.push(id);
+      }
+    }
+  }
+  // If there are ids to load, load them, otherwise, they are all loading or
+  // loaded.
+  if (idsToLoad.length > 0) {
+    this.loadModulesOrEnqueue_(idsToLoad);
+  }
+  return deferredMap;
+};
+/**
+ * Registers the callbacks and handles logic if it is a user initiated module
+ * load.
+ *
+ * @param {string} id The id of the module to possibly load.
+ * @param {!goog.module.ModuleInfo} moduleInfo The module identifier for the
+ *     given id.
+ * @param {boolean} userInitiated If the load was user initiated.
+ * @param {goog.async.Deferred} d A deferred object.
+ * @private
+ */
+goog.module.ModuleManager.prototype.registerModuleLoadCallbacks_ =
+    function(id, moduleInfo, userInitiated, d) {
+  moduleInfo.registerCallback(d.callback, d);
+  moduleInfo.registerErrback(function(err) { d.errback(Error(err)); });
+  // If it's already loading, we don't have to do anything besides handle
+  // if it was user initiated
+  if (this.isModuleLoading(id)) {
+    if (userInitiated) {
+      this.logger_.info('User initiated module already loading: ' + id);
+      this.addUserInitiatedLoadingModule_(id);
+      this.dispatchActiveIdleChangeIfNeeded_();
+    }
+  } else {
+    if (userInitiated) {
+      this.logger_.info('User initiated module load: ' + id);
+      this.addUserInitiatedLoadingModule_(id);
+    } else {
+      this.logger_.info('Initiating module load: ' + id);
+    }
+  }
+};
+/**
+ * Initiates loading of a list of modules or, if a module is currently being
+ * loaded, appends the modules to the queue of requested module ids.
+ *
+ * The caller should verify that the requested modules are not already loaded or
+ * loading. {@link #loadModulesOrEnqueueIfNotLoadedOrLoading_} is a more lenient
+ * alternative to this method.
+ *
+ * @param {Array.<string>} ids The ids of the modules to load.
+ * @private
+ */
+goog.module.ModuleManager.prototype.loadModulesOrEnqueue_ = function(ids) {
+  if (goog.array.isEmpty(this.loadingModuleIds_)) {
+    this.loadModules_(ids);
+  } else {
+    this.requestedModuleIdsQueue_.push(ids);
+    this.dispatchActiveIdleChangeIfNeeded_();
+  }
+};
+/**
+ * Gets the amount of delay to wait before sending a request for more modules.
+ * If a certain module request fails, we backoff a little bit and try again.
+ * @return {number} Delay, in ms.
+ * @private
+ */
+goog.module.ModuleManager.prototype.getBackOff_ = function() {
+  // 5 seconds after one error, 20 seconds after 2.
+  return Math.pow(this.consecutiveFailures_, 2) * 5000;
+};
+/**
+ * Loads a list of modules and any of their not-yet-loaded prerequisites.
+ * If batch mode is enabled, the prerequisites will be loaded together with the
+ * requested modules and all requested modules will be loaded at the same time.
+ *
+ * The caller should verify that the requested modules are not already loaded
+ * and that no modules are currently loading before calling this method.
+ *
+ * @param {Array.<string>} ids The ids of the modules to load.
+ * @param {boolean=} opt_isRetry If the load is a retry of a previous load
+ *     attempt.
+ * @param {boolean=} opt_forceReload Whether to bypass cache while loading the
+ *     module.
+ * @private
+ */
+goog.module.ModuleManager.prototype.loadModules_ = function(
+    ids, opt_isRetry, opt_forceReload) {
+  if (!opt_isRetry) {
+    this.consecutiveFailures_ = 0;
+  }
+  // Not all modules may be loaded immediately if batch mode is not enabled.
+  var idsToLoadImmediately = this.processModulesForLoad_(ids);
+  this.logger_.info('Loading module(s): ' + idsToLoadImmediately);
+  this.loadingModuleIds_ = idsToLoadImmediately;
+  if (this.batchModeEnabled_) {
+    this.requestedLoadingModuleIds_ = ids;
+  } else {
+    // If batch mode is disabled, we treat each dependency load as a separate
+    // load.
+    this.requestedLoadingModuleIds_ = goog.array.clone(idsToLoadImmediately);
+  }
+  // Dispatch an active/idle change if needed.
+  this.dispatchActiveIdleChangeIfNeeded_();
+  var loadFn = goog.bind(this.loader_.loadModules, this.loader_,
+      goog.array.clone(idsToLoadImmediately),
+      this.moduleInfoMap_,
+      null,
+      goog.bind(this.handleLoadError_, this),
+      goog.bind(this.handleLoadTimeout_, this),
+      !!opt_forceReload);
+  var delay = this.getBackOff_();
+  if (delay) {
+    window.setTimeout(loadFn, delay);
+  } else {
+    loadFn();
+  }
+};
+/**
+ * Processes a list of module ids for loading. Checks if any of the modules are
+ * already loaded and then gets transitive deps. Queues any necessary modules
+ * if batch mode is not enabled. Returns the list of ids that should be loaded.
+ *
+ * @param {Array.<string>} ids The ids that need to be loaded.
+ * @return {Array.<string>} The ids to load, including dependencies.
+ * @throws {Error} If the module is already loaded.
+ * @private
+ */
+goog.module.ModuleManager.prototype.processModulesForLoad_ = function(ids) {
+  for (var i = 0; i < ids.length; i++) {
+    var moduleInfo = this.moduleInfoMap_[ids[i]];
+    if (moduleInfo.isLoaded()) {
+      throw Error('Module already loaded: ' + ids[i]);
+    }
+  }
+  // Build a list of the ids of this module and any of its not-yet-loaded
+  // prerequisite modules in dependency order.
+  var idsWithDeps = [];
+  for (var i = 0; i < ids.length; i++) {
+    idsWithDeps = idsWithDeps.concat(
+        this.getNotYetLoadedTransitiveDepIds_(ids[i]));
+  }
+  goog.array.removeDuplicates(idsWithDeps);
+  if (!this.batchModeEnabled_ && idsWithDeps.length > 1) {
+    var idToLoad = idsWithDeps.shift();
+    this.logger_.info('Must load ' + idToLoad + ' module before ' + ids);
+    // Insert the requested module id and any other not-yet-loaded prereqs
+    // that it has at the front of the queue.
+    var queuedModules = goog.array.map(idsWithDeps, function(id) {
+      return [id];
+    });
+    this.requestedModuleIdsQueue_ = queuedModules.concat(
+        this.requestedModuleIdsQueue_);
+    return [idToLoad];
+  } else {
+    return idsWithDeps;
+  }
+};
+/**
+ * Builds a list of the ids of the not-yet-loaded modules that a particular
+ * module transitively depends on, including itself.
+ *
+ * @param {string} id The id of a not-yet-loaded module.
+ * @return {Array.<string>} An array of module ids in dependency order that's
+ *     guaranteed to end with the provided module id.
+ * @private
+ */
+goog.module.ModuleManager.prototype.getNotYetLoadedTransitiveDepIds_ =
+    function(id) {
+  // NOTE(user): We want the earliest occurrance of a module, not the first
+  // dependency we find. Therefore we strip duplicates at the end rather than
+  // during.  See the tests for concrete examples.
+  var ids = [id];
+  var depIds = goog.array.clone(this.getModuleInfo(id).getDependencies());
+  while (depIds.length) {
+    var depId = depIds.pop();
+    if (!this.getModuleInfo(depId).isLoaded()) {
+      ids.unshift(depId);
+      // We need to process direct dependencies first.
+      Array.prototype.unshift.apply(depIds,
+          this.getModuleInfo(depId).getDependencies());
+    }
+  }
+  goog.array.removeDuplicates(ids);
+  return ids;
+};
+/**
+ * If we are still loading the base module, consider the load complete.
+ * @private
+ */
+goog.module.ModuleManager.prototype.maybeFinishBaseLoad_ = function() {
+  if (this.currentlyLoadingModule_ == this.baseModuleInfo_) {
+    this.currentlyLoadingModule_ = null;
+    var error = this.baseModuleInfo_.onLoad(
+        goog.bind(this.getModuleContext, this));
+    if (error) {
+      this.dispatchModuleLoadFailed_(
+          goog.module.ModuleManager.FailureType.INIT_ERROR);
+    }
+  }
+};
+/**
+ * Records that a module was loaded. Also initiates loading the next module if
+ * any module requests are queued. This method is called by code that is
+ * generated and appended to each dynamic module's code at compilation time.
+ *
+ * @param {string} id A module id.
+ */
+goog.module.ModuleManager.prototype.setLoaded = function(id) {
+  if (this.isDisposed()) {
+    this.logger_.warning(
+        'Module loaded after module manager was disposed: ' + id);
+    return;
+  }
+  this.logger_.info('Module loaded: ' + id);
+  var error = this.moduleInfoMap_[id].onLoad(
+      goog.bind(this.getModuleContext, this));
+  if (error) {
+    this.dispatchModuleLoadFailed_(
+        goog.module.ModuleManager.FailureType.INIT_ERROR);
+  }
+  // Remove the module id from the user initiated set if it existed there.
+  goog.array.remove(this.userInitiatedLoadingModuleIds_, id);
+  // Remove the module id from the loading modules if it exists there.
+  goog.array.remove(this.loadingModuleIds_, id);
+  if (goog.array.isEmpty(this.loadingModuleIds_)) {
+    // No more modules are currently being loaded (e.g. arriving later in the
+    // same HTTP response), so proceed to load the next module in the queue.
+    this.loadNextModules_();
+  }
+  // Dispatch an active/idle change if needed.
+  this.dispatchActiveIdleChangeIfNeeded_();
+};
+/**
+ * Gets whether a module is currently loading or in the queue, waiting to be
+ * loaded.
+ * @param {string} id A module id.
+ * @return {boolean} TRUE iff the module is loading.
+ */
+goog.module.ModuleManager.prototype.isModuleLoading = function(id) {
+  if (goog.array.contains(this.loadingModuleIds_, id)) {
+    return true;
+  }
+  for (var i = 0; i < this.requestedModuleIdsQueue_.length; i++) {
+    if (goog.array.contains(this.requestedModuleIdsQueue_[i], id)) {
+      return true;
+    }
+  }
+  return false;
+};
+/**
+ * Requests that a function be called once a particular module is loaded.
+ * Client code can use this method to safely call into modules that may not yet
+ * be loaded. For consistency, this method always calls the function
+ * asynchronously -- even if the module is already loaded. Initiates loading of
+ * the module if necessary, unless opt_noLoad is true.
+ *
+ * @param {string} moduleId A module id.
+ * @param {Function} fn Function to execute when the module has loaded.
+ * @param {Object=} opt_handler Optional handler under whose scope to execute
+ *     the callback.
+ * @param {boolean=} opt_noLoad TRUE iff not to initiate loading of the module.
+ * @param {boolean=} opt_userInitiated TRUE iff the loading of the module was
+ *     user initiated.
+ * @param {boolean=} opt_preferSynchronous TRUE iff the function should be
+ *     executed synchronously if the module has already been loaded.
+ * @return {goog.module.ModuleLoadCallback} A callback wrapper that exposes
+ *     an abort and execute method.
+ */
+goog.module.ModuleManager.prototype.execOnLoad = function(
+    moduleId, fn, opt_handler, opt_noLoad,
+    opt_userInitiated, opt_preferSynchronous) {
+  var moduleInfo = this.moduleInfoMap_[moduleId];
+  var callbackWrapper;
+  if (moduleInfo.isLoaded()) {
+    this.logger_.info(moduleId + ' module already loaded');
+    // Call async so that code paths don't change between loaded and unloaded
+    // cases.
+    callbackWrapper = new goog.module.ModuleLoadCallback(fn, opt_handler);
+    if (opt_preferSynchronous) {
+      callbackWrapper.execute(this.moduleContext_);
+    } else {
+      window.setTimeout(
+          goog.bind(callbackWrapper.execute, callbackWrapper), 0);
+    }
+  } else if (this.isModuleLoading(moduleId)) {
+    this.logger_.info(moduleId + ' module already loading');
+    callbackWrapper = moduleInfo.registerCallback(fn, opt_handler);
+    if (opt_userInitiated) {
+      this.logger_.info('User initiated module already loading: ' + moduleId);
+      this.addUserInitiatedLoadingModule_(moduleId);
+      this.dispatchActiveIdleChangeIfNeeded_();
+    }
+  } else {
+    this.logger_.info('Registering callback for module: ' + moduleId);
+    callbackWrapper = moduleInfo.registerCallback(fn, opt_handler);
+    if (!opt_noLoad) {
+      if (opt_userInitiated) {
+        this.logger_.info('User initiated module load: ' + moduleId);
+        this.addUserInitiatedLoadingModule_(moduleId);
+      }
+      this.logger_.info('Initiating module load: ' + moduleId);
+      this.loadModulesOrEnqueue_([moduleId]);
+    }
+  }
+  return callbackWrapper;
+};
+/**
+ * Loads a module, returning a goog.async.Deferred for keeping track of the
+ * result.
+ *
+ * @param {string} moduleId A module id.
+ * @param {boolean=} opt_userInitiated If the load is a result of a user action.
+ * @return {goog.async.Deferred} A deferred object.
+ */
+goog.module.ModuleManager.prototype.load = function(
+    moduleId, opt_userInitiated) {
+  return this.loadModulesOrEnqueueIfNotLoadedOrLoading_(
+      [moduleId], opt_userInitiated)[moduleId];
+};
+/**
+ * Loads a list of modules, returning a goog.async.Deferred for keeping track of
+ * the result.
+ *
+ * @param {Array.<string>} moduleIds A list of module ids.
+ * @param {boolean=} opt_userInitiated If the load is a result of a user action.
+ * @return {Object.<!goog.async.Deferred>} A mapping from id (String) to
+ *     deferred objects that will callback or errback when the load for that
+ *     id is finished.
+ */
+goog.module.ModuleManager.prototype.loadMultiple = function(
+    moduleIds, opt_userInitiated) {
+  return this.loadModulesOrEnqueueIfNotLoadedOrLoading_(
+      moduleIds, opt_userInitiated);
+};
+/**
+ * Ensures that the module with the given id is listed as a user-initiated
+ * module that is being loaded. This method guarantees that a module will never
+ * get listed more than once.
+ * @param {string} id Identifier of the module.
+ * @private
+ */
+goog.module.ModuleManager.prototype.addUserInitiatedLoadingModule_ = function(
+    id) {
+  if (!goog.array.contains(this.userInitiatedLoadingModuleIds_, id)) {
+    this.userInitiatedLoadingModuleIds_.push(id);
+  }
+};
+/**
+ * Method called just before a module code is loaded.
+ * @param {string} id Identifier of the module.
+ */
+goog.module.ModuleManager.prototype.beforeLoadModuleCode = function(id) {
+  this.loadTracer_ = goog.debug.Trace.startTracer('Module Load: ' + id,
+      'Module Load');
+  if (this.currentlyLoadingModule_) {
+    this.logger_.severe('beforeLoadModuleCode called with module "' + id +
+                        '" while module "' +
+                        this.currentlyLoadingModule_.getId() +
+                        '" is loading');
+  }
+  this.currentlyLoadingModule_ = this.getModuleInfo(id);
+};
+/**
+ * Method called just after module code is loaded
+ * @param {string} id Identifier of the module.
+ */
+goog.module.ModuleManager.prototype.afterLoadModuleCode = function(id) {
+  if (!this.currentlyLoadingModule_ ||
+      id != this.currentlyLoadingModule_.getId()) {
+    this.logger_.severe('afterLoadModuleCode called with module "' + id +
+                        '" while loading module "' +
+                        (this.currentlyLoadingModule_ &&
+                         this.currentlyLoadingModule_.getId()) + '"');
+  }
+  this.currentlyLoadingModule_ = null;
+  goog.debug.Trace.stopTracer(this.loadTracer_);
+};
+/**
+ * Register an initialization callback for the currently loading module. This
+ * should only be called by script that is executed during the evaluation of
+ * a module's javascript. This is almost equivalent to calling the function
+ * inline, but ensures that all the code from the currently loading module
+ * has been loaded. This makes it cleaner and more robust than calling the
+ * function inline.
+ *
+ * If this function is called from the base module (the one that contains
+ * the module manager code), the callback is held until #setAllModuleInfo
+ * is called, or until #setModuleContext is called, whichever happens first.
+ *
+ * @param {Function} fn A callback function that takes a single argument
+ *    which is the module context.
+ * @param {Object=} opt_handler Optional handler under whose scope to execute
+ *     the callback.
+ */
+goog.module.ModuleManager.prototype.registerInitializationCallback = function(
+    fn, opt_handler) {
+  if (!this.currentlyLoadingModule_) {
+    this.logger_.severe('No module is currently loading');
+  } else {
+    this.currentlyLoadingModule_.registerEarlyCallback(fn, opt_handler);
+  }
+};
+/**
+ * Register a late initialization callback for the currently loading module.
+ * Callbacks registered via this function are executed similar to
+ * {@see registerInitializationCallback}, but they are fired after all
+ * initialization callbacks are called.
+ *
+ * @param {Function} fn A callback function that takes a single argument
+ *    which is the module context.
+ * @param {Object=} opt_handler Optional handler under whose scope to execute
+ *     the callback.
+ */
+goog.module.ModuleManager.prototype.registerLateInitializationCallback =
+    function(fn, opt_handler) {
+  if (!this.currentlyLoadingModule_) {
+    this.logger_.severe('No module is currently loading');
+  } else {
+    this.currentlyLoadingModule_.registerCallback(fn, opt_handler);
+  }
+};
+/**
+ * Sets the constructor to use for the module object for the currently
+ * loading module. The constructor should derive from {@see
+ * goog.module.BaseModule}.
+ * @param {Function} fn The constructor function.
+ */
+goog.module.ModuleManager.prototype.setModuleConstructor = function(fn) {
+  if (!this.currentlyLoadingModule_) {
+    this.logger_.severe('No module is currently loading');
+    return;
+  }
+  this.currentlyLoadingModule_.setModuleConstructor(fn);
+};
+/**
+ * The possible reasons for a module load failure callback being fired.
+ * @enum {number}
+ */
+goog.module.ModuleManager.FailureType = {
+  /** 401 Status. */
+  UNAUTHORIZED: 0,
+  /** Error status (not 401) returned multiple times. */
+  CONSECUTIVE_FAILURES: 1,
+  /** Request timeout. */
+  TIMEOUT: 2,
+  /** 410 status, old code gone. */
+  OLD_CODE_GONE: 3,
+  /** The onLoad callbacks failed. */
+  INIT_ERROR: 4
+};
+/**
+ * Handles a module load failure.
+ *
+ * @param {?number} status The error status.
+ * @private
+ */
+goog.module.ModuleManager.prototype.handleLoadError_ = function(status) {
+  this.consecutiveFailures_++;
+  if (status == 401) {
+    // The user is not logged in. They've cleared their cookies or logged out
+    // from another window.
+    this.logger_.info('Module loading unauthorized');
+    this.dispatchModuleLoadFailed_(
+        goog.module.ModuleManager.FailureType.UNAUTHORIZED);
+    // Drop any additional module requests.
+    this.requestedModuleIdsQueue_.length = 0;
+  } else if (status == 410) {
+    // The requested module js is old and not available.
+    this.requeueBatchOrDispatchFailure_(
+        goog.module.ModuleManager.FailureType.OLD_CODE_GONE);
+    this.loadNextModules_();
+  } else if (this.consecutiveFailures_ >= 3) {
+    this.logger_.info('Aborting after failure to load: ' +
+                      this.loadingModuleIds_);
+    this.requeueBatchOrDispatchFailure_(
+        goog.module.ModuleManager.FailureType.CONSECUTIVE_FAILURES);
+    this.loadNextModules_();
+  } else {
+    this.logger_.info('Retrying after failure to load: ' +
+                      this.loadingModuleIds_);
+    var forceReload =
+        status == goog.module.ModuleManager.CORRUPT_RESPONSE_STATUS_CODE;
+    this.loadModules_(this.requestedLoadingModuleIds_, true, forceReload);
+  }
+};
+/**
+ * Handles a module load timeout.
+ * @private
+ */
+goog.module.ModuleManager.prototype.handleLoadTimeout_ = function() {
+  this.logger_.info('Aborting after timeout: ' + this.loadingModuleIds_);
+  this.requeueBatchOrDispatchFailure_(
+      goog.module.ModuleManager.FailureType.TIMEOUT);
+  this.loadNextModules_();
+};
+/**
+ * Requeues batch loads that had more than one requested module
+ * (i.e. modules that were not included as dependencies) as separate loads or
+ * if there was only one requested module, fails that module with the received
+ * cause.
+ * @param {goog.module.ModuleManager.FailureType} cause The reason for the
+ *     failure.
+ * @private
+ */
+goog.module.ModuleManager.prototype.requeueBatchOrDispatchFailure_ =
+    function(cause) {
+  // The load failed, so if there are more than one requested modules, then we
+  // need to retry each one as a separate load. Otherwise, if there is only one
+  // requested module, remove it and its dependencies from the queue.
+  if (this.requestedLoadingModuleIds_.length > 1) {
+    var queuedModules = goog.array.map(this.requestedLoadingModuleIds_,
+        function(id) {
+          return [id];
+        });
+    this.requestedModuleIdsQueue_ = queuedModules.concat(
+        this.requestedModuleIdsQueue_);
+  } else {
+    this.dispatchModuleLoadFailed_(cause);
+  }
+};
+/**
+ * Handles when a module load failed.
+ * @param {goog.module.ModuleManager.FailureType} cause The reason for the
+ *     failure.
+ * @private
+ */
+goog.module.ModuleManager.prototype.dispatchModuleLoadFailed_ = function(
+    cause) {
+  var failedIds = this.requestedLoadingModuleIds_;
+  this.loadingModuleIds_.length = 0;
+  // If any pending modules depend on the id that failed,
+  // they need to be removed from the queue.
+  var idsToCancel = [];
+  for (var i = 0; i < this.requestedModuleIdsQueue_.length; i++) {
+    var dependentModules = goog.array.filter(
+        this.requestedModuleIdsQueue_[i],
+        /**
+         * Returns true if the requestedId has dependencies on the modules that
+         * just failed to load.
+         * @param {string} requestedId The module to check for dependencies.
+         * @return {boolean} True if the module depends on failed modules.
+         */
+        function(requestedId) {
+          var requestedDeps = this.getNotYetLoadedTransitiveDepIds_(
+              requestedId);
+          return goog.array.some(failedIds, function(id) {
+            return goog.array.contains(requestedDeps, id);
+          });
+        }, this);
+    goog.array.extend(idsToCancel, dependentModules);
+  }
+  // Also insert the ids that failed to load as ids to cancel.
+  for (var i = 0; i < failedIds.length; i++) {
+    goog.array.insert(idsToCancel, failedIds[i]);
+  }
+  // Remove ids to cancel from the queues.
+  for (var i = 0; i < idsToCancel.length; i++) {
+    for (var j = 0; j < this.requestedModuleIdsQueue_.length; j++) {
+      goog.array.remove(this.requestedModuleIdsQueue_[j], idsToCancel[i]);
+    }
+    goog.array.remove(this.userInitiatedLoadingModuleIds_, idsToCancel[i]);
+  }
+  // Call the functions for error notification.
+  var errorCallbacks = this.callbackMap_[
+      goog.module.ModuleManager.CallbackType.ERROR];
+  if (errorCallbacks) {
+    for (var i = 0; i < errorCallbacks.length; i++) {
+      var callback = errorCallbacks[i];
+      for (var j = 0; j < idsToCancel.length; j++) {
+        callback(goog.module.ModuleManager.CallbackType.ERROR, idsToCancel[j],
+            cause);
+      }
+    }
+  }
+  // Call the errbacks on the module info.
+  for (var i = 0; i < failedIds.length; i++) {
+    if (this.moduleInfoMap_[failedIds[i]]) {
+      this.moduleInfoMap_[failedIds[i]].onError(cause);
+    }
+  }
+  // Clear the requested loading module ids.
+  this.requestedLoadingModuleIds_.length = 0;
+  this.dispatchActiveIdleChangeIfNeeded_();
+};
+/**
+ * Loads the next modules on the queue.
+ * @private
+ */
+goog.module.ModuleManager.prototype.loadNextModules_ = function() {
+  while (this.requestedModuleIdsQueue_.length) {
+    // Remove modules that are already loaded.
+    var nextIds = goog.array.filter(this.requestedModuleIdsQueue_.shift(),
+        /** @param {string} id The module id. */
+        function(id) {
+          return !this.getModuleInfo(id).isLoaded();
+        }, this);
+    if (nextIds.length > 0) {
+      this.loadModules_(nextIds);
+      return;
+    }
+  }
+  // Dispatch an active/idle change if needed.
+  this.dispatchActiveIdleChangeIfNeeded_();
+};
+/**
+ * The function to call if the module manager is in error.
+ * @param {goog.module.ModuleManager.CallbackType|Array.<goog.module.ModuleManager.CallbackType>} types
+ *  The callback type.
+ * @param {Function} fn The function to register as a callback.
+ */
+goog.module.ModuleManager.prototype.registerCallback = function(
+    types, fn) {
+  if (!goog.isArray(types)) {
+    types = [types];
+  }
+  for (var i = 0; i < types.length; i++) {
+    this.registerCallback_(types[i], fn);
+  }
+};
+/**
+ * Register a callback for the specified callback type.
+ * @param {goog.module.ModuleManager.CallbackType} type The callback type.
+ * @param {Function} fn The callback function.
+ * @private
+ */
+goog.module.ModuleManager.prototype.registerCallback_ = function(type, fn) {
+  var callbackMap = this.callbackMap_;
+  if (!callbackMap[type]) {
+    callbackMap[type] = [];
+  }
+  callbackMap[type].push(fn);
+};
+/**
+ * Call the callback functions of the specified type.
+ * @param {goog.module.ModuleManager.CallbackType} type The callback type.
+ * @private
+ */
+goog.module.ModuleManager.prototype.executeCallbacks_ = function(type) {
+  var callbacks = this.callbackMap_[type];
+  for (var i = 0; callbacks && i < callbacks.length; i++) {
+    callbacks[i](type);
+  }
+};
+/** @override */
+goog.module.ModuleManager.prototype.disposeInternal = function() {
+  goog.module.ModuleManager.superClass_.disposeInternal.call(this);
+  // Dispose of each ModuleInfo object.
+  goog.array.forEach(goog.object.getValues(this.moduleInfoMap_), goog.dispose);
+  this.moduleInfoMap_ = null;
+  this.loadingModuleIds_ = null;
+  this.requestedLoadingModuleIds_ = null;
+  this.userInitiatedLoadingModuleIds_ = null;
+  this.requestedModuleIdsQueue_ = null;
+  this.callbackMap_ = null;
+};