text: // Copyright 2010 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 global registry for entry points into a program,
   * so that they can be instrumented. Each module should register their
   * entry points with this registry. Designed to be compiled out
   * if no instrumentation is requested.
   *
   * Entry points may be registered before or after a call to
   * goog.debug.entryPointRegistry.monitorAll. If an entry point is registered
   * later, the existing monitor will instrument the new entry point.
   *
   * @author nicksantos@google.com (Nick Santos)
   */
  
  goog.provide('goog.debug.EntryPointMonitor');
  goog.provide('goog.debug.entryPointRegistry');
  
  goog.require('goog.asserts');
  
  
  
  /**
   * @interface
   */
  goog.debug.EntryPointMonitor = function() {};
  
  
  /**
   * Instruments a function.
   *
   * @param {!Function} fn A function to instrument.
   * @return {!Function} The instrumented function.
   */
  goog.debug.EntryPointMonitor.prototype.wrap;
  
  
  /**
   * Try to remove an instrumentation wrapper created by this monitor.
   * If the function passed to unwrap is not a wrapper created by this
   * monitor, then we will do nothing.
   *
   * Notice that some wrappers may not be unwrappable. For example, if other
   * monitors have applied their own wrappers, then it will be impossible to
   * unwrap them because their wrappers will have captured our wrapper.
   *
   * So it is important that entry points are unwrapped in the reverse
   * order that they were wrapped.
   *
   * @param {!Function} fn A function to unwrap.
   * @return {!Function} The unwrapped function, or {@code fn} if it was not
   *     a wrapped function created by this monitor.
   */
  goog.debug.EntryPointMonitor.prototype.unwrap;
  
  
  /**
   * An array of entry point callbacks.
   * @type {!Array.<function(!Function)>}
   * @private
   */
  goog.debug.entryPointRegistry.refList_ = [];
  
  
  /**
   * Monitors that should wrap all the entry points.
   * @type {!Array.<!goog.debug.EntryPointMonitor>}
   * @private
   */
  goog.debug.entryPointRegistry.monitors_ = [];
  
  
  /**
   * Whether goog.debug.entryPointRegistry.monitorAll has ever been called.
   * Checking this allows the compiler to optimize out the registrations.
   * @type {boolean}
   * @private
   */
  goog.debug.entryPointRegistry.monitorsMayExist_ = false;
  
  
  /**
   * Register an entry point with this module.
   *
   * The entry point will be instrumented when a monitor is passed to
   * goog.debug.entryPointRegistry.monitorAll. If this has already occurred, the
   * entry point is instrumented immediately.
   *
   * @param {function(!Function)} callback A callback function which is called
   *     with a transforming function to instrument the entry point. The callback
   *     is responsible for wrapping the relevant entry point with the
   *     transforming function.
   */
  goog.debug.entryPointRegistry.register = function(callback) {
    // Don't use push(), so that this can be compiled out.
    goog.debug.entryPointRegistry.refList_[
        goog.debug.entryPointRegistry.refList_.length] = callback;
    // If no one calls monitorAll, this can be compiled out.
    if (goog.debug.entryPointRegistry.monitorsMayExist_) {
      var monitors = goog.debug.entryPointRegistry.monitors_;
      for (var i = 0; i < monitors.length; i++) {
        callback(goog.bind(monitors[i].wrap, monitors[i]));
      }
    }
  };
  
  
  /**
   * Configures a monitor to wrap all entry points.
   *
   * Entry points that have already been registered are immediately wrapped by
   * the monitor. When an entry point is registered in the future, it will also
   * be wrapped by the monitor when it is registered.
   *
   * @param {!goog.debug.EntryPointMonitor} monitor An entry point monitor.
   */
  goog.debug.entryPointRegistry.monitorAll = function(monitor) {
    goog.debug.entryPointRegistry.monitorsMayExist_ = true;
    var transformer = goog.bind(monitor.wrap, monitor);
    for (var i = 0; i < goog.debug.entryPointRegistry.refList_.length; i++) {
      goog.debug.entryPointRegistry.refList_[i](transformer);
    }
    goog.debug.entryPointRegistry.monitors_.push(monitor);
  };
  
  
  /**
   * Try to unmonitor all the entry points that have already been registered. If
   * an entry point is registered in the future, it will not be wrapped by the
   * monitor when it is registered. Note that this may fail if the entry points
   * have additional wrapping.
   *
   * @param {!goog.debug.EntryPointMonitor} monitor The last monitor to wrap
   *     the entry points.
   * @throws {Error} If the monitor is not the most recently configured monitor.
   */
  goog.debug.entryPointRegistry.unmonitorAllIfPossible = function(monitor) {
    var monitors = goog.debug.entryPointRegistry.monitors_;
    goog.asserts.assert(monitor == monitors[monitors.length - 1],
        'Only the most recent monitor can be unwrapped.');
    var transformer = goog.bind(monitor.unwrap, monitor);
    for (var i = 0; i < goog.debug.entryPointRegistry.refList_.length; i++) {
      goog.debug.entryPointRegistry.refList_[i](transformer);
    }
    monitors.length--;
  };
  