[Object.observe] rename intrinsic change record types for consitency.

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 338 matching lines @@
   obj->Set(Number::New(1.1), Number::New(6), DontDelete);
   obj->Delete(String::New("foo"));
   obj->Delete(1);
   obj->ForceDelete(Number::New(1.1));
 
   // Force delivery
   // TODO(adamk): Should the above set methods trigger delivery themselves?
   CompileRun("void 0");
   CHECK_EQ(9, CompileRun("records.length")->Int32Value());
   const RecordExpectation expected_records[] = {
-    { obj, "new", "foo", Handle<Value>() },
-    { obj, "new", "1", Handle<Value>() },
+    { obj, "add", "foo", Handle<Value>() },
+    { obj, "add", "1", Handle<Value>() },
     // Note: use 7 not 1 below, as the latter triggers a nifty VS10 compiler bug
     // where instead of 1.0, a garbage value would be passed into Number::New.
-    { obj, "updated", "foo", Number::New(7) },
-    { obj, "updated", "1", Number::New(2) },
-    { obj, "updated", "1", Number::New(4) },
-    { obj, "new", "1.1", Handle<Value>() },
-    { obj, "deleted", "foo", Number::New(3) },
-    { obj, "deleted", "1", Number::New(5) },
-    { obj, "deleted", "1.1", Number::New(6) }
+    { obj, "update", "foo", Number::New(7) },
+    { obj, "update", "1", Number::New(2) },
+    { obj, "update", "1", Number::New(4) },
+    { obj, "add", "1.1", Handle<Value>() },
+    { obj, "delete", "foo", Number::New(3) },
+    { obj, "delete", "1", Number::New(5) },
+    { obj, "delete", "1.1", Number::New(6) }
   };
   EXPECT_RECORDS(CompileRun("records"), expected_records);
 }
 
 
 TEST(HiddenPrototypeObservation) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
   LocalContext context(isolate.GetIsolate());
   Handle<FunctionTemplate> tmpl = FunctionTemplate::New();
   tmpl->SetHiddenPrototype(true);
   tmpl->InstanceTemplate()->Set(String::New("foo"), Number::New(75));
   Handle<Object> proto = tmpl->GetFunction()->NewInstance();
   Handle<Object> obj = Object::New();
   obj->SetPrototype(proto);
   context->Global()->Set(String::New("obj"), obj);
   context->Global()->Set(String::New("proto"), proto);
   CompileRun(
       "var records;"
       "function observer(r) { records = r; };"
       "Object.observe(obj, observer);"
       "obj.foo = 41;"  // triggers a notification
       "proto.foo = 42;");  // does not trigger a notification
   const RecordExpectation expected_records[] = {
-    { obj, "updated", "foo", Number::New(75) }
+    { obj, "update", "foo", Number::New(75) }
   };
   EXPECT_RECORDS(CompileRun("records"), expected_records);
   obj->SetPrototype(Null(isolate.GetIsolate()));
   CompileRun("obj.foo = 43");
   const RecordExpectation expected_records2[] = {
-    { obj, "new", "foo", Handle<Value>() }
+    { obj, "add", "foo", Handle<Value>() }
   };
   EXPECT_RECORDS(CompileRun("records"), expected_records2);
   obj->SetPrototype(proto);
   CompileRun(
       "Object.observe(proto, observer);"
       "proto.bar = 1;"
       "Object.unobserve(obj, observer);"
       "obj.foo = 44;");
   const RecordExpectation expected_records3[] = {
-    { proto, "new", "bar", Handle<Value>() }
+    { proto, "add", "bar", Handle<Value>() }
     // TODO(adamk): The below record should be emitted since proto is observed
     // and has been modified. Not clear if this happens in practice.
-    // { proto, "updated", "foo", Number::New(43) }
+    // { proto, "update", "foo", Number::New(43) }
   };
   EXPECT_RECORDS(CompileRun("records"), expected_records3);
 }
 
 
 static int NumberOfElements(i::Handle<i::JSWeakMap> map) {
   return i::ObjectHashTable::cast(map->table())->NumberOfElements();
 }
 
 
