[es6] silence access-check failure for well-known symbol properties

test/cctest/test-api.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 21837 matching lines @@
       "    fake.age;\n"
       "    result = 1;\n"
       "  } catch (e) {\n"
       "  }\n"
       "  test(d+1);\n"
       "}\n"
       "test(0);\n"
       "result;\n",
       0);
 }
+
+
+static bool AccessSymbolsAlwaysBlocked(Local<v8::Object> global,
+                                       Local<Value> name, v8::AccessType type,
+                                       Local<Value> data) {
+  if (!name->IsSymbol()) return true;

[Toon Verwaest, 2015/07/10 13:22:16]

Access checks are in the process of being rewritten to not get anything in but
the receiver and the context from which access is requested. At this point type
is already *always* ACCESS_HAS and "name" is *always* undefined. Hence this
IsSymbol check makes no sense.

Access checks shouldn't be finegrained, and cannot partially allow access (minus
some really internal things like hash-codes). Either you have access from the
current context to an object, or you don't.

+  i::PrintF("Access blocked.\n");
+  return false;
+}
+
+
+THREADED_TEST(Regress507553) {
+  v8::Isolate* isolate = CcTest::isolate();
+  HandleScope scope(isolate);
+
+  // Template for object with security check.
+  Local<ObjectTemplate> spreadable_template = v8::ObjectTemplate::New(isolate);
+  spreadable_template->SetAccessCheckCallbacks(AccessSymbolsAlwaysBlocked,
+                                               NULL);
+
+  // Context for "foreign" objects used in test.
+  Local<Context> context = v8::Context::New(isolate);
+  context->Enter();
+
+  // Object with explicit security check.
+  Local<Object> protected_object = spreadable_template->NewInstance();
+
+  spreadable_template->Set(v8::Symbol::GetIsConcatSpreadable(isolate),
+                           v8::Boolean::New(isolate, true));
+
+  protected_object->Set(v8_str("length"), v8::Integer::New(isolate, 2));
+  protected_object->Set(0U, v8_str("a"));
+  protected_object->Set(1U, v8_str("b"));
+
+  Local<ObjectTemplate> global_template = ObjectTemplate::New(isolate);
+  global_template->Set(v8_str("protected"), protected_object);
+
+  context->Exit();
+
+  LocalContext context2(NULL, global_template);
+
+  Local<Value> result1 = CompileRun("[].concat(protected)");
+  CHECK(result1->IsArray());
+  CHECK(result1.As<Object>()->Get(0)->Equals(protected_object));
+}