Pass --harmony-object-observe in tests that depend on it

test/cctest/test-object-observe.cc

 // 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 24 matching lines @@
 using namespace v8;
 namespace i = v8::internal;
 
 inline int32_t ToInt32(v8::Local<v8::Value> value) {
   return value->Int32Value(v8::Isolate::GetCurrent()->GetCurrentContext())
       .FromJust();
 }
 
 
 TEST(PerIsolateState) {
+  i::FLAG_harmony_object_observe = true;
   HandleScope scope(CcTest::isolate());
   LocalContext context1(CcTest::isolate());
 
   Local<Value> foo = v8_str("foo");
   context1->SetSecurityToken(foo);
 
   CompileRun(
       "var count = 0;"
       "var calls = 0;"
       "var observer = function(records) { count = records.length; calls++ };"
@@ skipping 43 matching lines @@
               notify_fun3)
         .FromJust();
     CompileRun("fun1(); fun2(); fun3(); Object.deliverChangeRecords(observer)");
   }
   CHECK_EQ(1, ToInt32(CompileRun("calls")));
   CHECK_EQ(3, ToInt32(CompileRun("count")));
 }
 
 
 TEST(EndOfMicrotaskDelivery) {
+  i::FLAG_harmony_object_observe = true;
   HandleScope scope(CcTest::isolate());
   LocalContext context(CcTest::isolate());
   CompileRun(
       "var obj = {};"
       "var count = 0;"
       "var observer = function(records) { count = records.length };"
       "Object.observe(obj, observer);"
       "obj.foo = 'bar';");
   CHECK_EQ(1, ToInt32(CompileRun("count")));
 }
 
 
 TEST(DeliveryOrdering) {
+  i::FLAG_harmony_object_observe = true;
   HandleScope scope(CcTest::isolate());
   LocalContext context(CcTest::isolate());
   CompileRun(
       "var obj1 = {};"
       "var obj2 = {};"
       "var ordering = [];"
       "function observer2() { ordering.push(2); };"
       "function observer1() { ordering.push(1); };"
       "function observer3() { ordering.push(3); };"
       "Object.observe(obj1, observer1);"
@@ skipping 11 matching lines @@
       "Object.observe(obj2, observer1);"
       "obj2.foo = 'baz'");
   CHECK_EQ(3, ToInt32(CompileRun("ordering.length")));
   CHECK_EQ(1, ToInt32(CompileRun("ordering[0]")));
   CHECK_EQ(2, ToInt32(CompileRun("ordering[1]")));
   CHECK_EQ(3, ToInt32(CompileRun("ordering[2]")));
 }
 
 
 TEST(DeliveryCallbackThrows) {
+  i::FLAG_harmony_object_observe = true;
   HandleScope scope(CcTest::isolate());
   LocalContext context(CcTest::isolate());
   CompileRun(
       "var obj = {};"
       "var ordering = [];"
       "function observer1() { ordering.push(1); };"
       "function observer2() { ordering.push(2); };"
       "function observer_throws() {"
       "  ordering.push(0);"
       "  throw new Error();"
       "  ordering.push(-1);"
       "};"
       "Object.observe(obj, observer_throws.bind());"
       "Object.observe(obj, observer1);"
       "Object.observe(obj, observer_throws.bind());"
       "Object.observe(obj, observer2);"
       "Object.observe(obj, observer_throws.bind());"
       "obj.foo = 'bar';");
   CHECK_EQ(5, ToInt32(CompileRun("ordering.length")));
   CHECK_EQ(0, ToInt32(CompileRun("ordering[0]")));
   CHECK_EQ(1, ToInt32(CompileRun("ordering[1]")));
   CHECK_EQ(0, ToInt32(CompileRun("ordering[2]")));
   CHECK_EQ(2, ToInt32(CompileRun("ordering[3]")));
   CHECK_EQ(0, ToInt32(CompileRun("ordering[4]")));
 }
 
 
 TEST(DeliveryChangesMutationInCallback) {
+  i::FLAG_harmony_object_observe = true;
   HandleScope scope(CcTest::isolate());
   LocalContext context(CcTest::isolate());
   CompileRun(
       "var obj = {};"
       "var ordering = [];"
       "function observer1(records) {"
       "  ordering.push(100 + records.length);"
       "  records.push(11);"
       "  records.push(22);"
       "};"
       "function observer2(records) {"
       "  ordering.push(200 + records.length);"
       "  records.push(33);"
       "  records.push(44);"
       "};"
       "Object.observe(obj, observer1);"
       "Object.observe(obj, observer2);"
       "obj.foo = 'bar';");
   CHECK_EQ(2, ToInt32(CompileRun("ordering.length")));
   CHECK_EQ(101, ToInt32(CompileRun("ordering[0]")));
   CHECK_EQ(201, ToInt32(CompileRun("ordering[1]")));
 }
 
 
 TEST(DeliveryOrderingReentrant) {
+  i::FLAG_harmony_object_observe = true;
   HandleScope scope(CcTest::isolate());
   LocalContext context(CcTest::isolate());
   CompileRun(
       "var obj = {};"
       "var reentered = false;"
       "var ordering = [];"
       "function observer1() { ordering.push(1); };"
       "function observer2() {"
       "  if (!reentered) {"
       "    obj.foo = 'baz';"
@@ skipping 11 matching lines @@
   CHECK_EQ(2, ToInt32(CompileRun("ordering[1]")));
   CHECK_EQ(3, ToInt32(CompileRun("ordering[2]")));
   // Note that we re-deliver to observers 1 and 2, while observer3
   // already received the second record during the first round.
   CHECK_EQ(1, ToInt32(CompileRun("ordering[3]")));
   CHECK_EQ(2, ToInt32(CompileRun("ordering[1]")));
 }
 
 
 TEST(DeliveryOrderingDeliverChangeRecords) {
+  i::FLAG_harmony_object_observe = true;
   HandleScope scope(CcTest::isolate());
   LocalContext context(CcTest::isolate());
   CompileRun(
       "var obj = {};"
       "var ordering = [];"
       "function observer1() { ordering.push(1); if (!obj.b) obj.b = true };"
       "function observer2() { ordering.push(2); };"
       "Object.observe(obj, observer1);"
       "Object.observe(obj, observer2);"
       "obj.a = 1;"
       "Object.deliverChangeRecords(observer2);");
   CHECK_EQ(4, ToInt32(CompileRun("ordering.length")));
   // First, observer2 is called due to deliverChangeRecords
   CHECK_EQ(2, ToInt32(CompileRun("ordering[0]")));
   // Then, observer1 is called when the stack unwinds
   CHECK_EQ(1, ToInt32(CompileRun("ordering[1]")));
   // observer1's mutation causes both 1 and 2 to be reactivated,
   // with 1 having priority.
   CHECK_EQ(1, ToInt32(CompileRun("ordering[2]")));
   CHECK_EQ(2, ToInt32(CompileRun("ordering[3]")));
 }
 
 
 TEST(ObjectHashTableGrowth) {
+  i::FLAG_harmony_object_observe = true;
   HandleScope scope(CcTest::isolate());
   // Initializing this context sets up initial hash tables.
   LocalContext context(CcTest::isolate());
   Local<Value> obj = CompileRun("obj = {};");
   Local<Value> observer = CompileRun(
       "var ran = false;"
       "(function() { ran = true })");
   {
     // As does initializing this context.
     LocalContext context2(CcTest::isolate());
@@ skipping 75 matching lines @@
       }
     }
   }
 }
 
 #define EXPECT_RECORDS(records, expectations)                \
   ExpectRecords(CcTest::isolate(), records, expectations, \
                 arraysize(expectations))
 
 TEST(APITestBasicMutation) {
+  i::FLAG_harmony_object_observe = true;
   v8::Isolate* v8_isolate = CcTest::isolate();
   HandleScope scope(v8_isolate);
   LocalContext context(v8_isolate);
   Local<Object> obj = Local<Object>::Cast(
       CompileRun("var records = [];"
                  "var obj = {};"
                  "function observer(r) { [].push.apply(records, r); };"
                  "Object.observe(obj, observer);"
                  "obj"));
   obj->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("foo"),
@@ skipping 39 matching lines @@
       {obj, "update", "1", Number::New(v8_isolate, 4)},
       {obj, "add", "1.1", Local<Value>()},
       {obj, "delete", "foo", Number::New(v8_isolate, 3)},
       {obj, "delete", "1", Number::New(v8_isolate, 5)},
       {obj, "delete", "1.1", Number::New(v8_isolate, 6)}};
   EXPECT_RECORDS(CompileRun("records"), expected_records);
 }
 
 
 TEST(HiddenPrototypeObservation) {
+  i::FLAG_harmony_object_observe = true;
   v8::Isolate* v8_isolate = CcTest::isolate();
   HandleScope scope(v8_isolate);
   LocalContext context(v8_isolate);
   Local<FunctionTemplate> tmpl = FunctionTemplate::New(v8_isolate);
   tmpl->SetHiddenPrototype(true);
   tmpl->InstanceTemplate()->Set(v8_str("foo"), Number::New(v8_isolate, 75));
   Local<Function> function =
       tmpl->GetFunction(v8::Isolate::GetCurrent()->GetCurrentContext())
           .ToLocalChecked();
   Local<Object> proto =
@@ skipping 42 matching lines @@
   EXPECT_RECORDS(CompileRun("records"), expected_records3);
 }
 
 
 static int NumberOfElements(i::Handle<i::JSWeakMap> map) {
   return i::ObjectHashTable::cast(map->table())->NumberOfElements();
 }
 
 
 TEST(ObservationWeakMap) {
+  i::FLAG_harmony_object_observe = true;
   HandleScope scope(CcTest::isolate());
   LocalContext context(CcTest::isolate());
   CompileRun(
       "var obj = {};"
       "Object.observe(obj, function(){});"
       "Object.getNotifier(obj);"
       "obj = null;");
   i::Isolate* i_isolate = CcTest::i_isolate();
   i::Handle<i::JSObject> observation_state =
       i_isolate->factory()->observation_state();
@@ skipping 50 matching lines @@
                  "Array.prototype.splice.call(obj, 1, 2, 2, 4);"
                  "Array.prototype.pop.call(obj);"
                  "Array.prototype.shift.call(obj);");
     }
   }
   return ToInt32(CompileRun("records ? records.length : 0"));
 }
 
 
 TEST(ObserverSecurityAAA) {
+  i::FLAG_harmony_object_observe = true;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   v8::Local<Context> contextA = Context::New(isolate);
   CHECK_EQ(8, TestObserveSecurity(contextA, contextA, contextA));
 }
 
 
 TEST(ObserverSecurityA1A2A3) {
+  i::FLAG_harmony_object_observe = true;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
 
   v8::Local<Context> contextA1 = Context::New(isolate);
   v8::Local<Context> contextA2 = Context::New(isolate);
   v8::Local<Context> contextA3 = Context::New(isolate);
 
   Local<Value> foo = v8_str("foo");
   contextA1->SetSecurityToken(foo);
   contextA2->SetSecurityToken(foo);
   contextA3->SetSecurityToken(foo);
 
   CHECK_EQ(8, TestObserveSecurity(contextA1, contextA2, contextA3));
 }
 
 
 TEST(ObserverSecurityAAB) {
+  i::FLAG_harmony_object_observe = true;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   v8::Local<Context> contextA = Context::New(isolate);
   v8::Local<Context> contextB = Context::New(isolate);
   CHECK_EQ(0, TestObserveSecurity(contextA, contextA, contextB));
 }
 
 
 TEST(ObserverSecurityA1A2B) {
+  i::FLAG_harmony_object_observe = true;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
 
   v8::Local<Context> contextA1 = Context::New(isolate);
   v8::Local<Context> contextA2 = Context::New(isolate);
   v8::Local<Context> contextB = Context::New(isolate);
 
   Local<Value> foo = v8_str("foo");
   contextA1->SetSecurityToken(foo);
   contextA2->SetSecurityToken(foo);
 
   CHECK_EQ(0, TestObserveSecurity(contextA1, contextA2, contextB));
 }
 
 
 TEST(ObserverSecurityABA) {
+  i::FLAG_harmony_object_observe = true;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   v8::Local<Context> contextA = Context::New(isolate);
   v8::Local<Context> contextB = Context::New(isolate);
   CHECK_EQ(0, TestObserveSecurity(contextA, contextB, contextA));
 }
 
 
 TEST(ObserverSecurityA1BA2) {
+  i::FLAG_harmony_object_observe = true;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   v8::Local<Context> contextA1 = Context::New(isolate);
   v8::Local<Context> contextA2 = Context::New(isolate);
   v8::Local<Context> contextB = Context::New(isolate);
 
   Local<Value> foo = v8_str("foo");
   contextA1->SetSecurityToken(foo);
   contextA2->SetSecurityToken(foo);
 
   CHECK_EQ(0, TestObserveSecurity(contextA1, contextB, contextA2));
 }
 
 
 TEST(ObserverSecurityBAA) {
+  i::FLAG_harmony_object_observe = true;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   v8::Local<Context> contextA = Context::New(isolate);
   v8::Local<Context> contextB = Context::New(isolate);
   CHECK_EQ(0, TestObserveSecurity(contextB, contextA, contextA));
 }
 
 
 TEST(ObserverSecurityBA1A2) {
+  i::FLAG_harmony_object_observe = true;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   v8::Local<Context> contextA1 = Context::New(isolate);
   v8::Local<Context> contextA2 = Context::New(isolate);
   v8::Local<Context> contextB = Context::New(isolate);
 
   Local<Value> foo = v8_str("foo");
   contextA1->SetSecurityToken(foo);
   contextA2->SetSecurityToken(foo);
 
   CHECK_EQ(0, TestObserveSecurity(contextB, contextA1, contextA2));
 }
 
 
 TEST(ObserverSecurityNotify) {
+  i::FLAG_harmony_object_observe = true;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   v8::Local<Context> contextA = Context::New(isolate);
   v8::Local<Context> contextB = Context::New(isolate);
 
   Context::Scope scopeA(contextA);
   CompileRun("var obj = {};"
              "var recordsA = null;"
              "var observerA = function(r) { recordsA = r };"
              "Object.observe(obj, observerA);");
@@ skipping 15 matching lines @@
   CHECK_EQ(1, ToInt32(CompileRun("recordsA ? recordsA.length : 0")));
 
   {
     Context::Scope scopeB(contextB);
     CHECK_EQ(0, ToInt32(CompileRun("recordsB ? recordsB.length : 0")));
   }
 }
 
 
 TEST(HiddenPropertiesLeakage) {
+  i::FLAG_harmony_object_observe = true;
   HandleScope scope(CcTest::isolate());
   LocalContext context(CcTest::isolate());
   CompileRun("var obj = {};"
              "var records = null;"
              "var observer = function(r) { records = r };"
              "Object.observe(obj, observer);");
   Local<Value> obj =
       context->Global()
           ->Get(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("obj"))
           .ToLocalChecked();
   Local<Object>::Cast(obj)
       ->SetPrivate(v8::Isolate::GetCurrent()->GetCurrentContext(),
                    v8::Private::New(CcTest::isolate(), v8_str("foo")),
                    Null(CcTest::isolate()))
       .FromJust();
   CompileRun("");  // trigger delivery
   CHECK(CompileRun("records")->IsNull());
 }
 
 
 TEST(GetNotifierFromOtherContext) {
+  i::FLAG_harmony_object_observe = true;
   HandleScope scope(CcTest::isolate());
   LocalContext context(CcTest::isolate());
   CompileRun("var obj = {};");
   Local<Value> instance = CompileRun("obj");
   {
     LocalContext context2(CcTest::isolate());
     context2->Global()
         ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("obj"),
               instance)
         .FromJust();
     CHECK(CompileRun("Object.getNotifier(obj)")->IsNull());
   }
 }
 
 
 TEST(GetNotifierFromOtherOrigin) {
+  i::FLAG_harmony_object_observe = true;
   HandleScope scope(CcTest::isolate());
   Local<Value> foo = v8_str("foo");
   Local<Value> bar = v8_str("bar");
   LocalContext context(CcTest::isolate());
   context->SetSecurityToken(foo);
   CompileRun("var obj = {};");
   Local<Value> instance = CompileRun("obj");
   {
     LocalContext context2(CcTest::isolate());
     context2->SetSecurityToken(bar);
     context2->Global()
         ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("obj"),
               instance)
         .FromJust();
     CHECK(CompileRun("Object.getNotifier(obj)")->IsNull());
   }
 }
 
 
 TEST(GetNotifierFromSameOrigin) {
+  i::FLAG_harmony_object_observe = true;
   HandleScope scope(CcTest::isolate());
   Local<Value> foo = v8_str("foo");
   LocalContext context(CcTest::isolate());
   context->SetSecurityToken(foo);
   CompileRun("var obj = {};");
   Local<Value> instance = CompileRun("obj");
   {
     LocalContext context2(CcTest::isolate());
     context2->SetSecurityToken(foo);
     context2->Global()
@@ skipping 31 matching lines @@
   CcTest::heap()->CollectAllGarbage(i::Heap::kMakeHeapIterableMask);
   int count = GetGlobalObjectsCount();
 #ifdef DEBUG
   if (count != expected) CcTest::heap()->TracePathToGlobal();
 #endif
   CHECK_EQ(expected, count);
 }
 
 
 TEST(DontLeakContextOnObserve) {
+  i::FLAG_harmony_object_observe = true;
   HandleScope scope(CcTest::isolate());
   Local<Value> foo = v8_str("foo");
   LocalContext context(CcTest::isolate());
   context->SetSecurityToken(foo);
   CompileRun("var obj = {};");
   Local<Value> object = CompileRun("obj");
   {
     HandleScope scope(CcTest::isolate());
     LocalContext context2(CcTest::isolate());
     context2->SetSecurityToken(foo);
     context2->Global()
         ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("obj"),
               object)
         .FromJust();
     CompileRun("function observer() {};"
                "Object.observe(obj, observer, ['foo', 'bar', 'baz']);"
                "Object.unobserve(obj, observer);");
   }
 
   CcTest::isolate()->ContextDisposedNotification();
   CheckSurvivingGlobalObjectsCount(0);
 }
 
 
 TEST(DontLeakContextOnGetNotifier) {
+  i::FLAG_harmony_object_observe = true;
   HandleScope scope(CcTest::isolate());
   Local<Value> foo = v8_str("foo");
   LocalContext context(CcTest::isolate());
   context->SetSecurityToken(foo);
   CompileRun("var obj = {};");
   Local<Value> object = CompileRun("obj");
   {
     HandleScope scope(CcTest::isolate());
     LocalContext context2(CcTest::isolate());
     context2->SetSecurityToken(foo);
     context2->Global()
         ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("obj"),
               object)
         .FromJust();
     CompileRun("Object.getNotifier(obj);");
   }
 
   CcTest::isolate()->ContextDisposedNotification();
   CheckSurvivingGlobalObjectsCount(0);
 }
 
 
 TEST(DontLeakContextOnNotifierPerformChange) {
+  i::FLAG_harmony_object_observe = true;
   HandleScope scope(CcTest::isolate());
   Local<Value> foo = v8_str("foo");
   LocalContext context(CcTest::isolate());
   context->SetSecurityToken(foo);
   CompileRun("var obj = {};");
   Local<Value> object = CompileRun("obj");
   Local<Value> notifier = CompileRun("Object.getNotifier(obj)");
   {
     HandleScope scope(CcTest::isolate());
     LocalContext context2(CcTest::isolate());
@@ skipping 17 matching lines @@
 }
 
 
 static void ObserverCallback(const FunctionCallbackInfo<Value>& args) {
   *static_cast<int*>(Local<External>::Cast(args.Data())->Value()) =
       Local<Array>::Cast(args[0])->Length();
 }
 
 
 TEST(ObjectObserveCallsCppFunction) {
+  i::FLAG_harmony_object_observe = true;
   Isolate* isolate = CcTest::isolate();
   HandleScope scope(isolate);
   LocalContext context(isolate);
   int numRecordsSent = 0;
   Local<Function> observer =
       Function::New(CcTest::isolate()->GetCurrentContext(), ObserverCallback,
                     External::New(isolate, &numRecordsSent))
           .ToLocalChecked();
   context->Global()
       ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("observer"),
             observer)
       .FromJust();
   CompileRun(
       "var obj = {};"
       "Object.observe(obj, observer);"
       "obj.foo = 1;"
       "obj.bar = 2;");
   CHECK_EQ(2, numRecordsSent);
 }
 
 
 TEST(ObjectObserveCallsFunctionTemplateInstance) {
+  i::FLAG_harmony_object_observe = true;
   Isolate* isolate = CcTest::isolate();
   HandleScope scope(isolate);
   LocalContext context(isolate);
   int numRecordsSent = 0;
   Local<FunctionTemplate> tmpl = FunctionTemplate::New(
       isolate, ObserverCallback, External::New(isolate, &numRecordsSent));
   Local<Function> function =
       tmpl->GetFunction(v8::Isolate::GetCurrent()->GetCurrentContext())
           .ToLocalChecked();
   context->Global()
@@ skipping 15 matching lines @@
 }
 
 
 static void AccessorSetter(Local<Name> property, Local<Value> value,
                            const PropertyCallbackInfo<void>& info) {
   info.GetReturnValue().SetUndefined();
 }
 
 
 TEST(APIAccessorsShouldNotNotify) {
+  i::FLAG_harmony_object_observe = true;
   Isolate* isolate = CcTest::isolate();
   HandleScope handle_scope(isolate);
   LocalContext context(isolate);
   Local<Object> object = Object::New(isolate);
   object->SetAccessor(v8::Isolate::GetCurrent()->GetCurrentContext(),
                       v8_str("accessor"), &AccessorGetter, &AccessorSetter)
       .FromJust();
   context->Global()
       ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("obj"),
             object)
