Minor Object.observe optimizations

src/object-observe.js

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 73 matching lines @@
     return !IS_UNDEFINED(this.get(key));
   }
 };
 
 var callbackInfoMap =
     new ObservationWeakMap(observationState.callbackInfoMap);
 var objectInfoMap = new ObservationWeakMap(observationState.objectInfoMap);
 var notifierObjectInfoMap =
     new ObservationWeakMap(observationState.notifierObjectInfoMap);
 
+function nullProtoObject() {
+  return { __proto__: null };
+}
+
 function TypeMapCreate() {
-  return { __proto__: null };
+  return nullProtoObject();
 }
 
 function TypeMapAddType(typeMap, type, ignoreDuplicate) {
   typeMap[type] = ignoreDuplicate ? 1 : (typeMap[type] || 0) + 1;
 }
 
 function TypeMapRemoveType(typeMap, type) {
   typeMap[type]--;
 }
 
@@ skipping 29 matching lines @@
   'reconfigure',
   'preventExtensions'
 ]);
 
 // 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,
-    callback: callback,
-    accept: TypeMapCreateFromList(acceptList)
-  };
+  if (IS_UNDEFINED(acceptList))
+    return callback;
+  var observer = nullProtoObject();
+  observer.callback = callback;
+  observer.accept = TypeMapCreateFromList(acceptList);
+  return observer;
 }
 
 function ObserverGetCallback(observer) {
   return IS_SPEC_FUNCTION(observer) ? observer : observer.callback;
 }
 
 function ObserverGetAcceptTypes(observer) {
   return IS_SPEC_FUNCTION(observer) ? defaultAcceptTypes : observer.accept;
 }
 
 function ObserverIsActive(observer, objectInfo) {
   return TypeMapIsDisjointFrom(ObjectInfoGetPerformingTypes(objectInfo),
                                ObserverGetAcceptTypes(observer));
 }
 
