Revert "Enable Object.observe by default"

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 38 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;
-
-function GetObservationState() {
-  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;
-  }
-
-  return observationState;
+var observationState = %GetObservationState();
+if (IS_UNDEFINED(observationState.callbackInfoMap)) {
+  observationState.callbackInfoMap = %ObservationWeakMapCreate();
+  observationState.objectInfoMap = %ObservationWeakMapCreate();
+  observationState.notifierObjectInfoMap = %ObservationWeakMapCreate();
+  observationState.pendingObservers = null;
+  observationState.nextCallbackPriority = 0;
 }
 
-function GetWeakMapWrapper() {
-  function MapWrapper(map) {
-    this.map_ = map;
-  };
-
-  MapWrapper.prototype = {
-    get: function(key) {
-      key = %UnwrapGlobalProxy(key);
-      if (!IS_SPEC_OBJECT(key)) return UNDEFINED;
-      return %WeakCollectionGet(this.map_, key);
-    },
-    set: function(key, value) {
-      key = %UnwrapGlobalProxy(key);
-      if (!IS_SPEC_OBJECT(key)) return UNDEFINED;
-      %WeakCollectionSet(this.map_, key, value);
-    },
-    has: function(key) {
-      return !IS_UNDEFINED(this.get(key));
-    }
-  };
-
-  return MapWrapper;
+function ObservationWeakMap(map) {
+  this.map_ = map;
 }
 
-var contextMaps;
+ObservationWeakMap.prototype = {
+  get: function(key) {
+    key = %UnwrapGlobalProxy(key);
+    if (!IS_SPEC_OBJECT(key)) return UNDEFINED;
+    return %WeakCollectionGet(this.map_, key);
+  },
+  set: function(key, value) {
+    key = %UnwrapGlobalProxy(key);
+    if (!IS_SPEC_OBJECT(key)) return UNDEFINED;
+    %WeakCollectionSet(this.map_, key, value);
+  },
+  has: function(key) {
+    return !IS_UNDEFINED(this.get(key));
+  }
+};
 
-function GetContextMaps() {
-  if (IS_UNDEFINED(contextMaps)) {
-    var map = GetWeakMapWrapper();
-    var observationState = GetObservationState();
-    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 GetObservationState().pendingObservers;
-}
-
-function SetPendingObservers(pendingObservers) {
-  GetObservationState().pendingObservers = pendingObservers;
-}
-
-function GetNextCallbackPriority() {
-  return GetObservationState().nextCallbackPriority++;
-}
+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 nullProtoObject();
 }
 
 function TypeMapAddType(typeMap, type, ignoreDuplicate) {
@@ skipping 70 matching lines @@
     if (!%IsJSProxy(object))
       %SetIsObserved(object);
 
     objectInfo = {
       object: object,
       changeObservers: null,
       notifier: null,
       performing: null,
       performingCount: 0,
     };
-    GetObjectInfoMap().set(object, objectInfo);
+    objectInfoMap.set(object, objectInfo);
   }
   return objectInfo;
 }
 
 function ObjectInfoGet(object) {
-  return GetObjectInfoMap().get(object);
+  return objectInfoMap.get(object);
 }
 
 function ObjectInfoGetFromNotifier(notifier) {
-  return GetNotifierObjectInfoMap().get(notifier);
+  return notifierObjectInfoMap.get(notifier);
 }
 
 function ObjectInfoGetNotifier(objectInfo) {
   if (IS_NULL(objectInfo.notifier)) {
     objectInfo.notifier = { __proto__: notifierPrototype };
-    GetNotifierObjectInfoMap().set(objectInfo.notifier, objectInfo);
+    notifierObjectInfoMap.set(objectInfo.notifier, objectInfo);
   }
 
   return objectInfo.notifier;
 }
 
 function ObjectInfoGetObject(objectInfo) {
   return objectInfo.object;
 }
 
 function ChangeObserversIsOptimized(changeObservers) {
@@ skipping 85 matching lines @@
       arg.length < 0)
     return false;
 
   return true;
 }
 
 // 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 GetCallbackInfoMap().get(callback);
+  return callbackInfoMap.get(callback);
 }
 
 function CallbackInfoGetOrCreate(callback) {
-  var callbackInfo = GetCallbackInfoMap().get(callback);
+  var callbackInfo = callbackInfoMap.get(callback);
   if (!IS_UNDEFINED(callbackInfo))
     return callbackInfo;
 
-  var priority =  GetNextCallbackPriority();
-  GetCallbackInfoMap().set(callback, priority);
+  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 = GetCallbackInfoMap().get(callback);
+  var callbackInfo = callbackInfoMap.get(callback);
   if (IS_NUMBER(callbackInfo)) {
     var priority = callbackInfo;
     callbackInfo = new InternalArray;
     callbackInfo.priority = priority;
-    GetCallbackInfoMap().set(callback, callbackInfo);
+    callbackInfoMap.set(callback, callbackInfo);
   }
   return callbackInfo;
 }
 
 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))
@@ skipping 41 matching lines @@
   var callback = ObserverGetCallback(observer);
   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 (IS_NULL(GetPendingObservers())) {
-    SetPendingObservers(nullProtoObject())
+  if (IS_NULL(observationState.pendingObservers)) {
+    observationState.pendingObservers = nullProtoObject();
     GetMicrotaskQueue().push(ObserveMicrotaskRunner);
     %SetMicrotaskPending(true);
   }
-  GetPendingObservers()[callbackInfo.priority] = callback;
+  observationState.pendingObservers[callbackInfo.priority] = callback;
   callbackInfo.push(changeRecord);
 }
 
 function ObjectInfoEnqueueExternalChangeRecord(objectInfo, changeRecord, type) {
   if (!ObjectInfoHasActiveObservers(objectInfo))
     return;
 
   var hasType = !IS_UNDEFINED(type);
   var newRecord = hasType ?
       { object: ObjectInfoGetObject(objectInfo), type: type } :
@@ skipping 132 matching lines @@
   if (!IS_SPEC_OBJECT(object))
     throw MakeTypeError("observe_non_object", ["getNotifier"]);
 
   if (ObjectIsFrozen(object)) return null;
 
   var objectInfo = ObjectInfoGetOrCreate(object);
   return ObjectInfoGetNotifier(objectInfo);
 }
 
 function CallbackDeliverPending(callback) {
-  var callbackInfo = GetCallbackInfoMap().get(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.
   var priority = callbackInfo.priority;
-  GetCallbackInfoMap().set(callback, priority);
+  callbackInfoMap.set(callback, priority);
 
-  if (GetPendingObservers())
-    delete GetPendingObservers()[priority];
+  if (observationState.pendingObservers)
+    delete observationState.pendingObservers[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();
+  var pendingObservers = observationState.pendingObservers;
   if (pendingObservers) {
-    SetPendingObservers(null);
+    observationState.pendingObservers = 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();