Split window support from V8. ...

test/cctest/test-api.cc

 // Copyright 2007-2008 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 969 matching lines @@
 
   // Indexed and named deleter.
   Script::Compile(v8_str("delete obj[0]"))->Run();
   Script::Compile(v8_str("delete obj.x"))->Run();
 
   // Enumerators.
   Script::Compile(v8_str("for (var p in obj) ;"))->Run();
 }
 
 
-v8::Handle<Value> pre_post_global;
-
 static v8::Handle<Value> PrePropertyHandlerGet(Local<String> key,
                                                const AccessorInfo& info) {
   ApiTestFuzzer::Fuzz();
-  CHECK(info.This()->Equals(pre_post_global));
-  CHECK(info.Holder()->Equals(pre_post_global));
   if (v8_str("pre")->Equals(key)) {
     return v8_str("PrePropertyHandler: pre");
   }
   return v8::Handle<String>();
 }
 
 
 static v8::Handle<v8::Boolean> PrePropertyHandlerHas(Local<String> key,
                                                      const AccessorInfo&) {
   if (v8_str("pre")->Equals(key)) {
     return v8::True();
   }
 
   return v8::Handle<v8::Boolean>();  // do not intercept the call
 }
 
 
 THREADED_TEST(PrePropertyHandler) {
   v8::HandleScope scope;
   v8::Handle<v8::FunctionTemplate> desc = v8::FunctionTemplate::New();
   desc->InstanceTemplate()->SetNamedPropertyHandler(PrePropertyHandlerGet,
                                                     0,
                                                     PrePropertyHandlerHas);
   LocalContext env(NULL, desc->InstanceTemplate());
-  pre_post_global = env->Global();
   Script::Compile(v8_str(
       "var pre = 'Object: pre'; var on = 'Object: on';"))->Run();
   v8::Handle<Value> result_pre = Script::Compile(v8_str("pre"))->Run();
   CHECK_EQ(v8_str("PrePropertyHandler: pre"), result_pre);
   v8::Handle<Value> result_on = Script::Compile(v8_str("on"))->Run();
   CHECK_EQ(v8_str("Object: on"), result_on);
   v8::Handle<Value> result_post = Script::Compile(v8_str("post"))->Run();
   CHECK(result_post.IsEmpty());
 }
 
@@ skipping 126 matching lines @@
   Foo->PrototypeTemplate()->Set(v8_str("plak"), v8_num(321));
   LocalContext env;
   env->Global()->Set(v8_str("Foo"), Foo->GetFunction());
   Local<Script> script = Script::Compile(v8_str("Foo.prototype.plak"));
   CHECK_EQ(script->Run()->Int32Value(), 321);
 }
 
 
 THREADED_TEST(InternalFields) {
   v8::HandleScope scope;
+  LocalContext env;
+
   Local<v8::FunctionTemplate> templ = v8::FunctionTemplate::New();
   Local<v8::ObjectTemplate> instance_templ = templ->InstanceTemplate();
   instance_templ->SetInternalFieldCount(1);
-  LocalContext env(0, instance_templ);
-  CHECK_EQ(1, env->Global()->InternalFieldCount());
-
   Local<v8::Object> obj = templ->GetFunction()->NewInstance();
   CHECK_EQ(1, obj->InternalFieldCount());
   CHECK(obj->GetInternalField(0)->IsUndefined());
   obj->SetInternalField(0, v8_num(17));
   CHECK_EQ(17, obj->GetInternalField(0)->Int32Value());
 }
 
 
 THREADED_TEST(External) {
   v8::HandleScope scope;
@@ skipping 1870 matching lines @@
 
   // Set to the same domain.
   env1->SetSecurityToken(foo);
 
   // Create a function in env1.
   Script::Compile(v8_str("spy=function(){return spy;}"))->Run();
   Local<Value> spy = env1->Global()->Get(v8_str("spy"));
   CHECK(spy->IsFunction());
 
   // Create another function accessing global objects.
-  Script::Compile(v8_str("spy2=function(){return new Array();}"))->Run();
+  Script::Compile(v8_str("spy2=function(){return new this.Array();}"))->Run();
   Local<Value> spy2 = env1->Global()->Get(v8_str("spy2"));
   CHECK(spy2->IsFunction());
 
   // Switch to env2 in the same domain and invoke spy on env2.
   {
     env2->SetSecurityToken(foo);
     // Enter env2
     Context::Scope scope_env2(env2);
     Local<Value> result = Function::Cast(*spy)->Call(env2->Global(), 0, NULL);
     CHECK(result->IsFunction());
   }
 
-  // Change env2 to a new domain and invoke spy on env2. It should be blocked
-  // by security check.
   {
     env2->SetSecurityToken(bar);
     Context::Scope scope_env2(env2);
-    Local<Value> result = Function::Cast(*spy)->Call(env2->Global(), 0, NULL);
-    CHECK(result->IsUndefined());
 
     // Call cross_domain_call, it should throw an exception
     v8::TryCatch try_catch;
     Function::Cast(*spy2)->Call(env2->Global(), 0, NULL);
     CHECK(try_catch.HasCaught());
   }
 
   env2.Dispose();
 }
 
