AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

Revert "This patch implements optimized objectInfo structure which manages the set of observers associated with an object and the changeRecord types which they accept."

Browse Source 
This reverts r16343 due to mjsunit object-observe failures on several bots:
  - V8 Linux nosse2
  - V8 GC stress 2

TBR=rossberg

Review URL: https://codereview.chromium.org/23491002

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@16344 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
This commit is contained in:
adamk@chromium.org 2013-08-26 22:45:10 +00:00
parent bf42ded40d
commit 432faaefb7
2 changed files with 163 additions and 261 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

432
src/object-observe.js
View File

@ -27,41 +27,12 @@
"use strict"; "use strict";
// Overview:
//
// This file contains all of the routing and accounting for Object.observe.
// User code will interact with these mechanisms via the Object.observe APIs
// and, as a side effect of mutation objects which are observed. The V8 runtime
// (both C++ and JS) will interact with these mechanisms primarily by enqueuing
// proper change records for objects which were mutated. The Object.observe
// routing and accounting consists primarily of three participants
//
// 1) ObjectInfo. This represents the observed state of a given object. It
// records what callbacks are observing the object, with what options, and
// what "change types" are in progress on the object (i.e. via
// notifier.performChange).
//
// 2) CallbackInfo. This represents a callback used for observation. It holds
// the records which must be delivered to the callback, as well as the global
// priority of the callback (which determines delivery order between
// callbacks).
//
// 3) observationState.pendingObservers. This is the set of observers which
// have change records which must be delivered. During "normal" delivery
// (i.e. not Object.deliverChangeRecords), this is the mechanism by which
// callbacks are invoked in the proper order until there are no more
// change records pending to a callback.
//
// Note that in order to reduce allocation and processing costs, the
// implementation of (1) and (2) have "optimized" states which represent
// common cases which can be handled more efficiently.
var observationState = %GetObservationState(); var observationState = %GetObservationState();
if (IS_UNDEFINED(observationState.callbackInfoMap)) { if (IS_UNDEFINED(observationState.callbackInfoMap)) {
observationState.callbackInfoMap = %ObservationWeakMapCreate(); observationState.callbackInfoMap = %ObservationWeakMapCreate();
observationState.objectInfoMap = %ObservationWeakMapCreate(); observationState.objectInfoMap = %ObservationWeakMapCreate();
observationState.notifierObjectInfoMap = %ObservationWeakMapCreate(); observationState.notifierTargetMap = %ObservationWeakMapCreate();
observationState.pendingObservers = null; observationState.pendingObservers = new InternalArray;
observationState.nextCallbackPriority = 0; observationState.nextCallbackPriority = 0;
} }
@ -88,191 +59,126 @@ ObservationWeakMap.prototype = {
var callbackInfoMap = var callbackInfoMap =
new ObservationWeakMap(observationState.callbackInfoMap); new ObservationWeakMap(observationState.callbackInfoMap);
var objectInfoMap = new ObservationWeakMap(observationState.objectInfoMap); var objectInfoMap = new ObservationWeakMap(observationState.objectInfoMap);
var notifierObjectInfoMap = var notifierTargetMap =
new ObservationWeakMap(observationState.notifierObjectInfoMap); new ObservationWeakMap(observationState.notifierTargetMap);
function TypeMapCreate() { function CreateObjectInfo(object) {
return { __proto__: null }; var info = {
changeObservers: new InternalArray,
notifier: null,
inactiveObservers: new InternalArray,
performing: { __proto__: null },
performingCount: 0,
};
objectInfoMap.set(object, info);
return info;
} }
function TypeMapAddType(typeMap, type, ignoreDuplicate) { var defaultAcceptTypes = {
typeMap[type] = ignoreDuplicate ? 1 : (typeMap[type] || 0) + 1; __proto__: null,
} 'new': true,
'updated': true,
'deleted': true,
'prototype': true,
'reconfigured': true
};
function TypeMapRemoveType(typeMap, type) { function CreateObserver(callback, accept) {
typeMap[type]--; var observer = {
}
function TypeMapCreateFromList(typeList) {
var typeMap = TypeMapCreate();
for (var i = 0; i < typeList.length; i++) {
TypeMapAddType(typeMap, typeList[i], true);
}
return typeMap;
}
function TypeMapHasType(typeMap, type) {
return !!typeMap[type];
}
function TypeMapIsDisjointFrom(typeMap1, typeMap2) {
if (!typeMap1 || !typeMap2)
return true;
for (var type in typeMap1) {
if (TypeMapHasType(typeMap1, type) && TypeMapHasType(typeMap2, type))
return false;
}
return true;
}
var defaultAcceptTypes = TypeMapCreateFromList([
'new',
'updated',
'deleted',
'prototype',
'reconfigured'
]);
// An Observer is a registration to observe an object by a callback with
// a given set of accept types. If the set of accept types is the default
// set for Object.observe, the observer is represented as a direct reference
// to the callback. An observer never changes its accept types and thus never
// needs to "normalize".
function ObserverCreate(callback, acceptList) {
return IS_UNDEFINED(acceptList) ? callback : {
__proto__: null, __proto__: null,
callback: callback, callback: callback,
accept: TypeMapCreateFromList(acceptList) accept: defaultAcceptTypes
}; };
}
function ObserverGetCallback(observer) { if (IS_UNDEFINED(accept))
return IS_SPEC_FUNCTION(observer) ? observer : observer.callback; return observer;
}
function ObserverGetAcceptTypes(observer) { var acceptMap = { __proto__: null };
return IS_SPEC_FUNCTION(observer) ? defaultAcceptTypes : observer.accept; for (var i = 0; i < accept.length; i++)
acceptMap[accept[i]] = true;
observer.accept = acceptMap;
return observer;
} }
function ObserverIsActive(observer, objectInfo) { function ObserverIsActive(observer, objectInfo) {
return TypeMapIsDisjointFrom(ObjectInfoGetPerformingTypes(objectInfo), if (objectInfo.performingCount === 0)
ObserverGetAcceptTypes(observer)); return true;
}
function ObjectInfoGet(object) { var performing = objectInfo.performing;
var objectInfo = objectInfoMap.get(object); for (var type in performing) {
if (IS_UNDEFINED(objectInfo)) { if (performing[type] > 0 && observer.accept[type])
if (!%IsJSProxy(object))
%SetIsObserved(object);
objectInfo = {
object: object,
changeObservers: null,
notifier: null,
performing: null,
performingCount: 0,
};
objectInfoMap.set(object, objectInfo);
}
return objectInfo;
}
function ObjectInfoGetFromNotifier(notifier) {
return notifierObjectInfoMap.get(notifier);
}
function ObjectInfoGetNotifier(objectInfo) {
if (IS_NULL(objectInfo.notifier)) {
objectInfo.notifier = { __proto__: notifierPrototype };
notifierObjectInfoMap.set(objectInfo.notifier, objectInfo);
}
return objectInfo.notifier;
}
function ObjectInfoGetObject(objectInfo) {
return objectInfo.object;
}
function ChangeObserversIsOptimized(changeObservers) {
return typeof changeObservers === 'function' ||
typeof changeObservers.callback === 'function';
}
// The set of observers on an object is called 'changeObservers'. The first
// observer is referenced directly via objectInfo.changeObservers. When a second
// is added, changeObservers "normalizes" to become a mapping of callback
// priority -> observer and is then stored on objectInfo.changeObservers.
function ObjectInfoNormalizeChangeObservers(objectInfo) {
if (ChangeObserversIsOptimized(objectInfo.changeObservers)) {
var observer = objectInfo.changeObservers;
var callback = ObserverGetCallback(observer);
var callbackInfo = CallbackInfoGet(callback);
var priority = CallbackInfoGetPriority(callbackInfo);
objectInfo.changeObservers = { __proto__: null };
objectInfo.changeObservers[priority] = observer;
}
}
function ObjectInfoAddObserver(objectInfo, callback, acceptList) {
var callbackInfo = CallbackInfoGetOrCreate(callback);
var observer = ObserverCreate(callback, acceptList);
if (!objectInfo.changeObservers) {
objectInfo.changeObservers = observer;
return;
}
ObjectInfoNormalizeChangeObservers(objectInfo);
var priority = CallbackInfoGetPriority(callbackInfo);
objectInfo.changeObservers[priority] = observer;
}
function ObjectInfoRemoveObserver(objectInfo, callback) {
if (!objectInfo.changeObservers)
return;
if (ChangeObserversIsOptimized(objectInfo.changeObservers)) {
if (callback === ObserverGetCallback(objectInfo.changeObservers))
objectInfo.changeObservers = null;
return;
}
var callbackInfo = CallbackInfoGet(callback);
var priority = CallbackInfoGetPriority(callbackInfo);
delete objectInfo.changeObservers[priority];
}
function ObjectInfoHasActiveObservers(objectInfo) {
if (IS_UNDEFINED(objectInfo) || !objectInfo.changeObservers)
return false; return false;
}
if (ChangeObserversIsOptimized(objectInfo.changeObservers)) return true;
return ObserverIsActive(objectInfo.changeObservers, objectInfo); }
for (var priority in objectInfo.changeObservers) { function ObserverIsInactive(observer, objectInfo) {
if (ObserverIsActive(objectInfo.changeObservers[priority], objectInfo)) return !ObserverIsActive(observer, objectInfo);
}
function RemoveNullElements(from) {
var i = 0;
var j = 0;
for (; i < from.length; i++) {
if (from[i] === null)
continue;
if (j < i)
from[j] = from[i];
j++;
}
if (i !== j)
from.length = from.length - (i - j);
}
function RepartitionObservers(conditionFn, from, to, objectInfo) {
var anyRemoved = false;
for (var i = 0; i < from.length; i++) {
var observer = from[i];
if (conditionFn(observer, objectInfo)) {
anyRemoved = true;
from[i] = null;
to.push(observer);
}
}
if (anyRemoved)
RemoveNullElements(from);
}
function BeginPerformChange(objectInfo, type) {
objectInfo.performing[type] = (objectInfo.performing[type] || 0) + 1;
objectInfo.performingCount++;
RepartitionObservers(ObserverIsInactive,
objectInfo.changeObservers,
objectInfo.inactiveObservers,
objectInfo);
}
function EndPerformChange(objectInfo, type) {
objectInfo.performing[type]--;
objectInfo.performingCount--;
RepartitionObservers(ObserverIsActive,
objectInfo.inactiveObservers,
objectInfo.changeObservers,
objectInfo);
}
function EnsureObserverRemoved(objectInfo, callback) {
function remove(observerList) {
for (var i = 0; i < observerList.length; i++) {
if (observerList[i].callback === callback) {
observerList.splice(i, 1);
return true; return true;
} }
}
return false; return false;
} }
function ObjectInfoAddPerformingType(objectInfo, type) { if (!remove(objectInfo.changeObservers))
objectInfo.performing = objectInfo.performing || TypeMapCreate(); remove(objectInfo.inactiveObservers);
TypeMapAddType(objectInfo.performing, type);
objectInfo.performingCount++;
}
function ObjectInfoRemovePerformingType(objectInfo, type) {
objectInfo.performingCount--;
TypeMapRemoveType(objectInfo.performing, type);
}
function ObjectInfoGetPerformingTypes(objectInfo) {
return objectInfo.performingCount > 0 ? objectInfo.performing : null;
} }
function AcceptArgIsValid(arg) { function AcceptArgIsValid(arg) {
@ -292,31 +198,12 @@ function AcceptArgIsValid(arg) {
return true; return true;
} }
// CallbackInfo's optimized state is just a number which represents its global function EnsureCallbackPriority(callback) {
// priority. When a change record must be enqueued for the callback, it if (!callbackInfoMap.has(callback))
// normalizes. When delivery clears any pending change records, it re-optimizes. callbackInfoMap.set(callback, observationState.nextCallbackPriority++);
function CallbackInfoGet(callback) {
return callbackInfoMap.get(callback);
} }
function CallbackInfoGetOrCreate(callback) { function NormalizeCallbackInfo(callback) {
var callbackInfo = callbackInfoMap.get(callback);
if (!IS_UNDEFINED(callbackInfo))
return callbackInfo;
var priority = observationState.nextCallbackPriority++
callbackInfoMap.set(callback, priority);
return priority;
}
function CallbackInfoGetPriority(callbackInfo) {
if (IS_NUMBER(callbackInfo))
return callbackInfo;
else
return callbackInfo.priority;
}
function CallbackInfoNormalize(callback) {
var callbackInfo = callbackInfoMap.get(callback); var callbackInfo = callbackInfoMap.get(callback);
if (IS_NUMBER(callbackInfo)) { if (IS_NUMBER(callbackInfo)) {
var priority = callbackInfo; var priority = callbackInfo;
@ -327,18 +214,32 @@ function CallbackInfoNormalize(callback) {
return callbackInfo; return callbackInfo;
} }
function ObjectObserve(object, callback, acceptList) { function ObjectObserve(object, callback, accept) {
if (!IS_SPEC_OBJECT(object)) if (!IS_SPEC_OBJECT(object))
throw MakeTypeError("observe_non_object", ["observe"]); throw MakeTypeError("observe_non_object", ["observe"]);
if (!IS_SPEC_FUNCTION(callback)) if (!IS_SPEC_FUNCTION(callback))
throw MakeTypeError("observe_non_function", ["observe"]); throw MakeTypeError("observe_non_function", ["observe"]);
if (ObjectIsFrozen(callback)) if (ObjectIsFrozen(callback))
throw MakeTypeError("observe_callback_frozen"); throw MakeTypeError("observe_callback_frozen");
if (!AcceptArgIsValid(acceptList)) if (!AcceptArgIsValid(accept))
throw MakeTypeError("observe_accept_invalid"); throw MakeTypeError("observe_accept_invalid");
var objectInfo = ObjectInfoGet(object); EnsureCallbackPriority(callback);
ObjectInfoAddObserver(objectInfo, callback, acceptList);
var objectInfo = objectInfoMap.get(object);
if (IS_UNDEFINED(objectInfo)) {
objectInfo = CreateObjectInfo(object);
%SetIsObserved(object);
}
EnsureObserverRemoved(objectInfo, callback);
var observer = CreateObserver(callback, accept);
if (ObserverIsActive(observer, objectInfo))
objectInfo.changeObservers.push(observer);
else
objectInfo.inactiveObservers.push(observer);
return object; return object;
} }
@ -352,7 +253,7 @@ function ObjectUnobserve(object, callback) {
if (IS_UNDEFINED(objectInfo)) if (IS_UNDEFINED(objectInfo))
return object; return object;
ObjectInfoRemoveObserver(objectInfo, callback); EnsureObserverRemoved(objectInfo, callback);
return object; return object;
} }
@ -367,52 +268,41 @@ function ArrayUnobserve(object, callback) {
return ObjectUnobserve(object, callback); return ObjectUnobserve(object, callback);
} }
function ObserverEnqueueIfActive(observer, objectInfo, changeRecord) { function EnqueueToCallback(callback, changeRecord) {
if (!ObserverIsActive(observer, objectInfo) || var callbackInfo = NormalizeCallbackInfo(callback);
!TypeMapHasType(ObserverGetAcceptTypes(observer), changeRecord.type)) {
return;
}
var callback = ObserverGetCallback(observer);
var callbackInfo = CallbackInfoNormalize(callback);
if (!observationState.pendingObservers)
observationState.pendingObservers = { __proto__: null };
observationState.pendingObservers[callbackInfo.priority] = callback; observationState.pendingObservers[callbackInfo.priority] = callback;
callbackInfo.push(changeRecord); callbackInfo.push(changeRecord);
%SetObserverDeliveryPending(); %SetObserverDeliveryPending();
} }
function ObjectInfoEnqueueChangeRecord(objectInfo, changeRecord) { function EnqueueChangeRecord(changeRecord, observers) {
// TODO(rossberg): adjust once there is a story for symbols vs proxies. // TODO(rossberg): adjust once there is a story for symbols vs proxies.
if (IS_SYMBOL(changeRecord.name)) return; if (IS_SYMBOL(changeRecord.name)) return;
if (ChangeObserversIsOptimized(objectInfo.changeObservers)) { for (var i = 0; i < observers.length; i++) {
var observer = objectInfo.changeObservers; var observer = observers[i];
ObserverEnqueueIfActive(observer, objectInfo, changeRecord); if (IS_UNDEFINED(observer.accept[changeRecord.type]))
return; continue;
}
for (var priority in objectInfo.changeObservers) { EnqueueToCallback(observer.callback, changeRecord);
var observer = objectInfo.changeObservers[priority];
ObserverEnqueueIfActive(observer, objectInfo, changeRecord);
} }
} }
function BeginPerformSplice(array) { function BeginPerformSplice(array) {
var objectInfo = objectInfoMap.get(array); var objectInfo = objectInfoMap.get(array);
if (!IS_UNDEFINED(objectInfo)) if (!IS_UNDEFINED(objectInfo))
ObjectInfoAddPerformingType(objectInfo, 'splice'); BeginPerformChange(objectInfo, 'splice');
} }
function EndPerformSplice(array) { function EndPerformSplice(array) {
var objectInfo = objectInfoMap.get(array); var objectInfo = objectInfoMap.get(array);
if (!IS_UNDEFINED(objectInfo)) if (!IS_UNDEFINED(objectInfo))
ObjectInfoRemovePerformingType(objectInfo, 'splice'); EndPerformChange(objectInfo, 'splice');
} }
function EnqueueSpliceRecord(array, index, removed, addedCount) { function EnqueueSpliceRecord(array, index, removed, addedCount) {
var objectInfo = objectInfoMap.get(array); var objectInfo = objectInfoMap.get(array);
if (!ObjectInfoHasActiveObservers(objectInfo)) if (IS_UNDEFINED(objectInfo) || objectInfo.changeObservers.length === 0)
return; return;
var changeRecord = { var changeRecord = {
@ -425,19 +315,19 @@ function EnqueueSpliceRecord(array, index, removed, addedCount) {
ObjectFreeze(changeRecord); ObjectFreeze(changeRecord);
ObjectFreeze(changeRecord.removed); ObjectFreeze(changeRecord.removed);
ObjectInfoEnqueueChangeRecord(objectInfo, changeRecord); EnqueueChangeRecord(changeRecord, objectInfo.changeObservers);
} }
function NotifyChange(type, object, name, oldValue) { function NotifyChange(type, object, name, oldValue) {
var objectInfo = objectInfoMap.get(object); var objectInfo = objectInfoMap.get(object);
if (!ObjectInfoHasActiveObservers(objectInfo)) if (objectInfo.changeObservers.length === 0)
return; return;
var changeRecord = (arguments.length < 4) ? var changeRecord = (arguments.length < 4) ?
{ type: type, object: object, name: name } : { type: type, object: object, name: name } :
{ type: type, object: object, name: name, oldValue: oldValue }; { type: type, object: object, name: name, oldValue: oldValue };
ObjectFreeze(changeRecord); ObjectFreeze(changeRecord);
ObjectInfoEnqueueChangeRecord(objectInfo, changeRecord); EnqueueChangeRecord(changeRecord, objectInfo.changeObservers);
} }
var notifierPrototype = {}; var notifierPrototype = {};
@ -446,16 +336,17 @@ function ObjectNotifierNotify(changeRecord) {
if (!IS_SPEC_OBJECT(this)) if (!IS_SPEC_OBJECT(this))
throw MakeTypeError("called_on_non_object", ["notify"]); throw MakeTypeError("called_on_non_object", ["notify"]);
var objectInfo = ObjectInfoGetFromNotifier(this); var target = notifierTargetMap.get(this);
if (IS_UNDEFINED(objectInfo)) if (IS_UNDEFINED(target))
throw MakeTypeError("observe_notify_non_notifier"); throw MakeTypeError("observe_notify_non_notifier");
if (!IS_STRING(changeRecord.type)) if (!IS_STRING(changeRecord.type))
throw MakeTypeError("observe_type_non_string"); throw MakeTypeError("observe_type_non_string");
if (!ObjectInfoHasActiveObservers(objectInfo)) var objectInfo = objectInfoMap.get(target);
if (IS_UNDEFINED(objectInfo) || objectInfo.changeObservers.length === 0)
return; return;
var newRecord = { object: ObjectInfoGetObject(objectInfo) }; var newRecord = { object: target };
for (var prop in changeRecord) { for (var prop in changeRecord) {
if (prop === 'object') continue; if (prop === 'object') continue;
%DefineOrRedefineDataProperty(newRecord, prop, changeRecord[prop], %DefineOrRedefineDataProperty(newRecord, prop, changeRecord[prop],
@ -463,16 +354,15 @@ function ObjectNotifierNotify(changeRecord) {
} }
ObjectFreeze(newRecord); ObjectFreeze(newRecord);
ObjectInfoEnqueueChangeRecord(objectInfo, newRecord); EnqueueChangeRecord(newRecord, objectInfo.changeObservers);
} }
function ObjectNotifierPerformChange(changeType, changeFn, receiver) { function ObjectNotifierPerformChange(changeType, changeFn, receiver) {
if (!IS_SPEC_OBJECT(this)) if (!IS_SPEC_OBJECT(this))
throw MakeTypeError("called_on_non_object", ["performChange"]); throw MakeTypeError("called_on_non_object", ["performChange"]);
var objectInfo = ObjectInfoGetFromNotifier(this); var target = notifierTargetMap.get(this);
if (IS_UNDEFINED(target))
if (IS_UNDEFINED(objectInfo))
throw MakeTypeError("observe_notify_non_notifier"); throw MakeTypeError("observe_notify_non_notifier");
if (!IS_STRING(changeType)) if (!IS_STRING(changeType))
throw MakeTypeError("observe_perform_non_string"); throw MakeTypeError("observe_perform_non_string");
@ -485,11 +375,15 @@ function ObjectNotifierPerformChange(changeType, changeFn, receiver) {
receiver = ToObject(receiver); receiver = ToObject(receiver);
} }
ObjectInfoAddPerformingType(objectInfo, changeType); var objectInfo = objectInfoMap.get(target);
if (IS_UNDEFINED(objectInfo))
return;
BeginPerformChange(objectInfo, changeType);
try { try {
%_CallFunction(receiver, changeFn); %_CallFunction(receiver, changeFn);
} finally { } finally {
ObjectInfoRemovePerformingType(objectInfo, changeType); EndPerformChange(objectInfo, changeType);
} }
} }
@ -499,8 +393,18 @@ function ObjectGetNotifier(object) {
if (ObjectIsFrozen(object)) return null; if (ObjectIsFrozen(object)) return null;
var objectInfo = ObjectInfoGet(object); var objectInfo = objectInfoMap.get(object);
return ObjectInfoGetNotifier(objectInfo); if (IS_UNDEFINED(objectInfo)) {
objectInfo = CreateObjectInfo(object);
%SetIsObserved(object);
}
if (IS_NULL(objectInfo.notifier)) {
objectInfo.notifier = { __proto__: notifierPrototype };
notifierTargetMap.set(objectInfo.notifier, object);
}
return objectInfo.notifier;
} }
function CallbackDeliverPending(callback) { function CallbackDeliverPending(callback) {
@ -513,9 +417,7 @@ function CallbackDeliverPending(callback) {
var priority = callbackInfo.priority; var priority = callbackInfo.priority;
callbackInfoMap.set(callback, priority); callbackInfoMap.set(callback, priority);
if (observationState.pendingObservers)
delete observationState.pendingObservers[priority]; delete observationState.pendingObservers[priority];
var delivered = []; var delivered = [];
%MoveArrayContents(callbackInfo, delivered); %MoveArrayContents(callbackInfo, delivered);
@ -533,9 +435,9 @@ function ObjectDeliverChangeRecords(callback) {
} }
function DeliverChangeRecords() { function DeliverChangeRecords() {
while (observationState.pendingObservers) { while (observationState.pendingObservers.length) {
var pendingObservers = observationState.pendingObservers; var pendingObservers = observationState.pendingObservers;
observationState.pendingObservers = null; observationState.pendingObservers = new InternalArray;
for (var i in pendingObservers) { for (var i in pendingObservers) {
CallbackDeliverPending(pendingObservers[i]); CallbackDeliverPending(pendingObservers[i]);
} }

8
test/cctest/test-object-observe.cc
View File

@ -435,14 +435,14 @@ TEST(ObservationWeakMap) {
i::Handle<i::JSWeakMap> objectInfoMap = i::Handle<i::JSWeakMap> objectInfoMap =
i::Handle<i::JSWeakMap>::cast( i::Handle<i::JSWeakMap>::cast(
i::GetProperty(observation_state, "objectInfoMap")); i::GetProperty(observation_state, "objectInfoMap"));
i::Handle<i::JSWeakMap> notifierObjectInfoMap = i::Handle<i::JSWeakMap> notifierTargetMap =
i::Handle<i::JSWeakMap>::cast( i::Handle<i::JSWeakMap>::cast(
i::GetProperty(observation_state, "notifierObjectInfoMap")); i::GetProperty(observation_state, "notifierTargetMap"));
CHECK_EQ(1, NumberOfElements(callbackInfoMap)); CHECK_EQ(1, NumberOfElements(callbackInfoMap));
CHECK_EQ(1, NumberOfElements(objectInfoMap)); CHECK_EQ(1, NumberOfElements(objectInfoMap));
CHECK_EQ(1, NumberOfElements(notifierObjectInfoMap)); CHECK_EQ(1, NumberOfElements(notifierTargetMap));
HEAP->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask); HEAP->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask);
CHECK_EQ(0, NumberOfElements(callbackInfoMap)); CHECK_EQ(0, NumberOfElements(callbackInfoMap));
CHECK_EQ(0, NumberOfElements(objectInfoMap)); CHECK_EQ(0, NumberOfElements(objectInfoMap));
CHECK_EQ(0, NumberOfElements(notifierObjectInfoMap)); CHECK_EQ(0, NumberOfElements(notifierTargetMap));
} }