Revert "Various cleanup/simplification in object-observe.js"

src/object-observe.js

 // Copyright 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.
 
 "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
@@ skipping 15 matching lines @@
 // 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;
 
-// This is run during the first context creation in an isolate.
-if (IS_UNDEFINED(observationState.callbackInfoMap)) {
-  observationState.callbackInfoMap = %ObservationWeakMapCreate();
-  observationState.objectInfoMap = %ObservationWeakMapCreate();
-  observationState.notifierObjectInfoMap = %ObservationWeakMapCreate();
-  observationState.pendingObservers = null;
-  observationState.nextCallbackPriority = 0;
-  observationState.lastMicrotaskId = 0;
+function GetObservationStateJS() {
+  if (IS_UNDEFINED(observationState))
+    observationState = %GetObservationState();
+
+  if (IS_UNDEFINED(observationState.callbackInfoMap)) {
+    observationState.callbackInfoMap = %ObservationWeakMapCreate();
+    observationState.objectInfoMap = %ObservationWeakMapCreate();
+    observationState.notifierObjectInfoMap = %ObservationWeakMapCreate();
+    observationState.pendingObservers = null;
+    observationState.nextCallbackPriority = 0;
+    observationState.lastMicrotaskId = 0;
+  }
+
+  return observationState;
+}
+
+function GetWeakMapWrapper() {
+  function MapWrapper(map) {
+    this.map_ = map;
+  };
+
+  MapWrapper.prototype = {
+    __proto__: null,
+    get: function(key) {
+      return %WeakCollectionGet(this.map_, key);
+    },
+    set: function(key, value) {
+      %WeakCollectionSet(this.map_, key, value);
+    },
+    has: function(key) {
+      return !IS_UNDEFINED(this.get(key));
+    }
+  };
+
+  return MapWrapper;
+}
+
+var contextMaps;
+
+function GetContextMaps() {
+  if (IS_UNDEFINED(contextMaps)) {
+    var map = GetWeakMapWrapper();
+    var observationState = GetObservationStateJS();
+    contextMaps = {
+      callbackInfoMap: new map(observationState.callbackInfoMap),
+      objectInfoMap: new map(observationState.objectInfoMap),
+      notifierObjectInfoMap: new map(observationState.notifierObjectInfoMap)
+    };
+  }
+
+  return contextMaps;
+}
+
+function GetCallbackInfoMap() {
+  return GetContextMaps().callbackInfoMap;
+}
+
+function GetObjectInfoMap() {
+  return GetContextMaps().objectInfoMap;
+}
+
+function GetNotifierObjectInfoMap() {
+  return GetContextMaps().notifierObjectInfoMap;
 }
 
 function GetPendingObservers() {
-  return observationState.pendingObservers;
+  return GetObservationStateJS().pendingObservers;
 }
 
 function SetPendingObservers(pendingObservers) {
-  observationState.pendingObservers = pendingObservers;
+  GetObservationStateJS().pendingObservers = pendingObservers;
 }
 
 function GetNextCallbackPriority() {
-  return observationState.nextCallbackPriority++;
+  return GetObservationStateJS().nextCallbackPriority++;
 }
 
 function nullProtoObject() {
   return { __proto__: null };
 }
 
 function TypeMapCreate() {
   return nullProtoObject();
 }
 
@@ skipping 74 matching lines @@
     if (!%_IsJSProxy(object)) {
       %SetIsObserved(object);
     }
     objectInfo = {
       object: object,
       changeObservers: null,
       notifier: null,
       performing: null,
       performingCount: 0,
     };
-    %WeakCollectionSet(observationState.objectInfoMap, object, objectInfo);
+    GetObjectInfoMap().set(object, objectInfo);
   }
   return objectInfo;
 }
 
 function ObjectInfoGet(object) {
-  return %WeakCollectionGet(observationState.objectInfoMap, object);
+  return GetObjectInfoMap().get(object);
 }
 
 function ObjectInfoGetFromNotifier(notifier) {
-  return %WeakCollectionGet(observationState.notifierObjectInfoMap, notifier);
+  return GetNotifierObjectInfoMap().get(notifier);
 }
 
 function ObjectInfoGetNotifier(objectInfo) {
   if (IS_NULL(objectInfo.notifier)) {
     objectInfo.notifier = { __proto__: notifierPrototype };
-    %WeakCollectionSet(observationState.notifierObjectInfoMap,
-                       objectInfo.notifier, objectInfo);
+    GetNotifierObjectInfoMap().set(objectInfo.notifier, objectInfo);
   }
 
   return objectInfo.notifier;
 }
 