@@ skipping 126 matching lines @@
         CompileRun("(function(){var obj = {'__proto__':env1};"
                    "for (var p in obj)"
                    "   if (p == 'prop') return false;"
                    "return true;})()");
     CHECK(result->IsTrue());
   }
   env2.Dispose();
 }
 
 
+TEST(ContextDetachGlobal) {
+  v8::HandleScope handle_scope;
+  LocalContext env1;
+  v8::Persistent<Context> env2 = Context::New();
+
+  Local<v8::Object> global1 = env1->Global();
+
+  Local<Value> foo = v8_str("foo");
+
+  // Set to the same domain.
+  env1->SetSecurityToken(foo);
+  env2->SetSecurityToken(foo);
+
+  // Enter env2
+  env2->Enter();
+
+  // Create a function in env1
+  Local<v8::Object> global2 = env2->Global();
+  global2->Set(v8_str("prop"), v8::Integer::New(1));
+  CompileRun("function getProp() {return prop;}");
+
+  env1->Global()->Set(v8_str("getProp"),
+                      global2->Get(v8_str("getProp")));
+
+  // Detach env1's global, and reuse the global object of env1
+  env2->Exit();
+  env2->DetachGlobal();
+  // env2 has a new global object.
+  CHECK(!env2->Global()->Equals(global2));
+
+  v8::Persistent<Context> env3 =
+      Context::New(0, v8::Handle<v8::ObjectTemplate>(), global2);
+  env3->SetSecurityToken(v8_str("bar"));
+  env3->Enter();
+
+  Local<v8::Object> global3 = env3->Global();
+  CHECK_EQ(global2, global3);
+  CHECK(global3->Get(v8_str("prop"))->IsUndefined());
+  CHECK(global3->Get(v8_str("getProp"))->IsUndefined());
+  global3->Set(v8_str("prop"), v8::Integer::New(-1));
+  global3->Set(v8_str("prop2"), v8::Integer::New(2));
+  env3->Exit();
+
+  // Call getProp in env1, and it should return the value 1
+  {
+    Local<Value> get_prop = global1->Get(v8_str("getProp"));
+    CHECK(get_prop->IsFunction());
+    v8::TryCatch try_catch;
+    Local<Value> r = Function::Cast(*get_prop)->Call(global1, 0, NULL);
+    CHECK(!try_catch.HasCaught());
+    CHECK_EQ(1, r->Int32Value());
+  }
+
+  // Check that env3 is not accessible from env1
+  {
+    Local<Value> r = global3->Get(v8_str("prop2"));
+    CHECK(r->IsUndefined());    
+  }
+
+  env2.Dispose();
+  env3.Dispose();
+}
+
+
 static bool NamedAccessBlocker(Local<v8::Object> global,
                                Local<Value> name,
                                v8::AccessType type,
                                Local<Value> data) {
-  return Context::GetCurrentSecurityContext()->Global()->Equals(global);
+  return Context::GetCurrent()->Global()->Equals(global);
 }
 
 
 static bool IndexedAccessBlocker(Local<v8::Object> global,
                                  uint32_t key,
                                  v8::AccessType type,
                                  Local<Value> data) {
-  return Context::GetCurrentSecurityContext()->Global()->Equals(global);
+  return Context::GetCurrent()->Global()->Equals(global);
 }
 
 
 static int g_echo_value = -1;
 static v8::Handle<Value> EchoGetter(Local<String> name,
                                     const AccessorInfo& info) {
   return v8_num(g_echo_value);
 }
 
 
 static void EchoSetter(Local<String> name,
                        Local<Value> value,
-                       const AccessorInfo& info) {
+                       const AccessorInfo&) {
   if (value->IsNumber())
     g_echo_value = value->Int32Value();
 }
 
 
 static v8::Handle<Value> UnreachableGetter(Local<String> name,
                                            const AccessorInfo& info) {
   CHECK(false);  // This function should not be called..
   return v8::Undefined();
 }
 
 
