AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity
86e3d4ae56
v8/test/cctest/test-object-observe.cc
adamk@chromium.org ebd4b61f38 Add access check for observed objects 
This change is mostly straightforward: for 'normal' sorts of change records,
simply don't deliver a changeRecord to a given observer callback if an access
the callback's Context is not allowed to "GET" or "HAS" changeRecord.name on
changeRecord.object, or if ACCESS_KEYS is disallowed.

For 'splice' records, the question of whether to hand it to an observer is trickier, since
there are multiple properties involved, and multiple types of possible information leakage.
Given that access-checked objects are very rare (only two in Blink, Window and Location),
and that they are not normally used as Arrays, it seems better to simply not emit any splice
records for such objects rather than spending lots of logic to attempt to avoid information
leakage for something that may never happen.

BUG=v8:2778
R=rossberg@chromium.org

Review URL: https://codereview.chromium.org/22962009

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@16663 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2013-09-11 20:03:54 +00:00

718 lines
26 KiB
C++
Raw Blame History

// 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
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "v8.h"
#include "cctest.h"
using namespace v8;
namespace i = v8::internal;
namespace {
// Need to create a new isolate when FLAG_harmony_observation is on.
class HarmonyIsolate {
public:
HarmonyIsolate() {
i::FLAG_harmony_observation = true;
isolate_ = Isolate::New();
isolate_->Enter();
}
~HarmonyIsolate() {
isolate_->Exit();
isolate_->Dispose();
}
Isolate* GetIsolate() const { return isolate_; }
private:
Isolate* isolate_;
};
}
TEST(PerIsolateState) {
HarmonyIsolate isolate;
HandleScope scope(isolate.GetIsolate());
LocalContext context1;
CompileRun(
"var count = 0;"
"var calls = 0;"
"var observer = function(records) { count = records.length; calls++ };"
"var obj = {};"
"Object.observe(obj, observer);");
Handle<Value> observer = CompileRun("observer");
Handle<Value> obj = CompileRun("obj");
Handle<Value> notify_fun1 = CompileRun(
"(function() { obj.foo = 'bar'; })");
Handle<Value> notify_fun2;
{
LocalContext context2;
context2->Global()->Set(String::New("obj"), obj);
notify_fun2 = CompileRun(
"(function() { obj.foo = 'baz'; })");
}
Handle<Value> notify_fun3;
{
LocalContext context3;
context3->Global()->Set(String::New("obj"), obj);
notify_fun3 = CompileRun(
"(function() { obj.foo = 'bat'; })");
}
{
LocalContext context4;
context4->Global()->Set(String::New("observer"), observer);
context4->Global()->Set(String::New("fun1"), notify_fun1);
context4->Global()->Set(String::New("fun2"), notify_fun2);
context4->Global()->Set(String::New("fun3"), notify_fun3);
CompileRun("fun1(); fun2(); fun3(); Object.deliverChangeRecords(observer)");
}
CHECK_EQ(1, CompileRun("calls")->Int32Value());
CHECK_EQ(3, CompileRun("count")->Int32Value());
}
TEST(EndOfMicrotaskDelivery) {
HarmonyIsolate isolate;
HandleScope scope(isolate.GetIsolate());
LocalContext context;
CompileRun(
"var obj = {};"
"var count = 0;"
"var observer = function(records) { count = records.length };"
"Object.observe(obj, observer);"
"obj.foo = 'bar';");
CHECK_EQ(1, CompileRun("count")->Int32Value());
}
TEST(DeliveryOrdering) {
HarmonyIsolate isolate;
HandleScope scope(isolate.GetIsolate());
LocalContext context;
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);"
"Object.observe(obj1, observer2);"
"Object.observe(obj1, observer3);"
"obj1.foo = 'bar';");
CHECK_EQ(3, CompileRun("ordering.length")->Int32Value());
CHECK_EQ(1, CompileRun("ordering[0]")->Int32Value());
CHECK_EQ(2, CompileRun("ordering[1]")->Int32Value());
CHECK_EQ(3, CompileRun("ordering[2]")->Int32Value());
CompileRun(
"ordering = [];"
"Object.observe(obj2, observer3);"
"Object.observe(obj2, observer2);"
"Object.observe(obj2, observer1);"
"obj2.foo = 'baz'");
CHECK_EQ(3, CompileRun("ordering.length")->Int32Value());
CHECK_EQ(1, CompileRun("ordering[0]")->Int32Value());
CHECK_EQ(2, CompileRun("ordering[1]")->Int32Value());
CHECK_EQ(3, CompileRun("ordering[2]")->Int32Value());
}
TEST(DeliveryOrderingReentrant) {
HarmonyIsolate isolate;
HandleScope scope(isolate.GetIsolate());
LocalContext context;
CompileRun(
"var obj = {};"
"var reentered = false;"
"var ordering = [];"
"function observer1() { ordering.push(1); };"
"function observer2() {"
" if (!reentered) {"
" obj.foo = 'baz';"
" reentered = true;"
" }"
" ordering.push(2);"
"};"
"function observer3() { ordering.push(3); };"
"Object.observe(obj, observer1);"
"Object.observe(obj, observer2);"
"Object.observe(obj, observer3);"
"obj.foo = 'bar';");
CHECK_EQ(5, CompileRun("ordering.length")->Int32Value());
CHECK_EQ(1, CompileRun("ordering[0]")->Int32Value());
CHECK_EQ(2, CompileRun("ordering[1]")->Int32Value());
CHECK_EQ(3, CompileRun("ordering[2]")->Int32Value());
// Note that we re-deliver to observers 1 and 2, while observer3
// already received the second record during the first round.
CHECK_EQ(1, CompileRun("ordering[3]")->Int32Value());
CHECK_EQ(2, CompileRun("ordering[1]")->Int32Value());
}
TEST(DeliveryOrderingDeliverChangeRecords) {
HarmonyIsolate isolate;
HandleScope scope(isolate.GetIsolate());
LocalContext context;
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, CompileRun("ordering.length")->Int32Value());
// First, observer2 is called due to deliverChangeRecords
CHECK_EQ(2, CompileRun("ordering[0]")->Int32Value());
// Then, observer1 is called when the stack unwinds
CHECK_EQ(1, CompileRun("ordering[1]")->Int32Value());
// observer1's mutation causes both 1 and 2 to be reactivated,
// with 1 having priority.
CHECK_EQ(1, CompileRun("ordering[2]")->Int32Value());
CHECK_EQ(2, CompileRun("ordering[3]")->Int32Value());
}
TEST(ObjectHashTableGrowth) {
HarmonyIsolate isolate;
HandleScope scope(isolate.GetIsolate());
// Initializing this context sets up initial hash tables.
LocalContext context;
Handle<Value> obj = CompileRun("obj = {};");
Handle<Value> observer = CompileRun(
"var ran = false;"
"(function() { ran = true })");
{
// As does initializing this context.
LocalContext context2;
context2->Global()->Set(String::New("obj"), obj);
context2->Global()->Set(String::New("observer"), observer);
CompileRun(
"var objArr = [];"
// 100 objects should be enough to make the hash table grow
// (and thus relocate).
"for (var i = 0; i < 100; ++i) {"
" 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;
LocalContext context;
HandleScope scope(isolate.GetIsolate());
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) });"
"global.foo = 'hello';");
CHECK_EQ(1, CompileRun("records.length")->Int32Value());
CHECK(global_proxy->StrictEquals(CompileRun("records[0].object")));
// Detached, mutating the proxy has no effect.
context->DetachGlobal();
CompileRun("global.bar = 'goodbye';");
CHECK_EQ(1, CompileRun("records.length")->Int32Value());
// Mutating the global object directly still has an effect...
CompileRun("this.bar = 'goodbye';");
CHECK_EQ(2, CompileRun("records.length")->Int32Value());
CHECK(inner_global->StrictEquals(CompileRun("records[1].object")));
// Reattached, back to global proxy.
context->ReattachGlobal(global_proxy);
CompileRun("global.baz = 'again';");
CHECK_EQ(3, CompileRun("records.length")->Int32Value());
CHECK(global_proxy->StrictEquals(CompileRun("records[2].object")));
// Attached to a different context, should not leak mutations
// to the old context.
context->DetachGlobal();
{
LocalContext context2;
context2->DetachGlobal();
context2->ReattachGlobal(global_proxy);
CompileRun(
"var records2 = [];"
"Object.observe(this, function(r) { [].push.apply(records2, r) });"
"this.bat = 'context2';");
CHECK_EQ(1, CompileRun("records2.length")->Int32Value());
CHECK(global_proxy->StrictEquals(CompileRun("records2[0].object")));
}
CHECK_EQ(3, CompileRun("records.length")->Int32Value());
// Attaching by passing to Context::New
{
// Delegates to Context::New
LocalContext context3(NULL, Handle<ObjectTemplate>(), global_proxy);
CompileRun(
"var records3 = [];"
"Object.observe(this, function(r) { [].push.apply(records3, r) });"
"this.qux = 'context3';");
CHECK_EQ(1, CompileRun("records3.length")->Int32Value());
CHECK(global_proxy->StrictEquals(CompileRun("records3[0].object")));
}
CHECK_EQ(3, CompileRun("records.length")->Int32Value());
}
struct RecordExpectation {
Handle<Value> object;
const char* type;
const char* name;
Handle<Value> old_value;
};
// TODO(adamk): Use this helper elsewhere in this file.
static void ExpectRecords(Handle<Value> records,
const RecordExpectation expectations[],
int num) {
CHECK(records->IsArray());
Handle<Array> recordArray = records.As<Array>();
CHECK_EQ(num, static_cast<int>(recordArray->Length()));
for (int i = 0; i < num; ++i) {
Handle<Value> record = recordArray->Get(i);
CHECK(record->IsObject());
Handle<Object> recordObj = record.As<Object>();
CHECK(expectations[i].object->StrictEquals(
recordObj->Get(String::New("object"))));
CHECK(String::New(expectations[i].type)->Equals(
recordObj->Get(String::New("type"))));
if (strcmp("splice", expectations[i].type) != 0) {
CHECK(String::New(expectations[i].name)->Equals(
recordObj->Get(String::New("name"))));
if (!expectations[i].old_value.IsEmpty()) {
CHECK(expectations[i].old_value->Equals(
recordObj->Get(String::New("oldValue"))));
}
}
}
}
#define EXPECT_RECORDS(records, expectations) \
ExpectRecords(records, expectations, ARRAY_SIZE(expectations))
TEST(APITestBasicMutation) {
HarmonyIsolate isolate;
HandleScope scope(isolate.GetIsolate());
LocalContext context;
Handle<Object> obj = Handle<Object>::Cast(CompileRun(
"var records = [];"
"var obj = {};"
"function observer(r) { [].push.apply(records, r); };"
"Object.observe(obj, observer);"
"obj"));
obj->Set(String::New("foo"), Number::New(7));
obj->Set(1, Number::New(2));
// ForceSet should work just as well as Set
obj->ForceSet(String::New("foo"), Number::New(3));
obj->ForceSet(Number::New(1), Number::New(4));
// Setting an indexed element via the property setting method
obj->Set(Number::New(1), Number::New(5));
// Setting with a non-String, non-uint32 key
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>() },
// 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) }
};
EXPECT_RECORDS(CompileRun("records"), expected_records);
}
TEST(HiddenPrototypeObservation) {
HarmonyIsolate isolate;
HandleScope scope(isolate.GetIsolate());
LocalContext context;
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) }
};
EXPECT_RECORDS(CompileRun("records"), expected_records);
obj->SetPrototype(Null());
CompileRun("obj.foo = 43");
const RecordExpectation expected_records2[] = {
{ obj, "new", "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>() }
// 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 int NumberOfElements(i::Handle<i::JSWeakMap> map) {
return i::ObjectHashTable::cast(map->table())->NumberOfElements();
}
TEST(ObservationWeakMap) {
HarmonyIsolate isolate;
HandleScope scope(isolate.GetIsolate());
LocalContext context;
CompileRun(
"var obj = {};"
"Object.observe(obj, function(){});"
"Object.getNotifier(obj);"
"obj = null;");
i::Handle<i::JSObject> observation_state =
i::Isolate::Current()->factory()->observation_state();
i::Handle<i::JSWeakMap> callbackInfoMap =
i::Handle<i::JSWeakMap>::cast(
i::GetProperty(observation_state, "callbackInfoMap"));
i::Handle<i::JSWeakMap> objectInfoMap =
i::Handle<i::JSWeakMap>::cast(
i::GetProperty(observation_state, "objectInfoMap"));
i::Handle<i::JSWeakMap> notifierObjectInfoMap =
i::Handle<i::JSWeakMap>::cast(
i::GetProperty(observation_state, "notifierObjectInfoMap"));
CHECK_EQ(1, NumberOfElements(callbackInfoMap));
CHECK_EQ(1, NumberOfElements(objectInfoMap));
CHECK_EQ(1, NumberOfElements(notifierObjectInfoMap));
HEAP->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask);
CHECK_EQ(0, NumberOfElements(callbackInfoMap));
CHECK_EQ(0, NumberOfElements(objectInfoMap));
CHECK_EQ(0, NumberOfElements(notifierObjectInfoMap));
}
static bool NamedAccessAlwaysAllowed(Local<Object>, Local<Value>, AccessType,
Local<Value>) {
return true;
}
static bool IndexedAccessAlwaysAllowed(Local<Object>, uint32_t, AccessType,
Local<Value>) {
return true;
}
static AccessType g_access_block_type = ACCESS_GET;
static bool NamedAccessAllowUnlessBlocked(Local<Object> host,
Local<Value> key,
AccessType type,
Local<Value>) {
if (type != g_access_block_type) return true;
Handle<Object> global = Context::GetCurrent()->Global();
Handle<Value> blacklist = global->Get(String::New("blacklist"));
if (!blacklist->IsObject()) return true;
if (key->IsString()) return !blacklist.As<Object>()->Has(key);
return true;
}
static bool IndexedAccessAllowUnlessBlocked(Local<Object> host,
uint32_t index,
AccessType type,
Local<Value>) {
if (type != ACCESS_GET) return true;
Handle<Object> global = Context::GetCurrent()->Global();
Handle<Value> blacklist = global->Get(String::New("blacklist"));
if (!blacklist->IsObject()) return true;
return !blacklist.As<Object>()->Has(index);
}
static bool BlockAccessKeys(Local<Object> host, Local<Value> key,
AccessType type, Local<Value>) {
Handle<Object> global = Context::GetCurrent()->Global();
Handle<Value> blacklist = global->Get(String::New("blacklist"));
if (!blacklist->IsObject()) return true;
return type != ACCESS_KEYS ||
!blacklist.As<Object>()->Has(String::New("__block_access_keys"));
}
static Handle<Object> CreateAccessCheckedObject(
NamedSecurityCallback namedCallback,
IndexedSecurityCallback indexedCallback) {
Handle<ObjectTemplate> tmpl = ObjectTemplate::New();
tmpl->SetAccessCheckCallbacks(namedCallback, indexedCallback);
Handle<Object> instance = tmpl->NewInstance();
instance->CreationContext()->Global()->Set(String::New("obj"), instance);
return instance;
}
TEST(NamedAccessCheck) {
HarmonyIsolate isolate;
const AccessType types[] = { ACCESS_GET, ACCESS_HAS };
for (size_t i = 0; i < ARRAY_SIZE(types); ++i) {
HandleScope scope(isolate.GetIsolate());
LocalContext context;
g_access_block_type = types[i];
Handle<Object> instance = CreateAccessCheckedObject(
NamedAccessAllowUnlessBlocked, IndexedAccessAlwaysAllowed);
CompileRun("var records = null;"
"var objNoCheck = {};"
"var blacklist = {foo: true};"
"var observer = function(r) { records = r };"
"Object.observe(obj, observer);"
"Object.observe(objNoCheck, observer);");
Handle<Value> obj_no_check = CompileRun("objNoCheck");
{
LocalContext context2;
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';"
"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>() },
};
EXPECT_RECORDS(CompileRun("records2"), expected_records2);
}
const RecordExpectation expected_records[] = {
{ instance, "new", "bar", Handle<Value>() },
{ obj_no_check, "new", "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) {
HandleScope scope(isolate.GetIsolate());
LocalContext context;
g_access_block_type = types[i];
Handle<Object> instance = CreateAccessCheckedObject(
NamedAccessAlwaysAllowed, IndexedAccessAllowUnlessBlocked);
CompileRun("var records = null;"
"var objNoCheck = {};"
"var blacklist = {7: true};"
"var observer = function(r) { records = r };"
"Object.observe(obj, observer);"
"Object.observe(objNoCheck, observer);");
Handle<Value> obj_no_check = CompileRun("objNoCheck");
{
LocalContext context2;
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[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>() }
};
EXPECT_RECORDS(CompileRun("records2"), expected_records2);
}
const RecordExpectation expected_records[] = {
{ instance, "new", "8", Handle<Value>() },
{ obj_no_check, "new", "42", Handle<Value>() }
};
EXPECT_RECORDS(CompileRun("records"), expected_records);
}
}
TEST(SpliceAccessCheck) {
HarmonyIsolate isolate;
HandleScope scope(isolate.GetIsolate());
LocalContext context;
g_access_block_type = ACCESS_GET;
Handle<Object> instance = CreateAccessCheckedObject(
NamedAccessAlwaysAllowed, IndexedAccessAllowUnlessBlocked);
CompileRun("var records = null;"
"obj[1] = 'foo';"
"obj.length = 2;"
"var objNoCheck = {1: 'bar', length: 2};"
"var blacklist = {1: true};"
"observer = function(r) { records = r };"
"Array.observe(obj, observer);"
"Array.observe(objNoCheck, observer);");
Handle<Value> obj_no_check = CompileRun("objNoCheck");
{
LocalContext context2;
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 };"
"Array.observe(obj, observer2);"
"Array.observe(objNoCheck, observer2);"
// No one should hear about this: no splice records are emitted
// for access-checked objects
"[].push.call(obj, 5);"
"[].splice.call(obj, 1, 1);"
"[].pop.call(obj);"
"[].pop.call(objNoCheck);");
// TODO(adamk): Extend EXPECT_RECORDS to be able to assert more things
// about splice records. For this test it's not so important since
// we just want to guarantee the machinery is in operation at all.
const RecordExpectation expected_records2[] = {
{ obj_no_check, "splice", "", Handle<Value>() }
};
EXPECT_RECORDS(CompileRun("records2"), expected_records2);
}
const RecordExpectation expected_records[] = {
{ obj_no_check, "splice", "", Handle<Value>() }
};
EXPECT_RECORDS(CompileRun("records"), expected_records);
}
TEST(DisallowAllForAccessKeys) {
HarmonyIsolate isolate;
HandleScope scope(isolate.GetIsolate());
LocalContext context;
Handle<Object> instance = CreateAccessCheckedObject(
BlockAccessKeys, IndexedAccessAlwaysAllowed);
CompileRun("var records = null;"
"var objNoCheck = {};"
"var observer = function(r) { records = r };"
"var blacklist = {__block_access_keys: true};"
"Object.observe(obj, observer);"
"Object.observe(objNoCheck, observer);");
Handle<Value> obj_no_check = CompileRun("objNoCheck");
{
LocalContext context2;
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>() },
};
EXPECT_RECORDS(CompileRun("records2"), expected_records2);
}
const RecordExpectation expected_records[] = {
{ obj_no_check, "new", "baz", Handle<Value>() }
};
EXPECT_RECORDS(CompileRun("records"), expected_records);
}
TEST(AccessCheckDisallowApiModifications) {
HarmonyIsolate isolate;
HandleScope scope(isolate.GetIsolate());
LocalContext context;
Handle<Object> instance = CreateAccessCheckedObject(
BlockAccessKeys, IndexedAccessAlwaysAllowed);
CompileRun("var records = null;"
"var observer = function(r) { records = r };"
"var blacklist = {__block_access_keys: true};"
"Object.observe(obj, observer);");
{
LocalContext context2;
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>() }
};
EXPECT_RECORDS(CompileRun("records2"), expected_records2);
}
CHECK(CompileRun("records")->IsNull());
}
Reference in New Issue View Git Blame Copy Permalink