Debugger: load debugger builtins as normal native JS.

src/debug/mirrors.js

 // Copyright 2006-2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
+
+(function(global, utils) {
 "use strict";
 
-// Handle id counters.
+// ----------------------------------------------------------------------------
+// Imports
+
+var GlobalArray = global.Array;
+var IsNaN = global.isNaN;
+var JSONStringify = global.JSON.stringify;
+var MathMin = global.Math.min;
+
+// ----------------------------------------------------------------------------
+
+// Mirror hierarchy:
+// - Mirror
+// - ValueMirror

[Jakob Kummerow, 2015/08/12 12:47:51]

nit: meaningful indentation got lost here

+// - UndefinedMirror
+// - NullMirror
+// - BooleanMirror
+// - NumberMirror
+// - StringMirror
+// - SymbolMirror
+// - ObjectMirror
+// - FunctionMirror
+// - UnresolvedFunctionMirror
+// - ArrayMirror
+// - DateMirror
+// - RegExpMirror
+// - ErrorMirror
+// - PromiseMirror
+// - MapMirror
+// - SetMirror
+// - IteratorMirror
+// - GeneratorMirror
+// - PropertyMirror
+// - InternalPropertyMirror
+// - FrameMirror
+// - ScriptMirror
+// - ScopeMirror
+
+// Type names of the different mirrors.
+var MirrorType = {
+  UNDEFINED_TYPE : 'undefined',
+  NULL_TYPE : 'null',
+  BOOLEAN_TYPE : 'boolean',
+  NUMBER_TYPE : 'number',
+  STRING_TYPE : 'string',
+  SYMBOL_TYPE : 'symbol',
+  OBJECT_TYPE : 'object',
+  FUNCTION_TYPE : 'function',
+  REGEXP_TYPE : 'regexp',
+  ERROR_TYPE : 'error',
+  PROPERTY_TYPE : 'property',
+  INTERNAL_PROPERTY_TYPE : 'internalProperty',
+  FRAME_TYPE : 'frame',
+  SCRIPT_TYPE : 'script',
+  CONTEXT_TYPE : 'context',
+  SCOPE_TYPE : 'scope',
+  PROMISE_TYPE : 'promise',
+  MAP_TYPE : 'map',
+  SET_TYPE : 'set',
+  ITERATOR_TYPE : 'iterator',
+  GENERATOR_TYPE : 'generator',
+}
+
+
+//Handle id counters.

[Jakob Kummerow, 2015/08/12 12:47:51]

nit: space after //

 var next_handle_ = 0;
 var next_transient_handle_ = -1;
 
 // Mirror cache.
 var mirror_cache_ = [];
 var mirror_cache_enabled_ = true;
 
 
+function MirrorCacheIsEmpty() {
+  return next_handle_ == 0 && mirror_cache_.length == 0;
+}
+
+
 function ToggleMirrorCache(value) {
   mirror_cache_enabled_ = value;
+  ClearMirrorCache();
+}
+
+
+function ClearMirrorCache(value) {
   next_handle_ = 0;
   mirror_cache_ = [];
 }
 
 
 // Wrapper to check whether an object is a Promise.  The call may not work
 // if promises are not enabled.
 // TODO(yangguo): remove try-catch once promises are enabled by default.
 function ObjectIsPromise(value) {
   try {
@@ skipping 17 matching lines @@
   var mirror;
 
   // Look for non transient mirrors in the mirror cache.
   if (!opt_transient && mirror_cache_enabled_) {
     for (var id in mirror_cache_) {
       mirror = mirror_cache_[id];
       if (mirror.value() === value) {
         return mirror;
       }
       // Special check for NaN as NaN == NaN is false.
-      if (mirror.isNumber() && isNaN(mirror.value()) &&
-          typeof value == 'number' && isNaN(value)) {
+      if (mirror.isNumber() && IsNaN(mirror.value()) &&
+          typeof value == 'number' && IsNaN(value)) {
         return mirror;
       }
     }
   }
 
   if (IS_UNDEFINED(value)) {
     mirror = new UndefinedMirror();
   } else if (IS_NULL(value)) {
     mirror = new NullMirror();
   } else if (IS_BOOLEAN(value)) {
@@ skipping 20 matching lines @@
     mirror = new MapMirror(value);
   } else if (IS_SET(value) || IS_WEAKSET(value)) {
     mirror = new SetMirror(value);
   } else if (IS_MAP_ITERATOR(value) || IS_SET_ITERATOR(value)) {
     mirror = new IteratorMirror(value);
   } else if (ObjectIsPromise(value)) {
     mirror = new PromiseMirror(value);
   } else if (IS_GENERATOR(value)) {
     mirror = new GeneratorMirror(value);
   } else {
-    mirror = new ObjectMirror(value, OBJECT_TYPE, opt_transient);
+    mirror = new ObjectMirror(value, MirrorType.OBJECT_TYPE, opt_transient);
   }
 
   if (mirror_cache_enabled_) mirror_cache_[mirror.handle()] = mirror;
   return mirror;
 }
 
 
 /**
  * Returns the mirror for a specified mirror handle.
  *
  * @param {number} handle the handle to find the mirror for
  * @returns {Mirror or undefiend} the mirror with the requested handle or
  *     undefined if no mirror with the requested handle was found
  */
 function LookupMirror(handle) {
-  if (!mirror_cache_enabled_) throw new Error("Mirror cache is disabled");
+  if (!mirror_cache_enabled_) {
+    throw MakeError(kDebugger, "Mirror cache is disabled");
+  }
   return mirror_cache_[handle];
 }
 
 
 /**
  * Returns the mirror for the undefined value.
  *
  * @returns {Mirror} the mirror reflects the undefined value
  */
 function GetUndefinedMirror() {
@@ skipping 15 matching lines @@
  * @param {function} superCtor Constructor function to inherit prototype from
  */
 function inherits(ctor, superCtor) {
   var tempCtor = function(){};
   tempCtor.prototype = superCtor.prototype;
   ctor.super_ = superCtor.prototype;
   ctor.prototype = new tempCtor();
   ctor.prototype.constructor = ctor;
 }
 
-
-// Type names of the different mirrors.
-var UNDEFINED_TYPE = 'undefined';
-var NULL_TYPE = 'null';
-var BOOLEAN_TYPE = 'boolean';
-var NUMBER_TYPE = 'number';
-var STRING_TYPE = 'string';
-var SYMBOL_TYPE = 'symbol';
-var OBJECT_TYPE = 'object';
-var FUNCTION_TYPE = 'function';
-var REGEXP_TYPE = 'regexp';
-var ERROR_TYPE = 'error';
-var PROPERTY_TYPE = 'property';
-var INTERNAL_PROPERTY_TYPE = 'internalProperty';
-var FRAME_TYPE = 'frame';
-var SCRIPT_TYPE = 'script';
-var CONTEXT_TYPE = 'context';
-var SCOPE_TYPE = 'scope';
-var PROMISE_TYPE = 'promise';
-var MAP_TYPE = 'map';
-var SET_TYPE = 'set';
-var ITERATOR_TYPE = 'iterator';
-var GENERATOR_TYPE = 'generator';
-
 // Maximum length when sending strings through the JSON protocol.
 var kMaxProtocolStringLength = 80;
 
 // Different kind of properties.
 var PropertyKind = {};
 PropertyKind.Named   = 1;
 PropertyKind.Indexed = 2;
 
 
 // A copy of the PropertyType enum from property-details.h
@@ skipping 15 matching lines @@
 // NOTE: these constants should be backward-compatible, so
 // add new ones to the end of this list.
 var ScopeType = { Global: 0,
                   Local: 1,
                   With: 2,
                   Closure: 3,
                   Catch: 4,
                   Block: 5,
                   Script: 6 };
 
-
-// Mirror hierarchy:
-//   - Mirror
-//     - ValueMirror
-//       - UndefinedMirror
-//       - NullMirror
-//       - NumberMirror
-//       - StringMirror
-//       - SymbolMirror
-//       - ObjectMirror
-//         - FunctionMirror
-//           - UnresolvedFunctionMirror
-//         - ArrayMirror
-//         - DateMirror
-//         - RegExpMirror
-//         - ErrorMirror
-//         - PromiseMirror
-//         - MapMirror
-//         - SetMirror
-//         - IteratorMirror
-//         - GeneratorMirror
-//     - PropertyMirror
-//     - InternalPropertyMirror
-//     - FrameMirror
-//     - ScriptMirror
-
-
 /**
  * Base class for all mirror objects.
  * @param {string} type The type of the mirror
  * @constructor
  */
 function Mirror(type) {
   this.type_ = type;
 }
 
 
@@ skipping 299 matching lines @@
   return this.value_;
 };
 
 
 /**
  * Mirror object for Undefined.
  * @constructor
  * @extends ValueMirror
  */
 function UndefinedMirror() {
-  %_CallFunction(this, UNDEFINED_TYPE, UNDEFINED, ValueMirror);
+  %_CallFunction(this, MirrorType.UNDEFINED_TYPE, UNDEFINED, ValueMirror);
 }
 inherits(UndefinedMirror, ValueMirror);
 
 
 UndefinedMirror.prototype.toText = function() {
   return 'undefined';
 };
 
 
 /**
  * Mirror object for null.
  * @constructor
  * @extends ValueMirror
  */
 function NullMirror() {
-  %_CallFunction(this, NULL_TYPE, null, ValueMirror);
+  %_CallFunction(this, MirrorType.NULL_TYPE, null, ValueMirror);
 }
 inherits(NullMirror, ValueMirror);
 
 
 NullMirror.prototype.toText = function() {
   return 'null';
 };
 
 
 /**
  * Mirror object for boolean values.
  * @param {boolean} value The boolean value reflected by this mirror
  * @constructor
  * @extends ValueMirror
  */
 function BooleanMirror(value) {
-  %_CallFunction(this, BOOLEAN_TYPE, value, ValueMirror);
+  %_CallFunction(this, MirrorType.BOOLEAN_TYPE, value, ValueMirror);
 }
 inherits(BooleanMirror, ValueMirror);
 
 
 BooleanMirror.prototype.toText = function() {
   return this.value_ ? 'true' : 'false';
 };
 
 
 /**
  * Mirror object for number values.
  * @param {number} value The number value reflected by this mirror
  * @constructor
  * @extends ValueMirror
  */
 function NumberMirror(value) {
-  %_CallFunction(this, NUMBER_TYPE, value, ValueMirror);
+  %_CallFunction(this, MirrorType.NUMBER_TYPE, value, ValueMirror);
 }
 inherits(NumberMirror, ValueMirror);
 
 
 NumberMirror.prototype.toText = function() {
   return %_NumberToString(this.value_);
 };
 
 
 /**
  * Mirror object for string values.
  * @param {string} value The string value reflected by this mirror
  * @constructor
  * @extends ValueMirror
  */
 function StringMirror(value) {
-  %_CallFunction(this, STRING_TYPE, value, ValueMirror);
+  %_CallFunction(this, MirrorType.STRING_TYPE, value, ValueMirror);
 }
 inherits(StringMirror, ValueMirror);
 
 
 StringMirror.prototype.length = function() {
   return this.value_.length;
 };
 
 StringMirror.prototype.getTruncatedValue = function(maxLength) {
   if (maxLength != -1 && this.length() > maxLength) {
     return this.value_.substring(0, maxLength) +
            '... (length: ' + this.length() + ')';
   }
   return this.value_;
 };
 
 StringMirror.prototype.toText = function() {
   return this.getTruncatedValue(kMaxProtocolStringLength);
 };
 
 
 /**
  * Mirror object for a Symbol
  * @param {Object} value The Symbol
  * @constructor
  * @extends Mirror
  */
 function SymbolMirror(value) {
-  %_CallFunction(this, SYMBOL_TYPE, value, ValueMirror);
+  %_CallFunction(this, MirrorType.SYMBOL_TYPE, value, ValueMirror);
 }
 inherits(SymbolMirror, ValueMirror);
 
 
 SymbolMirror.prototype.description = function() {
   return %SymbolDescription(%_ValueOf(this.value_));
 }
 
 
 SymbolMirror.prototype.toText = function() {
   return %_CallFunction(this.value_, builtins.$symbolToString);
 }
 
 
 /**
  * Mirror object for objects.
  * @param {object} value The object reflected by this mirror
  * @param {boolean} transient indicate whether this object is transient with a
  *    transient handle
  * @constructor
  * @extends ValueMirror
  */
 function ObjectMirror(value, type, transient) {
-  %_CallFunction(this, type || OBJECT_TYPE, value, transient, ValueMirror);
+  type = type || MirrorType.OBJECT_TYPE;
+  %_CallFunction(this, type, value, transient, ValueMirror);
 }
 inherits(ObjectMirror, ValueMirror);
 
 
 ObjectMirror.prototype.className = function() {
   return %_ClassOf(this.value_);
 };
 
 
 ObjectMirror.prototype.constructorFunction = function() {
@@ skipping 79 matching lines @@
     // Get names for indexed interceptor properties.
     if (this.hasIndexedInterceptor() && (kind & PropertyKind.Indexed)) {
       var indexedInterceptorNames =
           %GetIndexedInterceptorElementNames(this.value_);
       if (indexedInterceptorNames) {
         elementNames = elementNames.concat(indexedInterceptorNames);
         total += indexedInterceptorNames.length;
       }
     }
   }
-  limit = Math.min(limit || total, total);
+  limit = MathMin(limit || total, total);
 
-  var names = new Array(limit);
+  var names = new GlobalArray(limit);
   var index = 0;
 
   // Copy names for named properties.
   if (kind & PropertyKind.Named) {
     for (var i = 0; index < limit && i < propertyNames.length; i++) {
       names[index++] = propertyNames[i];
     }
   }
 
   // Copy names for indexed properties.
@@ skipping 10 matching lines @@
 /**
  * Return the properties for this object as an array of PropertyMirror objects.
  * @param {number} kind Indicate whether named, indexed or both kinds of
  *     properties are requested
  * @param {number} limit Limit the number of properties returned to the
        specified value
  * @return {Array} Property mirrors for this object
  */
 ObjectMirror.prototype.properties = function(kind, limit) {
   var names = this.propertyNames(kind, limit);
-  var properties = new Array(names.length);
+  var properties = new GlobalArray(names.length);
   for (var i = 0; i < names.length; i++) {
     properties[i] = this.property(names[i]);
   }
 
   return properties;
 };
 
 
 /**
  * Return the internal properties for this object as an array of
@@ skipping 96 matching lines @@
 }
 
 
 /**
  * Mirror object for functions.
  * @param {function} value The function object reflected by this mirror.
  * @constructor
  * @extends ObjectMirror
  */
 function FunctionMirror(value) {
-  %_CallFunction(this, value, FUNCTION_TYPE, ObjectMirror);
+  %_CallFunction(this, value, MirrorType.FUNCTION_TYPE, ObjectMirror);
   this.resolved_ = true;
 }
 inherits(FunctionMirror, ObjectMirror);
 
 
 /**
  * Returns whether the function is resolved.
  * @return {boolean} True if the function is resolved. Unresolved functions can
  *     only originate as functions from stack frames
  */
@@ skipping 133 matching lines @@
 /**
  * Mirror object for unresolved functions.
  * @param {string} value The name for the unresolved function reflected by this
  *     mirror.
  * @constructor
  * @extends ObjectMirror
  */
 function UnresolvedFunctionMirror(value) {
   // Construct this using the ValueMirror as an unresolved function is not a
   // real object but just a string.
-  %_CallFunction(this, FUNCTION_TYPE, value, ValueMirror);
+  %_CallFunction(this, MirrorType.FUNCTION_TYPE, value, ValueMirror);
   this.propertyCount_ = 0;
   this.elementCount_ = 0;
   this.resolved_ = false;
 }
 inherits(UnresolvedFunctionMirror, FunctionMirror);
 
 
 UnresolvedFunctionMirror.prototype.className = function() {
   return 'Function';
 };
@@ skipping 13 matching lines @@
   return GetUndefinedMirror();
 };
 
 
 UnresolvedFunctionMirror.prototype.name = function() {
   return this.value_;
 };
 
 
 UnresolvedFunctionMirror.prototype.inferredName = function() {
-  return undefined;
+  return UNDEFINED;
 };
 
 
 UnresolvedFunctionMirror.prototype.propertyNames = function(kind, limit) {
   return [];
 };
 
 
 /**
  * Mirror object for arrays.
  * @param {Array} value The Array object reflected by this mirror
  * @constructor
  * @extends ObjectMirror
  */
 function ArrayMirror(value) {
   %_CallFunction(this, value, ObjectMirror);
 }
 inherits(ArrayMirror, ObjectMirror);
 
 
 ArrayMirror.prototype.length = function() {
   return this.value_.length;
 };
 
 
 ArrayMirror.prototype.indexedPropertiesFromRange = function(opt_from_index,
                                                             opt_to_index) {
   var from_index = opt_from_index || 0;
   var to_index = opt_to_index || this.length() - 1;
-  if (from_index > to_index) return new Array();
-  var values = new Array(to_index - from_index + 1);
+  if (from_index > to_index) return new GlobalArray();
+  var values = new GlobalArray(to_index - from_index + 1);
   for (var i = from_index; i <= to_index; i++) {
     var details = %DebugGetPropertyDetails(this.value_, builtins.$toString(i));
     var value;
     if (details) {
       value = new PropertyMirror(this, i, details);
     } else {
       value = GetUndefinedMirror();
     }
     values[i - from_index] = value;
   }
   return values;
 };
 
 
 /**
  * Mirror object for dates.
  * @param {Date} value The Date object reflected by this mirror
  * @constructor
  * @extends ObjectMirror
  */
 function DateMirror(value) {
   %_CallFunction(this, value, ObjectMirror);
 }
 inherits(DateMirror, ObjectMirror);
 
 
 DateMirror.prototype.toText = function() {
-  var s = JSON.stringify(this.value_);
+  var s = JSONStringify(this.value_);
   return s.substring(1, s.length - 1);  // cut quotes
 };
 
 
 /**
  * Mirror object for regular expressions.
  * @param {RegExp} value The RegExp object reflected by this mirror
  * @constructor
  * @extends ObjectMirror
  */
 function RegExpMirror(value) {
-  %_CallFunction(this, value, REGEXP_TYPE, ObjectMirror);
+  %_CallFunction(this, value, MirrorType.REGEXP_TYPE, ObjectMirror);
 }
 inherits(RegExpMirror, ObjectMirror);
 
 
 /**
  * Returns the source to the regular expression.
  * @return {string or undefined} The source to the regular expression
  */
 RegExpMirror.prototype.source = function() {
   return this.value_.source;
@@ skipping 51 matching lines @@
 };
 
 
 /**
  * Mirror object for error objects.
  * @param {Error} value The error object reflected by this mirror
  * @constructor
  * @extends ObjectMirror
  */
 function ErrorMirror(value) {
-  %_CallFunction(this, value, ERROR_TYPE, ObjectMirror);
+  %_CallFunction(this, value, MirrorType.ERROR_TYPE, ObjectMirror);
 }
 inherits(ErrorMirror, ObjectMirror);
 
 
 /**
  * Returns the message for this eror object.
  * @return {string or undefined} The message for this eror object
  */
 ErrorMirror.prototype.message = function() {
   return this.value_.message;
@@ skipping 12 matching lines @@
 };
 
 
 /**
  * Mirror object for a Promise object.
  * @param {Object} value The Promise object
  * @constructor
  * @extends ObjectMirror
  */
 function PromiseMirror(value) {
-  %_CallFunction(this, value, PROMISE_TYPE, ObjectMirror);
+  %_CallFunction(this, value, MirrorType.PROMISE_TYPE, ObjectMirror);
 }
 inherits(PromiseMirror, ObjectMirror);
 
 
 function PromiseGetStatus_(value) {
   var status = %DebugGetProperty(value, builtins.$promiseStatus);
   if (status == 0) return "pending";
   if (status == 1) return "resolved";
   return "rejected";
 }
 
 
 function PromiseGetValue_(value) {
   return %DebugGetProperty(value, builtins.$promiseValue);
 }
 
 
 PromiseMirror.prototype.status = function() {
   return PromiseGetStatus_(this.value_);
 };
 
 
 PromiseMirror.prototype.promiseValue = function() {
   return MakeMirror(PromiseGetValue_(this.value_));
 };
 
 
 function MapMirror(value) {
-  %_CallFunction(this, value, MAP_TYPE, ObjectMirror);
+  %_CallFunction(this, value, MirrorType.MAP_TYPE, ObjectMirror);
 }
 inherits(MapMirror, ObjectMirror);
 
 
 /**
  * Returns an array of key/value pairs of a map.
  * This will keep keys alive for WeakMaps.
  *
  * @param {number=} opt_limit Max elements to return.
  * @returns {Array.<Object>} Array of key/value pairs of a map.
@@ skipping 19 matching lines @@
     result.push({
       key: next.value[0],
       value: next.value[1]
     });
   }
   return result;
 };
 
 
 function SetMirror(value) {
-  %_CallFunction(this, value, SET_TYPE, ObjectMirror);
+  %_CallFunction(this, value, MirrorType.SET_TYPE, ObjectMirror);
 }
 inherits(SetMirror, ObjectMirror);
 
 
 function IteratorGetValues_(iter, next_function, opt_limit) {
   var result = [];
   var next;
   while ((!opt_limit || result.length < opt_limit) &&
          !(next = %_CallFunction(iter, next_function)).done) {
     result.push(next.value);
@@ skipping 13 matching lines @@
   if (IS_WEAKSET(this.value_)) {
     return %GetWeakSetValues(this.value_, opt_limit || 0);
   }
 
   var iter = %_CallFunction(this.value_, builtins.$setValues);
   return IteratorGetValues_(iter, builtins.$setIteratorNext, opt_limit);
 };
 
 
 function IteratorMirror(value) {
-  %_CallFunction(this, value, ITERATOR_TYPE, ObjectMirror);
+  %_CallFunction(this, value, MirrorType.ITERATOR_TYPE, ObjectMirror);
 }
 inherits(IteratorMirror, ObjectMirror);
 
 
 /**
  * Returns a preview of elements of an iterator.
  * Does not change the backing iterator state.
  *
  * @param {number=} opt_limit Max elements to return.
  * @returns {Array.<Object>} Array of elements of an iterator.
@@ skipping 11 matching lines @@
 };
 
 
 /**
  * Mirror object for a Generator object.
  * @param {Object} data The Generator object
  * @constructor
  * @extends Mirror
  */
 function GeneratorMirror(value) {
-  %_CallFunction(this, value, GENERATOR_TYPE, ObjectMirror);
+  %_CallFunction(this, value, MirrorType.GENERATOR_TYPE, ObjectMirror);
 }
 inherits(GeneratorMirror, ObjectMirror);
 
 
 function GeneratorGetStatus_(value) {
   var continuation = %GeneratorGetContinuation(value);
   if (continuation < 0) return "running";
   if (continuation == 0) return "closed";
   return "suspended";
 }
@@ skipping 46 matching lines @@
 
 /**
  * Base mirror object for properties.
  * @param {ObjectMirror} mirror The mirror object having this property
  * @param {string} name The name of the property
  * @param {Array} details Details about the property
  * @constructor
  * @extends Mirror
  */
 function PropertyMirror(mirror, name, details) {
-  %_CallFunction(this, PROPERTY_TYPE, Mirror);
+  %_CallFunction(this, MirrorType.PROPERTY_TYPE, Mirror);
   this.mirror_ = mirror;
   this.name_ = name;
   this.value_ = details[0];
   this.details_ = details[1];
   this.is_interceptor_ = details[2];
   if (details.length > 3) {
     this.exception_ = details[3];
     this.getter_ = details[4];
     this.setter_ = details[5];
   }
@@ skipping 122 matching lines @@
 /**
  * Mirror object for internal properties. Internal property reflects properties
  * not accessible from user code such as [[BoundThis]] in bound function.
  * Their names are merely symbolic.
  * @param {string} name The name of the property
  * @param {value} property value
  * @constructor
  * @extends Mirror
  */
 function InternalPropertyMirror(name, value) {
-  %_CallFunction(this, INTERNAL_PROPERTY_TYPE, Mirror);
+  %_CallFunction(this, MirrorType.INTERNAL_PROPERTY_TYPE, Mirror);
   this.name_ = name;
   this.value_ = value;
 }
 inherits(InternalPropertyMirror, Mirror);
 
 
 InternalPropertyMirror.prototype.name = function() {
   return this.name_;
 };
 
@@ skipping 192 matching lines @@
 
 /**
  * Mirror object for stack frames.
  * @param {number} break_id The break id in the VM for which this frame is
        valid
  * @param {number} index The frame index (top frame is index 0)
  * @constructor
  * @extends Mirror
  */
 function FrameMirror(break_id, index) {
-  %_CallFunction(this, FRAME_TYPE, Mirror);
+  %_CallFunction(this, MirrorType.FRAME_TYPE, Mirror);
   this.break_id_ = break_id;
   this.index_ = index;
   this.details_ = new FrameDetails(break_id, index);
 }
 inherits(FrameMirror, Mirror);
 
 
 FrameMirror.prototype.details = function() {
   return this.details_;
 };
@@ skipping 178 matching lines @@
   return result;
 };
 
 
 FrameMirror.prototype.evaluate = function(source, disable_break,
                                           opt_context_object) {
   return MakeMirror(%DebugEvaluate(this.break_id_,
                                    this.details_.frameId(),
                                    this.details_.inlinedFrameIndex(),
                                    source,
-                                   Boolean(disable_break),
+                                   $toBoolean(disable_break),
                                    opt_context_object));
 };
 
 
 FrameMirror.prototype.invocationText = function() {
   // Format frame invoaction (receiver, function and arguments).
   var result = '';
   var func = this.func();
   var receiver = this.receiver();
   if (this.isConstructCall()) {
@@ skipping 154 matching lines @@
     this.details_ = opt_details ||
                     %GetScopeDetails(frame.break_id_,
                                      frame.details_.frameId(),
                                      frame.details_.inlinedFrameIndex(),
                                      index);
     this.frame_id_ = frame.details_.frameId();
     this.inlined_frame_id_ = frame.details_.inlinedFrameIndex();
   } else {
     this.details_ = opt_details || %GetFunctionScopeDetails(fun.value(), index);
     this.fun_value_ = fun.value();
-    this.break_id_ = undefined;
+    this.break_id_ = UNDEFINED;
   }
   this.index_ = index;
 }
 
 
 ScopeDetails.prototype.type = function() {
   if (!IS_UNDEFINED(this.break_id_)) {
     %CheckExecutionState(this.break_id_);
   }
   return this.details_[kScopeDetailsTypeIndex];
@@ skipping 11 matching lines @@
 ScopeDetails.prototype.setVariableValueImpl = function(name, new_value) {
   var raw_res;
   if (!IS_UNDEFINED(this.break_id_)) {
     %CheckExecutionState(this.break_id_);
     raw_res = %SetScopeVariableValue(this.break_id_, this.frame_id_,
         this.inlined_frame_id_, this.index_, name, new_value);
   } else {
     raw_res = %SetScopeVariableValue(this.fun_value_, null, null, this.index_,
         name, new_value);
   }
-  if (!raw_res) {
-    throw new Error("Failed to set variable value");
-  }
+  if (!raw_res) throw MakeError(kDebugger, "Failed to set variable value");
 };
 
 
 /**
  * Mirror object for scope of frame or function. Either frame or function must
  * be specified.
  * @param {FrameMirror} frame The frame this scope is a part of
  * @param {FunctionMirror} function The function this scope is a part of
  * @param {number} index The scope index in the frame
  * @param {Array=} opt_details Raw scope details data
  * @constructor
  * @extends Mirror
  */
-function ScopeMirror(frame, function, index, opt_details) {
-  %_CallFunction(this, SCOPE_TYPE, Mirror);
+function ScopeMirror(frame, fun, index, opt_details) {
+  %_CallFunction(this, MirrorType.SCOPE_TYPE, Mirror);
   if (frame) {
     this.frame_index_ = frame.index_;
   } else {
-    this.frame_index_ = undefined;
+    this.frame_index_ = UNDEFINED;
   }
   this.scope_index_ = index;
-  this.details_ = new ScopeDetails(frame, function, index, opt_details);
+  this.details_ = new ScopeDetails(frame, fun, index, opt_details);
 }
 inherits(ScopeMirror, Mirror);
 
 
 ScopeMirror.prototype.details = function() {
   return this.details_;
 };
 
 
 ScopeMirror.prototype.frameIndex = function() {
@@ skipping 27 matching lines @@
 };
 
 
 /**
  * Mirror object for script source.
  * @param {Script} script The script object
  * @constructor
  * @extends Mirror
  */
 function ScriptMirror(script) {
-  %_CallFunction(this, SCRIPT_TYPE, Mirror);
+  %_CallFunction(this, MirrorType.SCRIPT_TYPE, Mirror);
   this.script_ = script;
   this.context_ = new ContextMirror(script.context_data);
   this.allocateHandle_();
 }
 inherits(ScriptMirror, Mirror);
 
 
 ScriptMirror.prototype.value = function() {
   return this.script_;
 };
@@ skipping 100 matching lines @@
 };
 
 
 /**
  * Mirror object for context.
  * @param {Object} data The context data
  * @constructor
  * @extends Mirror
  */
 function ContextMirror(data) {
-  %_CallFunction(this, CONTEXT_TYPE, Mirror);
+  %_CallFunction(this, MirrorType.CONTEXT_TYPE, Mirror);
   this.data_ = data;
   this.allocateHandle_();
 }
 inherits(ContextMirror, Mirror);
 
 
 ContextMirror.prototype.data = function() {
   return this.data_;
 };
 
@@ skipping 109 matching lines @@
  * be used to display the value in debugger.
  * @param {Mirror} mirror Mirror to serialize.
  * @return {Object} Protocol reference object.
  */
 JSONProtocolSerializer.prototype.serializeReferenceWithDisplayData_ =
     function(mirror) {
   var o = {};
   o.ref = mirror.handle();
   o.type = mirror.type();
   switch (mirror.type()) {
-    case UNDEFINED_TYPE:
-    case NULL_TYPE:
-    case BOOLEAN_TYPE:
-    case NUMBER_TYPE:
+    case MirrorType.UNDEFINED_TYPE:
+    case MirrorType.NULL_TYPE:
+    case MirrorType.BOOLEAN_TYPE:
+    case MirrorType.NUMBER_TYPE:
       o.value = mirror.value();
       break;
-    case STRING_TYPE:
+    case MirrorType.STRING_TYPE:
       o.value = mirror.getTruncatedValue(this.maxStringLength_());
       break;
-    case SYMBOL_TYPE:
+    case MirrorType.SYMBOL_TYPE:
       o.description = mirror.description();
       break;
-    case FUNCTION_TYPE:
+    case MirrorType.FUNCTION_TYPE:
       o.name = mirror.name();
       o.inferredName = mirror.inferredName();
       if (mirror.script()) {
         o.scriptId = mirror.script().id();
       }
       break;
-    case ERROR_TYPE:
-    case REGEXP_TYPE:
+    case MirrorType.ERROR_TYPE:
+    case MirrorType.REGEXP_TYPE:
       o.value = mirror.toText();
       break;
-    case OBJECT_TYPE:
+    case MirrorType.OBJECT_TYPE:
       o.className = mirror.className();
       break;
   }
   return o;
 };
 
 
 JSONProtocolSerializer.prototype.serialize_ = function(mirror, reference,
                                                        details) {
   // If serializing a reference to a mirror just return the reference and add
@@ skipping 13 matching lines @@
 
   // Add the mirror handle.
   if (mirror.isValue() || mirror.isScript() || mirror.isContext()) {
     content.handle = mirror.handle();
   }
 
   // Always add the type.
   content.type = mirror.type();
 
   switch (mirror.type()) {
-    case UNDEFINED_TYPE:
-    case NULL_TYPE:
+    case MirrorType.UNDEFINED_TYPE:
+    case MirrorType.NULL_TYPE:
       // Undefined and null are represented just by their type.
       break;
 
-    case BOOLEAN_TYPE:
+    case MirrorType.BOOLEAN_TYPE:
       // Boolean values are simply represented by their value.
       content.value = mirror.value();
       break;
 
-    case NUMBER_TYPE:
+    case MirrorType.NUMBER_TYPE:
       // Number values are simply represented by their value.
       content.value = NumberToJSON_(mirror.value());
       break;
 
-    case STRING_TYPE:
+    case MirrorType.STRING_TYPE:
       // String values might have their value cropped to keep down size.
       if (this.maxStringLength_() != -1 &&
           mirror.length() > this.maxStringLength_()) {
         var str = mirror.getTruncatedValue(this.maxStringLength_());
         content.value = str;
         content.fromIndex = 0;
         content.toIndex = this.maxStringLength_();
       } else {
         content.value = mirror.value();
       }
       content.length = mirror.length();
       break;
 
-    case SYMBOL_TYPE:
+    case MirrorType.SYMBOL_TYPE:
       content.description = mirror.description();
       break;
 
-    case OBJECT_TYPE:
-    case FUNCTION_TYPE:
-    case ERROR_TYPE:
-    case REGEXP_TYPE:
-    case PROMISE_TYPE:
-    case GENERATOR_TYPE:
+    case MirrorType.OBJECT_TYPE:
+    case MirrorType.FUNCTION_TYPE:
+    case MirrorType.ERROR_TYPE:
+    case MirrorType.REGEXP_TYPE:
+    case MirrorType.PROMISE_TYPE:
+    case MirrorType.GENERATOR_TYPE:
       // Add object representation.
       this.serializeObject_(mirror, content, details);
       break;
 
-    case PROPERTY_TYPE:
-    case INTERNAL_PROPERTY_TYPE:
-      throw new Error('PropertyMirror cannot be serialized independently');
+    case MirrorType.PROPERTY_TYPE:
+    case MirrorType.INTERNAL_PROPERTY_TYPE:
+      throw MakeError(kDebugger,
+                     'PropertyMirror cannot be serialized independently');
       break;
 
-    case FRAME_TYPE:
+    case MirrorType.FRAME_TYPE:
       // Add object representation.
       this.serializeFrame_(mirror, content);
       break;
 
-    case SCOPE_TYPE:
+    case MirrorType.SCOPE_TYPE:
       // Add object representation.
       this.serializeScope_(mirror, content);
       break;
 
-    case SCRIPT_TYPE:
+    case MirrorType.SCRIPT_TYPE:
       // Script is represented by id, name and source attributes.
       if (mirror.name()) {
         content.name = mirror.name();
       }
       content.id = mirror.id();
       content.lineOffset = mirror.lineOffset();
       content.columnOffset = mirror.columnOffset();
       content.lineCount = mirror.lineCount();
       if (mirror.data()) {
         content.data = mirror.data();
@@ skipping 20 matching lines @@
         }
         if (mirror.evalFromFunctionName()) {
           content.evalFromFunctionName = mirror.evalFromFunctionName();
         }
       }
       if (mirror.context()) {
         content.context = this.serializeReference(mirror.context());
       }
       break;
 
-    case CONTEXT_TYPE:
+    case MirrorType.CONTEXT_TYPE:
       content.data = mirror.data();
       break;
   }
 
   // Always add the text representation.
   content.text = mirror.toText();
 
   // Create and return the JSON string.
   return content;
 };
@@ skipping 77 matching lines @@
 
   if (mirror.isPromise()) {
     // Add promise specific properties.
     content.status = mirror.status();
     content.promiseValue = this.serializeReference(mirror.promiseValue());
   }
 
   // Add actual properties - named properties followed by indexed properties.
   var propertyNames = mirror.propertyNames(PropertyKind.Named);
   var propertyIndexes = mirror.propertyNames(PropertyKind.Indexed);
-  var p = new Array(propertyNames.length + propertyIndexes.length);
+  var p = new GlobalArray(propertyNames.length + propertyIndexes.length);
   for (var i = 0; i < propertyNames.length; i++) {
     var propertyMirror = mirror.property(propertyNames[i]);
     p[i] = this.serializeProperty_(propertyMirror);
     if (details) {
       this.add_(propertyMirror.value());
     }
   }
   for (var i = 0; i < propertyIndexes.length; i++) {
     var propertyMirror = mirror.property(propertyIndexes[i]);
     p[propertyNames.length + i] = this.serializeProperty_(propertyMirror);
@@ skipping 110 matching lines @@
   var script = func.script();
   if (script) {
     content.script = this.serializeReference(script);
   }
   content.constructCall = mirror.isConstructCall();
   content.atReturn = mirror.isAtReturn();
   if (mirror.isAtReturn()) {
     content.returnValue = this.serializeReference(mirror.returnValue());
   }
   content.debuggerFrame = mirror.isDebuggerFrame();
-  var x = new Array(mirror.argumentCount());
+  var x = new GlobalArray(mirror.argumentCount());
   for (var i = 0; i < mirror.argumentCount(); i++) {
     var arg = {};
     var argument_name = mirror.argumentName(i);
     if (argument_name) {
       arg.name = argument_name;
     }
     arg.value = this.serializeReference(mirror.argumentValue(i));
     x[i] = arg;
   }
   content.arguments = x;
-  var x = new Array(mirror.localCount());
+  var x = new GlobalArray(mirror.localCount());
   for (var i = 0; i < mirror.localCount(); i++) {
     var local = {};
     local.name = mirror.localName(i);
     local.value = this.serializeReference(mirror.localValue(i));
     x[i] = local;
   }
   content.locals = x;
   serializeLocationFields(mirror.sourceLocation(), content);
   var source_line_text = mirror.sourceLineText();
   if (!IS_UNDEFINED(source_line_text)) {
@@ skipping 24 matching lines @@
 /**
  * Convert a number to a protocol value. For all finite numbers the number
  * itself is returned. For non finite numbers NaN, Infinite and
  * -Infinite the string representation "NaN", "Infinite" or "-Infinite"
  * (not including the quotes) is returned.
  *
  * @param {number} value The number value to convert to a protocol value.
  * @returns {number|string} Protocol value.
  */
 function NumberToJSON_(value) {
-  if (isNaN(value)) {
+  if (IsNaN(value)) {
     return 'NaN';
   }
   if (!NUMBER_IS_FINITE(value)) {
     if (value > 0) {
       return 'Infinity';
     } else {
       return '-Infinity';
     }
   }
   return value;
 }
+
+// ----------------------------------------------------------------------------
+// Exports
+
+%AddNamedProperty(global, "MakeMirror", MakeMirror, DONT_ENUM);

[Jakob Kummerow, 2015/08/12 12:47:51]

is there a specific reason to use %AddNamedProperty() rather than
utils.InstallFunctions() ?

+%AddNamedProperty(global, "MakeMirrorSerializer", MakeMirrorSerializer,
+                  DONT_ENUM);
+%AddNamedProperty(global, "LookupMirror", LookupMirror, DONT_ENUM);
+%AddNamedProperty(global, "ToggleMirrorCache", ToggleMirrorCache, DONT_ENUM);
+%AddNamedProperty(global, "MirrorCacheIsEmpty", MirrorCacheIsEmpty, DONT_ENUM);
+
+%AddNamedProperty(global, "Mirror", Mirror, DONT_ENUM);
+%AddNamedProperty(global, "ValueMirror", ValueMirror, DONT_ENUM);
+%AddNamedProperty(global, "UndefinedMirror", UndefinedMirror, DONT_ENUM);
+%AddNamedProperty(global, "NullMirror", NullMirror, DONT_ENUM);
+%AddNamedProperty(global, "BooleanMirror", BooleanMirror, DONT_ENUM);
+%AddNamedProperty(global, "NumberMirror", NumberMirror, DONT_ENUM);
+%AddNamedProperty(global, "StringMirror", StringMirror, DONT_ENUM);
+%AddNamedProperty(global, "SymbolMirror", SymbolMirror, DONT_ENUM);
+%AddNamedProperty(global, "ObjectMirror", ObjectMirror, DONT_ENUM);
+%AddNamedProperty(global, "FunctionMirror", FunctionMirror, DONT_ENUM);
+%AddNamedProperty(global, "UnresolvedFunctionMirror", UnresolvedFunctionMirror,
+                  DONT_ENUM);
+%AddNamedProperty(global, "ArrayMirror", ArrayMirror, DONT_ENUM);
+%AddNamedProperty(global, "DateMirror", DateMirror, DONT_ENUM);
+%AddNamedProperty(global, "RegExpMirror", RegExpMirror, DONT_ENUM);
+%AddNamedProperty(global, "ErrorMirror", ErrorMirror, DONT_ENUM);
+%AddNamedProperty(global, "PromiseMirror", PromiseMirror, DONT_ENUM);
+%AddNamedProperty(global, "MapMirror", MapMirror, DONT_ENUM);
+%AddNamedProperty(global, "SetMirror", SetMirror, DONT_ENUM);
+%AddNamedProperty(global, "IteratorMirror", IteratorMirror, DONT_ENUM);
+%AddNamedProperty(global, "GeneratorMirror", GeneratorMirror, DONT_ENUM);
+%AddNamedProperty(global, "PropertyMirror", PropertyMirror, DONT_ENUM);
+%AddNamedProperty(global, "InternalPropertyMirror", InternalPropertyMirror,
+                  DONT_ENUM);
+%AddNamedProperty(global, "FrameMirror", FrameMirror, DONT_ENUM);
+%AddNamedProperty(global, "ScriptMirror", ScriptMirror, DONT_ENUM);
+%AddNamedProperty(global, "ScopeMirror", ScopeMirror, DONT_ENUM);
+%AddNamedProperty(global, "FrameDetails", FrameDetails, DONT_ENUM);
+
+%AddNamedProperty(global, "ScopeType", ScopeType, DONT_ENUM);
+%AddNamedProperty(global, "PropertyKind", PropertyKind, DONT_ENUM);
+%AddNamedProperty(global, "PropertyType", PropertyType, DONT_ENUM);
+%AddNamedProperty(global, "PropertyAttribute", PropertyAttribute, DONT_ENUM);
+
+// Functions needed by the debugger runtime.
+%AddNamedProperty(utils, "ClearMirrorCache", ClearMirrorCache, DONT_ENUM);
+
+// Export to debug.js
+utils.Export(function(to) {
+  to.MirrorType = MirrorType;
+});
+})