_propertyDescriptor: function(name, onlyEnumerable) {
if (!DevToolsUtils.isSafeDebuggerObject(this.obj)) {
return undefined;
}
let desc;
try {
desc = this.obj.getOwnPropertyDescriptor(name);
} catch (e) {
// Calling getOwnPropertyDescriptor on wrapped native prototypes is not
// allowed (bug 560072). Inform the user with a bogus, but hopefully
// explanatory, descriptor.
return {
configurable: false,
writable: false,
enumerable: false,
value: e.name,
};
}
if (isStorage(this.obj)) {
if (name === "length") {
return undefined;
}
return desc;
}
if (!desc || onlyEnumerable && !desc.enumerable) {
return undefined;
}
const retval = {
configurable: desc.configurable,
enumerable: desc.enumerable,
};
if ("value" in desc) {
retval.writable = desc.writable;
retval.value = this.hooks.createValueGrip(desc.value);
} else {
if ("get" in desc) {
retval.get = this.hooks.createValueGrip(desc.get);
}
if ("set" in desc) {
retval.set = this.hooks.createValueGrip(desc.set);
}
}
return retval;
},
form: function() {
const g = {
"type": "object",
"actor": this.actorID,
"class": this.obj.class,
};
const unwrapped = DevToolsUtils.unwrap(this.obj);
// Unsafe objects must be treated carefully.
if (!DevToolsUtils.isSafeDebuggerObject(this.obj)) {
if (DevToolsUtils.isCPOW(this.obj)) {
// Cross-process object wrappers can't be accessed.
g.class = "CPOW: " + g.class;
} else if (unwrapped === undefined) {
// Objects belonging to an invisible-to-debugger compartment might be proxies,
// so just in case they shouldn't be accessed.
g.class = "InvisibleToDebugger: " + g.class;
} else if (unwrapped.isProxy) {
// Proxy objects can run traps when accessed, so just create a preview with
// the target and the handler.
g.class = "Proxy";
this.hooks.incrementGripDepth();
previewers.Proxy[0](this, g, null);
this.hooks.decrementGripDepth();
}
return g;
}
// If the debuggee does not subsume the object's compartment, most properties won't
// be accessible. Cross-orgin Window and Location objects might expose some, though.
// Change the displayed class, but when creating the preview use the original one.
if (unwrapped === null) {
g.class = "Restricted";
}
this.hooks.incrementGripDepth();
g.extensible = this.obj.isExtensible();
g.frozen = this.obj.isFrozen();
g.sealed = this.obj.isSealed();
if (g.class == "Promise") {
g.promiseState = this._createPromiseState();
}
// FF40+: Allow to know how many properties an object has to lazily display them
// when there is a bunch.
if (isTypedArray(g)) {
// Bug 1348761: getOwnPropertyNames is unnecessary slow on TypedArrays
g.ownPropertyLength = getArrayLength(this.obj);
} else if (isStorage(g)) {
g.ownPropertyLength = getStorageLength(this.obj);
} else if (isReplaying) {
// When replaying we can get the number of properties directly, to avoid
// needing to enumerate all of them.
g.ownPropertyLength = this.obj.getOwnPropertyNamesCount();
} else {
try {
g.ownPropertyLength = this.obj.getOwnPropertyNames().length;
} catch (err) {
// The above can throw when the debuggee does not subsume the object's
// compartment, or for some WrappedNatives like Cu.Sandbox.
}
}
let raw = this.obj.unsafeDereference();
// If Cu is not defined, we are running on a worker thread, where xrays
// don't exist. The raw object will be null/unavailable when interacting
// with a replaying execution.
if (raw && Cu) {
raw = Cu.unwaiveXrays(raw);
}
if (raw && !DevToolsUtils.isSafeJSObject(raw)) {
raw = null;
}
for (const fn of previewers[this.obj.class] || previewers.Object) {
try {
if (fn(this, g, raw)) {
break;
}
} catch (e) {
const msg = "ObjectActor.prototype.grip previewer function";
DevToolsUtils.reportException(msg, e);
}
}
this.hooks.decrementGripDepth();
return g;
},