-function ObjectInfoGet(object) {
-  var objectInfo = objectInfoMap.get(object);
+function ObjectInfoGetOrCreate(object) {
+  var objectInfo = ObjectInfoGet(object);
   if (IS_UNDEFINED(objectInfo)) {
     if (!%IsJSProxy(object))
       %SetIsObserved(object);
 
     objectInfo = {
       object: object,
       changeObservers: null,
       notifier: null,
       performing: null,
       performingCount: 0,
     };
     objectInfoMap.set(object, objectInfo);
   }
   return objectInfo;
 }
 
+function ObjectInfoGet(object) {
+  return objectInfoMap.get(object);
+}
+
 function ObjectInfoGetFromNotifier(notifier) {
   return notifierObjectInfoMap.get(notifier);
 }
 
 function ObjectInfoGetNotifier(objectInfo) {
   if (IS_NULL(objectInfo.notifier)) {
     objectInfo.notifier = { __proto__: notifierPrototype };
     notifierObjectInfoMap.set(objectInfo.notifier, objectInfo);
   }
 
@@ skipping 12 matching lines @@
 // 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 = nullProtoObject();
     objectInfo.changeObservers[priority] = observer;
   }
 }
 
 function ObjectInfoAddObserver(objectInfo, callback, acceptList) {
   var callbackInfo = CallbackInfoGetOrCreate(callback);
   var observer = ObserverCreate(callback, acceptList);
 
   if (!objectInfo.changeObservers) {
     objectInfo.changeObservers = observer;
@@ skipping 10 matching lines @@
     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];
+  objectInfo.changeObservers[priority] = null;
 }
 
 function ObjectInfoHasActiveObservers(objectInfo) {
   if (IS_UNDEFINED(objectInfo) || !objectInfo.changeObservers)
     return false;
 
   if (ChangeObserversIsOptimized(objectInfo.changeObservers))
     return ObserverIsActive(objectInfo.changeObservers, objectInfo);
 
   for (var priority in objectInfo.changeObservers) {
-    if (ObserverIsActive(objectInfo.changeObservers[priority], objectInfo))
+    var observer = objectInfo.changeObservers[priority];
+    if (!IS_NULL(observer) && ObserverIsActive(observer, objectInfo))
       return true;
   }
 
   return false;
 }
 
 function ObjectInfoAddPerformingType(objectInfo, type) {
   objectInfo.performing = objectInfo.performing || TypeMapCreate();
   TypeMapAddType(objectInfo.performing, type);
   objectInfo.performingCount++;
@@ skipping 58 matching lines @@
 function ObjectObserve(object, callback, acceptList) {
   if (!IS_SPEC_OBJECT(object))
     throw MakeTypeError("observe_non_object", ["observe"]);
   if (!IS_SPEC_FUNCTION(callback))
     throw MakeTypeError("observe_non_function", ["observe"]);
   if (ObjectIsFrozen(callback))
     throw MakeTypeError("observe_callback_frozen");
   if (!AcceptArgIsValid(acceptList))
     throw MakeTypeError("observe_accept_invalid");
 
-  var objectInfo = ObjectInfoGet(object);
+  var objectInfo = ObjectInfoGetOrCreate(object);
   ObjectInfoAddObserver(objectInfo, callback, acceptList);
   return object;
 }
 
 function ObjectUnobserve(object, callback) {
   if (!IS_SPEC_OBJECT(object))
     throw MakeTypeError("observe_non_object", ["unobserve"]);
   if (!IS_SPEC_FUNCTION(callback))
     throw MakeTypeError("observe_non_function", ["unobserve"]);
 
-  var objectInfo = objectInfoMap.get(object);
+  var objectInfo = ObjectInfoGet(object);
   if (IS_UNDEFINED(objectInfo))
     return object;
 
   ObjectInfoRemoveObserver(objectInfo, callback);
   return object;
 }
 
 function ArrayObserve(object, callback) {
   return ObjectObserve(object, callback, ['add',
                                           'update',
@@ skipping 16 matching lines @@
   if (needsAccessCheck &&
       // Drop all splice records on the floor for access-checked objects
       (changeRecord.type == 'splice' ||
        !%IsAccessAllowedForObserver(
            callback, changeRecord.object, changeRecord.name))) {
     return;
   }
 
   var callbackInfo = CallbackInfoNormalize(callback);
   if (!observationState.pendingObservers)
-    observationState.pendingObservers = { __proto__: null };
+    observationState.pendingObservers = nullProtoObject();
   observationState.pendingObservers[callbackInfo.priority] = callback;
   callbackInfo.push(changeRecord);
   %SetMicrotaskPending(true);
 }
 
 function ObjectInfoEnqueueExternalChangeRecord(objectInfo, changeRecord, type) {
   if (!ObjectInfoHasActiveObservers(objectInfo))
     return;
 
   var hasType = !IS_UNDEFINED(type);
@@ skipping 22 matching lines @@
 
   if (ChangeObserversIsOptimized(objectInfo.changeObservers)) {
     var observer = objectInfo.changeObservers;
     ObserverEnqueueIfActive(observer, objectInfo, changeRecord,
                             needsAccessCheck);
     return;
   }
 
   for (var priority in objectInfo.changeObservers) {
     var observer = objectInfo.changeObservers[priority];
+    if (IS_NULL(observer))
+      continue;
     ObserverEnqueueIfActive(observer, objectInfo, changeRecord,
                             needsAccessCheck);
   }
 }
 
 function BeginPerformSplice(array) {
-  var objectInfo = objectInfoMap.get(array);
+  var objectInfo = ObjectInfoGet(array);
   if (!IS_UNDEFINED(objectInfo))
     ObjectInfoAddPerformingType(objectInfo, 'splice');
 }
 
 function EndPerformSplice(array) {
-  var objectInfo = objectInfoMap.get(array);
+  var objectInfo = ObjectInfoGet(array);
   if (!IS_UNDEFINED(objectInfo))
     ObjectInfoRemovePerformingType(objectInfo, 'splice');
 }
 
 function EnqueueSpliceRecord(array, index, removed, addedCount) {
-  var objectInfo = objectInfoMap.get(array);
+  var objectInfo = ObjectInfoGet(array);
   if (!ObjectInfoHasActiveObservers(objectInfo))
     return;
 
   var changeRecord = {
     type: 'splice',
     object: array,
     index: index,
     removed: removed,
     addedCount: addedCount
   };
 
   ObjectFreeze(changeRecord);
   ObjectFreeze(changeRecord.removed);
   ObjectInfoEnqueueInternalChangeRecord(objectInfo, changeRecord);
 }
 
 function NotifyChange(type, object, name, oldValue) {
-  var objectInfo = objectInfoMap.get(object);
+  var objectInfo = ObjectInfoGet(object);
   if (!ObjectInfoHasActiveObservers(objectInfo))
     return;
 
   var changeRecord;
   if (arguments.length == 2) {
     changeRecord = { type: type, object: object };
   } else if (arguments.length == 3) {
     changeRecord = { type: type, object: object, name: name };
   } else {
     changeRecord = {
@@ skipping 48 matching lines @@
   if (IS_SPEC_OBJECT(changeRecord))
     ObjectInfoEnqueueExternalChangeRecord(objectInfo, changeRecord, changeType);
 }
 
 function ObjectGetNotifier(object) {
   if (!IS_SPEC_OBJECT(object))
     throw MakeTypeError("observe_non_object", ["getNotifier"]);
 
   if (ObjectIsFrozen(object)) return null;
 
-  var objectInfo = ObjectInfoGet(object);
+  var objectInfo = ObjectInfoGetOrCreate(object);
   return ObjectInfoGetNotifier(objectInfo);
 }
 
 function CallbackDeliverPending(callback) {
   var callbackInfo = callbackInfoMap.get(callback);
   if (IS_UNDEFINED(callbackInfo) || IS_NUMBER(callbackInfo))
     return false;
 
   // Clear the pending change records from callback and return it to its
   // "optimized" state.
@@ skipping 42 matching lines @@
     "observe", ArrayObserve,
     "unobserve", ArrayUnobserve
   ));
   InstallFunctions(notifierPrototype, DONT_ENUM, $Array(
     "notify", ObjectNotifierNotify,
     "performChange", ObjectNotifierPerformChange
   ));
 }
 
 SetupObjectObserve();