goog.debug.ErrorHandler

Invokes a callback function when this object is disposed. Callbacks are invoked in the order in which they were added. If a callback is added to an already disposed Disposable, it will be called immediately.

Install an unhandledrejection event listener that reports rejected promises. Note: this will only work with Chrome 49+ and friends, but so far is the only way to report uncaught errors in aysnc/await functions.

Disposes of the object and its resources.

Performs appropriate cleanup. See description of goog.disposable.IDisposable for examples. Classes that extend goog.Disposable should override this method. Not reentrant. To avoid calling it twice, it must only be called from the subclass' disposeInternal method. Everywhere else the public dispose method must be used. For example:

 mypackage.MyClass = function() {
 mypackage.MyClass.base(this, 'constructor');
     // Constructor logic specific to MyClass.
     ...
   };
   goog.inherits(mypackage.MyClass, goog.Disposable);

   mypackage.MyClass.prototype.disposeInternal = function() {
     // Dispose logic specific to MyClass.
     ...
     // Call superclass's disposeInternal at the end of the subclass's, like
     // in C++, to avoid hard-to-catch issues.
     mypackage.MyClass.base(this, 'disposeInternal');
   };
 

Helps #protectEntryPoint by actually creating the protected wrapper function, after #protectEntryPoint determines that one does not already exist for the given function. Can be overridden by subclasses that may want to implement different error handling, or add additional entry point hooks.

Installs exception protection for an entry point function. When an exception is thrown from a protected function, a handler will be invoked to handle it.

Install exception protection for window.requestAnimationFrame to handle exceptions.

Install exception protection for window.setInterval to handle exceptions.

Installs exception protection for window.setTimeout to handle exceptions.

Associates a disposable object with this object so that they will be disposed together.

Set whether to add a prefix to all error messages that occur in protected functions.

Set whether to wrap errors that occur in protected functions in a goog.debug.ErrorHandler.ProtectedFunctionError.

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.

Instruments a function.

If monitoring the goog.Disposable instances is enabled, stores the creation stack trace of the Disposable instance.