@@ skipping 117 matching lines @@
       CompileRun("var records2 = null;"
                  "var observer2 = function(r) { records2 = r };"
                  "Object.observe(obj, observer2);"
                  "Object.observe(objNoCheck, observer2);"
                  "obj.foo = 'bar';"
                  "Object.defineProperty(obj, 'foo', {value: 5});"
                  "Object.defineProperty(obj, 'foo', {get: function(){}});"
                  "obj.bar = 'baz';"
                  "objNoCheck.baz = 'quux'");
       const RecordExpectation expected_records2[] = {
-        { instance, "new", "foo", Handle<Value>() },
-        { instance, "updated", "foo", String::New("bar") },
-        { instance, "reconfigured", "foo", Number::New(5) },
-        { instance, "new", "bar", Handle<Value>() },
-        { obj_no_check, "new", "baz", Handle<Value>() },
+        { instance, "add", "foo", Handle<Value>() },
+        { instance, "update", "foo", String::New("bar") },
+        { instance, "reconfigure", "foo", Number::New(5) },
+        { instance, "add", "bar", Handle<Value>() },
+        { obj_no_check, "add", "baz", Handle<Value>() },
       };
       EXPECT_RECORDS(CompileRun("records2"), expected_records2);
     }
     const RecordExpectation expected_records[] = {
-      { instance, "new", "bar", Handle<Value>() },
-      { obj_no_check, "new", "baz", Handle<Value>() }
+      { instance, "add", "bar", Handle<Value>() },
+      { obj_no_check, "add", "baz", Handle<Value>() }
     };
     EXPECT_RECORDS(CompileRun("records"), expected_records);
   }
 }
 
 
 TEST(IndexedAccessCheck) {
   HarmonyIsolate isolate;
   const AccessType types[] = { ACCESS_GET, ACCESS_HAS };
   for (size_t i = 0; i < ARRAY_SIZE(types); ++i) {
@@ skipping 16 matching lines @@
       CompileRun("var records2 = null;"
                  "var observer2 = function(r) { records2 = r };"
                  "Object.observe(obj, observer2);"
                  "Object.observe(objNoCheck, observer2);"
                  "obj[7] = 'foo';"
                  "Object.defineProperty(obj, '7', {value: 5});"
                  "Object.defineProperty(obj, '7', {get: function(){}});"
                  "obj[8] = 'bar';"
                  "objNoCheck[42] = 'quux'");
       const RecordExpectation expected_records2[] = {
-        { instance, "new", "7", Handle<Value>() },
-        { instance, "updated", "7", String::New("foo") },
-        { instance, "reconfigured", "7", Number::New(5) },
-        { instance, "new", "8", Handle<Value>() },
-        { obj_no_check, "new", "42", Handle<Value>() }
+        { instance, "add", "7", Handle<Value>() },
+        { instance, "update", "7", String::New("foo") },
+        { instance, "reconfigure", "7", Number::New(5) },
+        { instance, "add", "8", Handle<Value>() },
+        { obj_no_check, "add", "42", Handle<Value>() }
       };
       EXPECT_RECORDS(CompileRun("records2"), expected_records2);
     }
     const RecordExpectation expected_records[] = {
-      { instance, "new", "8", Handle<Value>() },
-      { obj_no_check, "new", "42", Handle<Value>() }
+      { instance, "add", "8", Handle<Value>() },
+      { obj_no_check, "add", "42", Handle<Value>() }
     };
     EXPECT_RECORDS(CompileRun("records"), expected_records);
   }
 }
 
 
 TEST(SpliceAccessCheck) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
   LocalContext context(isolate.GetIsolate());
@@ skipping 55 matching lines @@
     context2->Global()->Set(String::New("obj"), instance);
     context2->Global()->Set(String::New("objNoCheck"), obj_no_check);
     CompileRun("var records2 = null;"
                "var observer2 = function(r) { records2 = r };"
                "Object.observe(obj, observer2);"
                "Object.observe(objNoCheck, observer2);"
                "obj.foo = 'bar';"
                "obj[5] = 'baz';"
                "objNoCheck.baz = 'quux'");
     const RecordExpectation expected_records2[] = {
-      { instance, "new", "foo", Handle<Value>() },
-      { instance, "new", "5", Handle<Value>() },
-      { obj_no_check, "new", "baz", Handle<Value>() },
+      { instance, "add", "foo", Handle<Value>() },
+      { instance, "add", "5", Handle<Value>() },
+      { obj_no_check, "add", "baz", Handle<Value>() },
     };
     EXPECT_RECORDS(CompileRun("records2"), expected_records2);
   }
   const RecordExpectation expected_records[] = {
-    { obj_no_check, "new", "baz", Handle<Value>() }
+    { obj_no_check, "add", "baz", Handle<Value>() }
   };
   EXPECT_RECORDS(CompileRun("records"), expected_records);
 }
 
 
 TEST(AccessCheckDisallowApiModifications) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
   LocalContext context(isolate.GetIsolate());
   Handle<Object> instance = CreateAccessCheckedObject(
       BlockAccessKeys, IndexedAccessAlwaysAllowed);
   CompileRun("var records = null;"
              "var observer = function(r) { records = r };"
              "Object.observe(obj, observer);");
   {
     LocalContext context2(isolate.GetIsolate());
     context2->Global()->Set(String::New("obj"), instance);
     CompileRun("var records2 = null;"
                "var observer2 = function(r) { records2 = r };"
                "Object.observe(obj, observer2);");
     instance->Set(5, String::New("bar"));
     instance->Set(String::New("foo"), String::New("bar"));
     CompileRun("");  // trigger delivery
     const RecordExpectation expected_records2[] = {
-      { instance, "new", "5", Handle<Value>() },
-      { instance, "new", "foo", Handle<Value>() }
+      { instance, "add", "5", Handle<Value>() },
+      { instance, "add", "foo", Handle<Value>() }
     };
     EXPECT_RECORDS(CompileRun("records2"), expected_records2);
   }
   CHECK(CompileRun("records")->IsNull());
 }
 
 
 TEST(HiddenPropertiesLeakage) {
   HarmonyIsolate isolate;
   HandleScope scope(isolate.GetIsolate());
   LocalContext context(isolate.GetIsolate());
   CompileRun("var obj = {};"
              "var records = null;"
              "var observer = function(r) { records = r };"
              "Object.observe(obj, observer);");
   Handle<Value> obj = context->Global()->Get(String::New("obj"));
   Handle<Object>::Cast(obj)->SetHiddenValue(String::New("foo"), Null());
   CompileRun("");  // trigger delivery
   CHECK(CompileRun("records")->IsNull());
 }