Add API for access checks on observed objects

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 201 matching lines @@
         "  objArr.push({});"
         "  Object.observe(objArr[objArr.length-1], function(){});"
         "}"
         "Object.observe(obj, observer);");
   }
   // obj is now marked "is_observed", but our map has moved.
   CompileRun("obj.foo = 'bar'");
   CHECK(CompileRun("ran")->BooleanValue());
 }
 
+
 TEST(GlobalObjectObservation) {
   HarmonyIsolate isolate;
   HandleScope scope;
   LocalContext context;
   Handle<Object> global_proxy = context->Global();
   Handle<Object> inner_global = global_proxy->GetPrototype().As<Object>();
   CompileRun(
       "var records = [];"
       "var global = this;"
       "Object.observe(global, function(r) { [].push.apply(records, r) });"
@@ skipping 158 matching lines @@
       "Object.unobserve(obj, observer);"
       "obj.foo = 44;");
   const RecordExpectation expected_records3[] = {
     { proto, "new", "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) }
   };
   EXPECT_RECORDS(CompileRun("records"), expected_records3);
 }
+
+
+static bool NamedAccessAlwaysAllowed(Local<Object> host, Local<Value> key,
+                                     AccessType type, Local<Value> data) {
+  return true;
+}
+
+static bool IndexedAccessAlwaysAllowed(Local<Object> host, uint32_t index,
+                                       AccessType type, Local<Value> data) {
+  return true;
+}
+
+static bool ObservationAlwaysDisallowed(Local<Object> host, Local<Value> data) {
+  return false;
+}
+
+TEST(ObserveWithAccessChecks) {
+  HarmonyIsolate isolate;
+  HandleScope scope;
+  LocalContext context;
+  Handle<ObjectTemplate> tmpl = ObjectTemplate::New();
+  tmpl->SetAccessCheckCallbacks(NamedAccessAlwaysAllowed,
+                                IndexedAccessAlwaysAllowed,
+                                ObservationAlwaysDisallowed);
+  Handle<Object> instance = tmpl->NewInstance();
+  context->Global()->Set(String::New("obj"), instance);
+  TryCatch try_catch;
+  CompileRun("var records = null;"
+             "Object.observe(obj, function(r) { records = r });");
+  CHECK(try_catch.HasCaught());
+  CompileRun("obj.foo = 'bar'");
+  CHECK(CompileRun("records")->IsNull());
+}
+
+TEST(ObserveWithAccessChecksDeprecatedAPI) {
+  HarmonyIsolate isolate;
+  HandleScope scope;
+  LocalContext context;
+  Handle<ObjectTemplate> tmpl = ObjectTemplate::New();
+  tmpl->SetAccessCheckCallbacks(NamedAccessAlwaysAllowed,
+                                IndexedAccessAlwaysAllowed);
+  Handle<Object> instance = tmpl->NewInstance();
+  context->Global()->Set(String::New("obj"), instance);
+  TryCatch try_catch;
+  CompileRun("var records = null;"
+             "Object.observe(obj, function(r) { records = r });");
+  CHECK(try_catch.HasCaught());
+  CompileRun("obj.foo = 'bar'");
+  CHECK(CompileRun("records")->IsNull());
+}