-static void UnreachableSetter(Local<String> name,
-                              Local<Value> value,
-                              const AccessorInfo& info) {
+static void UnreachableSetter(Local<String>, Local<Value>,
+                              const AccessorInfo&) {
   CHECK(false);  // This function should nto be called.
 }
 
 
 THREADED_TEST(AccessControl) {
   v8::HandleScope handle_scope;
   v8::Handle<v8::ObjectTemplate> global_template = v8::ObjectTemplate::New();
 
   global_template->SetAccessCheckCallbacks(NamedAccessBlocker,
                                            IndexedAccessBlocker);
@@ skipping 258 matching lines @@
   value = v8_compile("var p = 'as' + 'df';")->Run();
   value = v8_compile("obj[p];")->Run();
 
   context1->Exit();
   context0->Exit();
   context1.Dispose();
   context0.Dispose();
 }
 
 
-static v8::Handle<Value> AccessControlNamedGetter(Local<String> name,
-                                                  const AccessorInfo& info) {
+static v8::Handle<Value> AccessControlNamedGetter(
+    Local<String>, const AccessorInfo&) {
   return v8::Integer::New(42);
 }
 
 
-static v8::Handle<Value> AccessControlNamedSetter(Local<String> key,
-                                                  Local<Value> value,
-                                                  const AccessorInfo&) {
+static v8::Handle<Value> AccessControlNamedSetter(
+    Local<String>, Local<Value> value, const AccessorInfo&) {
   return value;
 }
 
 
 static v8::Handle<Value> AccessControlIndexedGetter(
       uint32_t index,
       const AccessorInfo& info) {
   return v8_num(42);
 }
 
 
-static v8::Handle<Value> AccessControlIndexedSetter(uint32_t index,
-                                                    Local<Value> value,
-                                                    const AccessorInfo&) {
+static v8::Handle<Value> AccessControlIndexedSetter(
+    uint32_t, Local<Value> value, const AccessorInfo&) {
   return value;
 }
 
 
 THREADED_TEST(AccessControlInterceptorIC) {
   named_access_count = 0;
   indexed_access_count = 0;
 
   v8::HandleScope handle_scope;
 
@@ skipping 138 matching lines @@
   ApiTestFuzzer::Fuzz();
   return v8_num(42);
 }
 
 
 static int shadow_y;
 static int shadow_y_setter_call_count;
 static int shadow_y_getter_call_count;
 
 
-static void ShadowYSetter(Local<String> name,
-                          Local<Value> value,
-                          const AccessorInfo& info) {
+static void ShadowYSetter(Local<String>, Local<Value>, const AccessorInfo&) {
   shadow_y_setter_call_count++;
   shadow_y = 42;
 }
 
 
 static v8::Handle<Value> ShadowYGetter(Local<String> name,
                                        const AccessorInfo& info) {
   ApiTestFuzzer::Fuzz();
   shadow_y_getter_call_count++;
   return v8_num(shadow_y);
@@ skipping 395 matching lines @@
   v8::Handle<Value> value = CompileRun(
     "var result = 0;"
     "for (var i = 0; i < 1000; i++) {"
     "  result = o.x;"
     "}");
   CHECK_EQ(42, value->Int32Value());
 }
 
 
 static v8::Handle<Value> InterceptorStoreICSetter(
-      Local<String> key,
-      Local<Value> value,
-      const AccessorInfo&) {
+    Local<String> key, Local<Value> value, const AccessorInfo&) {
   CHECK(v8_str("x")->Equals(key));
   CHECK_EQ(42, value->Int32Value());
   return value;
 }
 
 
 // This test should hit the store IC for the interceptor case.
 THREADED_TEST(InterceptorStoreIC) {
   v8::HandleScope scope;
   v8::Handle<v8::ObjectTemplate> templ = ObjectTemplate::New();
@@ skipping 124 matching lines @@
     "  return false;"
     "};"
     "f();");
   CHECK_EQ(true, value->BooleanValue());
 }
 
 
 static int interceptor_ic_exception_set_count = 0;
 
 static v8::Handle<Value> InterceptorICExceptionSetter(
-      Local<String> key,
-      Local<Value> value,
-      const AccessorInfo&) {
+      Local<String> key, Local<Value> value, const AccessorInfo&) {
   ApiTestFuzzer::Fuzz();
   if (++interceptor_ic_exception_set_count > 20) {
     return v8::ThrowException(v8_num(42));
   }
   // Do not actually handle setting.
   return v8::Handle<Value>();
 }
 
 // Test interceptor store IC where the interceptor throws an exception
 // once in a while.
@@ skipping 459 matching lines @@
 #endif
   return count;
 }
 
 
 TEST(DontLeakGlobalObjects) {
   // Regression test for issues 1139850 and 1174891.
 
   v8::V8::Initialize();
 
+  // TODO(121): when running "cctest test-api", the initial count is 2,
+  // after second GC, the counter drops to 1. Needs to figure out why
+  // one GC is not enough to collect all garbage.
+  GetSurvivingGlobalObjectsCount();
   int count = GetSurvivingGlobalObjectsCount();
 
   for (int i = 0; i < 5; i++) {
     { v8::HandleScope scope;
       LocalContext context;
     }
     CHECK_EQ(count, GetSurvivingGlobalObjectsCount());
 
     { v8::HandleScope scope;
       LocalContext context;
@@ skipping 181 matching lines @@
   v8::HandleScope scope;
   LocalContext context;
   Local<ObjectTemplate> t = ObjectTemplate::New();
   t->Set(v8_str("asdf"), v8::FunctionTemplate::New(FunctionNameCallback));
   context->Global()->Set(v8_str("obj"), t->NewInstance());
   v8::Handle<v8::Value> value = CompileRun("obj.asdf.name");
   CHECK(value->IsString());
   v8::String::AsciiValue name(value);
   CHECK_EQ("asdf", *name);
 }