[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;
+  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();
+
+  // JSGlobalProxy object, always have security check.
+  Local<Object> proxy_object = context->Global();
+
+  // Global object, the  prototype of proxy_object. No security checks.
+  Local<Object> global_object = proxy_object->GetPrototype()->ToObject(isolate);
+
+  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);
+  global_template->Set(v8_str("global"), global_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));
+
+  Local<Value> result2 = CompileRun("[].concat([global], global, protected)");
+  CHECK(result2->IsArray());
+  CHECK(result2.As<Object>()->Get(0)->Equals(global_object));
+  CHECK(result2.As<Object>()->Get(1)->Equals(global_object));
+  CHECK(result2.As<Object>()->Get(2)->Equals(protected_object));
+}