+function ObjectInfoGetObject(objectInfo) {
+  return objectInfo.object;
+}
+
 function ChangeObserversIsOptimized(changeObservers) {
-  return IS_SPEC_FUNCTION(changeObservers) ||
-         IS_SPEC_FUNCTION(changeObservers.callback);
+  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);
@@ skipping 75 matching lines @@
   var len = ToInteger(arg.length);
   if (len < 0) len = 0;
 
   return TypeMapCreateFromList(arg, len);
 }
 
 // CallbackInfo's optimized state is just a number which represents its global
 // priority. When a change record must be enqueued for the callback, it
 // normalizes. When delivery clears any pending change records, it re-optimizes.
 function CallbackInfoGet(callback) {
-  return %WeakCollectionGet(observationState.callbackInfoMap, callback);
-}
-
-function CallbackInfoSet(callback, callbackInfo) {
-  %WeakCollectionSet(observationState.callbackInfoMap, callback, callbackInfo);
+  return GetCallbackInfoMap().get(callback);
 }
 
 function CallbackInfoGetOrCreate(callback) {
-  var callbackInfo = CallbackInfoGet(callback);
+  var callbackInfo = GetCallbackInfoMap().get(callback);
   if (!IS_UNDEFINED(callbackInfo))
     return callbackInfo;
 
-  var priority = GetNextCallbackPriority();
-  CallbackInfoSet(callback, priority);
+  var priority =  GetNextCallbackPriority();
+  GetCallbackInfoMap().set(callback, priority);
   return priority;
 }
 
 function CallbackInfoGetPriority(callbackInfo) {
   if (IS_NUMBER(callbackInfo))
     return callbackInfo;
   else
     return callbackInfo.priority;
 }
 
 function CallbackInfoNormalize(callback) {
-  var callbackInfo = CallbackInfoGet(callback);
+  var callbackInfo = GetCallbackInfoMap().get(callback);
   if (IS_NUMBER(callbackInfo)) {
     var priority = callbackInfo;
     callbackInfo = new InternalArray;
     callbackInfo.priority = priority;
-    CallbackInfoSet(callback, callbackInfo);
+    GetCallbackInfoMap().set(callback, callbackInfo);
   }
   return callbackInfo;
 }
 
 function ObjectObserve(object, callback, acceptList) {
   if (!IS_SPEC_OBJECT(object))
     throw MakeTypeError("observe_non_object", ["observe"]);
   if (%IsJSGlobalProxy(object))
     throw MakeTypeError("observe_global_proxy", ["observe"]);
   if (!IS_SPEC_FUNCTION(callback))
@@ skipping 48 matching lines @@
   var callback = ObserverGetCallback(observer);
   if (!%ObserverObjectAndRecordHaveSameOrigin(callback, changeRecord.object,
                                               changeRecord)) {
     return;
   }
 
   var callbackInfo = CallbackInfoNormalize(callback);
   if (IS_NULL(GetPendingObservers())) {
     SetPendingObservers(nullProtoObject());
     if (DEBUG_IS_ACTIVE) {
-      var id = ++observationState.lastMicrotaskId;
+      var id = ++GetObservationStateJS().lastMicrotaskId;
       var name = "Object.observe";
       %EnqueueMicrotask(function() {
         %DebugAsyncTaskEvent({ type: "willHandle", id: id, name: name });
         ObserveMicrotaskRunner();
         %DebugAsyncTaskEvent({ type: "didHandle", id: id, name: name });
       });
       %DebugAsyncTaskEvent({ type: "enqueue", id: id, name: name });
     } else {
       %EnqueueMicrotask(ObserveMicrotaskRunner);
     }
   }
   GetPendingObservers()[callbackInfo.priority] = callback;
   callbackInfo.push(changeRecord);
 }
 
 function ObjectInfoEnqueueExternalChangeRecord(objectInfo, changeRecord, type) {
   if (!ObjectInfoHasActiveObservers(objectInfo))
     return;
 
   var hasType = !IS_UNDEFINED(type);
   var newRecord = hasType ?
-      { object: objectInfo.object, type: type } :
-      { object: objectInfo.object };
+      { object: ObjectInfoGetObject(objectInfo), type: type } :
+      { object: ObjectInfoGetObject(objectInfo) };
 
   for (var prop in changeRecord) {
     if (prop === 'object' || (hasType && prop === 'type')) continue;
     %DefineDataPropertyUnchecked(
         newRecord, prop, changeRecord[prop], READ_ONLY + DONT_DELETE);
   }
   ObjectFreezeJS(newRecord);
 
   ObjectInfoEnqueueInternalChangeRecord(objectInfo, newRecord);
 }