@@ skipping 13 matching lines @@
 int* global_use_counts = NULL;
 
 void MockUseCounterCallback(v8::Isolate* isolate,
                             v8::Isolate::UseCounterFeature feature) {
   ++global_use_counts[feature];
 }
 }
 
 
 TEST(UseCountObjectObserve) {
+  i::FLAG_harmony_object_observe = true;
   i::Isolate* isolate = CcTest::i_isolate();
   i::HandleScope scope(isolate);
   LocalContext env;
   int use_counts[v8::Isolate::kUseCounterFeatureCount] = {};
   global_use_counts = use_counts;
   CcTest::isolate()->SetUseCounterCallback(MockUseCounterCallback);
   CompileRun(
       "var obj = {};"
       "Object.observe(obj, function(){})");
   CHECK_EQ(1, use_counts[v8::Isolate::kObjectObserve]);
   CompileRun(
       "var obj2 = {};"
       "Object.observe(obj2, function(){})");
   // Only counts the first use of observe in a given context.
   CHECK_EQ(1, use_counts[v8::Isolate::kObjectObserve]);
   {
     LocalContext env2;
     CompileRun(
         "var obj = {};"
         "Object.observe(obj, function(){})");
   }
   // Counts different contexts separately.
   CHECK_EQ(2, use_counts[v8::Isolate::kObjectObserve]);
 }
 
 
 TEST(UseCountObjectGetNotifier) {
+  i::FLAG_harmony_object_observe = true;
   i::Isolate* isolate = CcTest::i_isolate();
   i::HandleScope scope(isolate);
   LocalContext env;
   int use_counts[v8::Isolate::kUseCounterFeatureCount] = {};
   global_use_counts = use_counts;
   CcTest::isolate()->SetUseCounterCallback(MockUseCounterCallback);
   CompileRun("var obj = {}");
   CompileRun("Object.getNotifier(obj)");
   CHECK_EQ(1, use_counts[v8::Isolate::kObjectObserve]);
 }
 
 
 static bool NamedAccessCheckAlwaysAllow(Local<v8::Context> accessing_context,
                                         Local<v8::Object> accessed_object) {
   return true;
 }
 
 
 TEST(DisallowObserveAccessCheckedObject) {
+  i::FLAG_harmony_object_observe = true;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   LocalContext env;
   v8::Local<v8::ObjectTemplate> object_template =
       v8::ObjectTemplate::New(isolate);
   object_template->SetAccessCheckCallback(NamedAccessCheckAlwaysAllow);
   Local<Object> new_instance =
       object_template->NewInstance(
                          v8::Isolate::GetCurrent()->GetCurrentContext())
           .ToLocalChecked();
   env->Global()
       ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("obj"),
             new_instance)
       .FromJust();
   v8::TryCatch try_catch(isolate);
   CompileRun("Object.observe(obj, function(){})");
   CHECK(try_catch.HasCaught());
 }
 
 
 TEST(DisallowGetNotifierAccessCheckedObject) {
+  i::FLAG_harmony_object_observe = true;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   LocalContext env;
   v8::Local<v8::ObjectTemplate> object_template =
       v8::ObjectTemplate::New(isolate);
   object_template->SetAccessCheckCallback(NamedAccessCheckAlwaysAllow);
   Local<Object> new_instance =
       object_template->NewInstance(
                          v8::Isolate::GetCurrent()->GetCurrentContext())
           .ToLocalChecked();
   env->Global()
       ->Set(v8::Isolate::GetCurrent()->GetCurrentContext(), v8_str("obj"),
             new_instance)
       .FromJust();
   v8::TryCatch try_catch(isolate);
   CompileRun("Object.getNotifier(obj)");
   CHECK(try_catch.HasCaught());
 }