@@ skipping 127 matching lines @@
   var getNotifierFn = %GetObjectContextObjectGetNotifier(object);
   return getNotifierFn(object);
 }
 
 function NativeObjectGetNotifier(object) {
   var objectInfo = ObjectInfoGetOrCreate(object);
   return ObjectInfoGetNotifier(objectInfo);
 }
 
 function CallbackDeliverPending(callback) {
-  var callbackInfo = CallbackInfoGet(callback);
+  var callbackInfo = GetCallbackInfoMap().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.
   var priority = callbackInfo.priority;
-  CallbackInfoSet(callback, priority);
+  GetCallbackInfoMap().set(callback, priority);
 
-  var pendingObservers = GetPendingObservers();
-  if (!IS_NULL(pendingObservers))
-    delete pendingObservers[priority];
+  if (GetPendingObservers())
+    delete GetPendingObservers()[priority];
 
   var delivered = [];
   %MoveArrayContents(callbackInfo, delivered);
 
   try {
     %_CallFunction(UNDEFINED, delivered, callback);
   } catch (ex) {}  // TODO(rossberg): perhaps log uncaught exceptions.
   return true;
 }
 
 function ObjectDeliverChangeRecords(callback) {
   if (!IS_SPEC_FUNCTION(callback))
     throw MakeTypeError("observe_non_function", ["deliverChangeRecords"]);
 
   while (CallbackDeliverPending(callback)) {}
 }
 
 function ObserveMicrotaskRunner() {
   var pendingObservers = GetPendingObservers();
-  if (!IS_NULL(pendingObservers)) {
+  if (pendingObservers) {
     SetPendingObservers(null);
     for (var i in pendingObservers) {
       CallbackDeliverPending(pendingObservers[i]);
     }
   }
 }
 
 function SetupObjectObserve() {
   %CheckIsBootstrapping();
   InstallFunctions($Object, DONT_ENUM, $Array(
     "deliverChangeRecords", ObjectDeliverChangeRecords,
     "getNotifier", ObjectGetNotifier,
     "observe", ObjectObserve,
     "unobserve", ObjectUnobserve
   ));
   InstallFunctions($Array, DONT_ENUM, $Array(
     "observe", ArrayObserve,
     "unobserve", ArrayUnobserve
   ));
   InstallFunctions(notifierPrototype, DONT_ENUM, $Array(
     "notify", ObjectNotifierNotify,
     "performChange", ObjectNotifierPerformChange
   ));
 }
 
 SetupObjectObserve();