Split window support from V8. ...

src/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 394 matching lines @@
 }
 
 
 void Context::Enter() {
   if (IsDeadCheck("v8::Context::Enter()")) return;
   i::Handle<i::Context> env = Utils::OpenHandle(this);
   thread_local.EnterContext(env);
 
   thread_local.SaveContext(i::GlobalHandles::Create(i::Top::context()));
   i::Top::set_context(*env);
-
-  thread_local.SaveSecurityContext(
-      i::GlobalHandles::Create(i::Top::security_context()));
-  i::Top::set_security_context(*env);
 }
 
 
 void Context::Exit() {
   if (has_shut_down) return;
   if (!ApiCheck(thread_local.LeaveLastContext(),
                 "v8::Context::Exit()",
                 "Cannot exit non-entered context")) {
     return;
   }
 
-  // Content of 'last_context' and 'last_security_context' could be NULL.
+  // Content of 'last_context' could be NULL.
   i::Handle<i::Object> last_context = thread_local.RestoreContext();
   i::Top::set_context(static_cast<i::Context*>(*last_context));
   i::GlobalHandles::Destroy(last_context.location());
-
-  i::Handle<i::Object> last_security_context =
-      thread_local.RestoreSecurityContext();
-  i::Top::set_security_context(
-      static_cast<i::Context*>(*last_security_context));
-  i::GlobalHandles::Destroy(last_security_context.location());
 }
 
 
 void v8::HandleScope::DeleteExtensions() {
   ASSERT(current_.extensions != 0);
   thread_local.DeleteExtensions(current_.extensions);
 }
 
 
 void HandleScope::ZapRange(void** start, void** end) {
@@ skipping 451 matching lines @@
   i::FunctionTemplateInfo* constructor =
       i::FunctionTemplateInfo::cast(Utils::OpenHandle(this)->constructor());
   i::Handle<i::FunctionTemplateInfo> cons(constructor);
   cons->set_undetectable(true);
 }
 
 
 void ObjectTemplate::SetAccessCheckCallbacks(
       NamedSecurityCallback named_callback,
       IndexedSecurityCallback indexed_callback,
-      Handle<Value> data) {
+      Handle<Value> data,
+      bool turned_on_by_default) {
   if (IsDeadCheck("v8::ObjectTemplate::SetAccessCheckCallbacks()")) return;
   HandleScope scope;
   EnsureConstructor(this);
 
   i::Handle<i::Struct> struct_info =
       i::Factory::NewStruct(i::ACCESS_CHECK_INFO_TYPE);
   i::Handle<i::AccessCheckInfo> info =
       i::Handle<i::AccessCheckInfo>::cast(struct_info);
   info->set_named_callback(*FromCData(named_callback));
   info->set_indexed_callback(*FromCData(indexed_callback));
   if (data.IsEmpty()) data = v8::Undefined();
   info->set_data(*Utils::OpenHandle(*data));
 
   i::FunctionTemplateInfo* constructor =
       i::FunctionTemplateInfo::cast(Utils::OpenHandle(this)->constructor());
   i::Handle<i::FunctionTemplateInfo> cons(constructor);
-  cons->set_needs_access_check(true);
   cons->set_access_check_info(*info);
+  cons->set_needs_access_check(turned_on_by_default);
 }
 
 
 void ObjectTemplate::SetIndexedPropertyHandler(
       IndexedPropertyGetter getter,
       IndexedPropertySetter setter,
       IndexedPropertyQuery query,
       IndexedPropertyDeleter remover,
       IndexedPropertyEnumerator enumerator,
       Handle<Value> data) {
@@ skipping 117 matching lines @@
 
 
 Local<Value> Script::Run() {
   ON_BAILOUT("v8::Script::Run()", return Local<Value>());
   LOG_API("Script::Run");
   i::Object* raw_result = NULL;
   {
     HandleScope scope;
     i::Handle<i::JSFunction> fun = Utils::OpenHandle(this);
     EXCEPTION_PREAMBLE();
-    i::Handle<i::Object> global(i::Top::context()->global());
+    i::Handle<i::Object> receiver(i::Top::context()->global_proxy());
     i::Handle<i::Object> result =
-        i::Execution::Call(fun, global, 0, NULL, &has_pending_exception);
+        i::Execution::Call(fun, receiver, 0, NULL, &has_pending_exception);
     EXCEPTION_BAILOUT_CHECK(Local<Value>());
     raw_result = *result;
   }
   i::Handle<i::Object> result(raw_result);
   return Utils::ToLocal(result);
 }
 
 
 // --- E x c e p t i o n s ---
 
@@ skipping 677 matching lines @@
     if (num->IsSmi()) {
       return i::Smi::cast(*num)->value();
     } else {
       return static_cast<uint32_t>(num->Number());
     }
   }
 }
 
 
 bool v8::Object::Set(v8::Handle<Value> key, v8::Handle<Value> value,
-                             v8::PropertyAttribute attribs) {
+                     v8::PropertyAttribute attribs) {
   ON_BAILOUT("v8::Object::Set()", return false);
   i::Handle<i::Object> self = Utils::OpenHandle(this);
   i::Handle<i::Object> key_obj = Utils::OpenHandle(*key);
   i::Handle<i::Object> value_obj = Utils::OpenHandle(*value);
   EXCEPTION_PREAMBLE();
   i::Handle<i::Object> obj = i::SetProperty(
       self,
       key_obj,
       value_obj,
       static_cast<PropertyAttributes>(attribs));
@@ skipping 152 matching lines @@
     i::Handle<i::Object> result(self_obj->GetProperty(*self_obj,
                                                       &lookup,
                                                       *key_obj,
                                                       &attributes));
     return Utils::ToLocal(result);
   }
   return Local<Value>();  // No real property was found in prototype chain.
 }
 
 
+// Turns on access checks by copying the map and setting the check flag.
+// Because the object gets a new map, existing inline cache caching
+// the old map of this object will fail.
+void v8::Object::TurnOnAccessCheck() {
+  ON_BAILOUT("v8::Object::TurnOnAccessCheck()", return);
+  i::Handle<i::JSObject> obj = Utils::OpenHandle(this);
+
+  i::Handle<i::Map> new_map =
+    i::Factory::CopyMapDropTransitions(i::Handle<i::Map>(obj->map()));
+  new_map->set_is_access_check_needed();
+  obj->set_map(*new_map);
+}
+
+
 Local<v8::Object> Function::NewInstance() {
   return NewInstance(0, NULL);
 }
 
 
 Local<v8::Object> Function::NewInstance(int argc,
                                         v8::Handle<v8::Value> argv[]) {
   ON_BAILOUT("v8::Function::NewInstance()", return Local<v8::Object>());
   LOG_API("Function::NewInstance");
   HandleScope scope;
@@ skipping 263 matching lines @@
     return i::V8::Initialize(NULL);
   }
 }
 
 
 const char* v8::V8::GetVersion() {
   return "0.4.0 (internal)";
 }
 
 
-Persistent<Context> v8::Context::New(v8::ExtensionConfiguration* extensions,
-                                     v8::Handle<ObjectTemplate> global_template,
-                                     v8::Handle<Value> global_object) {
+static i::Handle<i::FunctionTemplateInfo>
+    EnsureConstructor(i::Handle<i::ObjectTemplateInfo> templ) {
+  if (templ->constructor()->IsUndefined()) {
+    Local<FunctionTemplate> constructor = FunctionTemplate::New();
+    Utils::OpenHandle(*constructor)->set_instance_template(*templ);
+    templ->set_constructor(*Utils::OpenHandle(*constructor));
+  }
+  return i::Handle<i::FunctionTemplateInfo>(
+    i::FunctionTemplateInfo::cast(templ->constructor()));
+}
+
+
+Persistent<Context> v8::Context::New(
+    v8::ExtensionConfiguration* extensions,
+    v8::Handle<ObjectTemplate> global_template,
+    v8::Handle<Value> global_object) {
   EnsureInitialized("v8::Context::New()");
   LOG_API("Context::New");
   ON_BAILOUT("v8::Context::New()", return Persistent<Context>());
+
   // Make sure that the global_template has a constructor.
-  if (!global_template.IsEmpty() &&
-     Utils::OpenHandle(*global_template)->constructor()->IsUndefined()) {
-    Local<FunctionTemplate> templ = FunctionTemplate::New();
-    Utils::OpenHandle(*templ)->set_instance_template(
+  if (!global_template.IsEmpty()) {
+    i::Handle<i::FunctionTemplateInfo> constructor =
+        EnsureConstructor(Utils::OpenHandle(*global_template));
+
+    // Create a fresh template for outer global object.
+    Local<ObjectTemplate> outer_template = ObjectTemplate::New();
+
+    i::Handle<i::FunctionTemplateInfo> outer_constructor =
+      EnsureConstructor(Utils::OpenHandle(*outer_template));
+    
+    // Set the global template to be the prototype template
+    // of outer global template.
+    outer_constructor->set_prototype_template(
         *Utils::OpenHandle(*global_template));
-    i::Handle<i::FunctionTemplateInfo> constructor = Utils::OpenHandle(*templ);
-    Utils::OpenHandle(*global_template)->set_constructor(*constructor);
+
+    // Migrate security handlers from global_template to outer_template.
+    if (!constructor->access_check_info()->IsUndefined()) {
+       outer_constructor->set_access_check_info(
+           constructor->access_check_info());
+       outer_constructor->set_needs_access_check(true);
+
+       // Remove access check info from global_template.
+       constructor->set_needs_access_check(false);
+       constructor->set_access_check_info(i::Heap::undefined_value());
+    }
+
+    global_template = outer_template;
   }
 
   i::Handle<i::Context> env = i::Bootstrapper::CreateEnvironment(
       Utils::OpenHandle(*global_object),
       global_template, extensions);
   if (!ApiCheck(!env.is_null(),
                 "v8::Context::New()",
                 "Could not initialize environment"))
     return Persistent<Context>();
   return Persistent<Context>(Utils::ToLocal(env));
 }
 
 
 void v8::Context::SetSecurityToken(Handle<Value> token) {
+  if (IsDeadCheck("v8::Context::SetSecurityToken()")) return;
   i::Handle<i::Context> env = Utils::OpenHandle(this);
   i::Handle<i::Object> token_handle = Utils::OpenHandle(*token);
-  // The global object of an environment is always a real global
-  // object with security token and reference to the builtins object.
-  i::JSGlobalObject::cast(env->global())->set_security_token(*token_handle);
+  env->set_security_token(*token_handle);
+}
+
+
+void v8::Context::UseDefaultSecurityToken() {
+  if (IsDeadCheck("v8::Context::UseDefaultSecurityToken()")) return;
+  i::Handle<i::Context> env = Utils::OpenHandle(this);
+  // The default security token of an environment is the inner global object
+  // of the environment. The security tokens of outer and inner global objects
+  // are always the same.
+  env->set_security_token(env->global());
 }
 
 
 Handle<Value> v8::Context::GetSecurityToken() {
+  if (IsDeadCheck("v8::Context::GetSecurityToken()")) return Handle<Value>();
   i::Handle<i::Context> env = Utils::OpenHandle(this);
-  i::Object* security_token =
-      i::JSGlobalObject::cast(env->global())->security_token();
+  i::Object* security_token = env->security_token();
   i::Handle<i::Object> token_handle(security_token);
   return Utils::ToLocal(token_handle);
 }
 
 
 bool Context::HasOutOfMemoryException() {
   i::Handle<i::Context> env = Utils::OpenHandle(this);
   return env->has_out_of_memory();
 }
 
 
 bool Context::InContext() {
   return i::Top::context() != NULL;
 }
 
 
-bool Context::InSecurityContext() {
-  return i::Top::security_context() != NULL;
-}
-
-
 v8::Local<v8::Context> Context::GetEntered() {
   if (IsDeadCheck("v8::Context::GetEntered()")) return Local<Context>();
   i::Handle<i::Object> last = thread_local.LastEnteredContext();
   if (last.is_null()) return Local<Context>();
   i::Handle<i::Context> context = i::Handle<i::Context>::cast(last);
   return Utils::ToLocal(context);
 }
 
 
 v8::Local<v8::Context> Context::GetCurrent() {
   if (IsDeadCheck("v8::Context::GetCurrent()")) return Local<Context>();
   i::Handle<i::Context> context(i::Top::global_context());
   return Utils::ToLocal(context);
 }
 
 
-v8::Local<v8::Context> Context::GetCurrentSecurityContext() {
-  if (IsDeadCheck("v8::Context::GetCurrentSecurityContext()")) {
-    return Local<Context>();
-  }
-  i::Handle<i::Context> context(i::Top::security_context());
-  return Utils::ToLocal(context);
-}
-
-
 v8::Local<v8::Object> Context::Global() {
   if (IsDeadCheck("v8::Context::Global()")) return Local<v8::Object>();
   i::Object** ctx = reinterpret_cast<i::Object**>(this);
   i::Handle<i::Context> context =
       i::Handle<i::Context>::cast(i::Handle<i::Object>(ctx));
-  i::Handle<i::JSObject> global(context->global());
-  return Utils::ToLocal(global);
+  i::Handle<i::Object> global(context->global_proxy());
+  return Utils::ToLocal(i::Handle<i::JSObject>::cast(global));
 }
 
 
+void Context::DetachGlobal() {
+  if (IsDeadCheck("v8::Context::DetachGlobal()")) return;
+  i::Object** ctx = reinterpret_cast<i::Object**>(this);
+  i::Handle<i::Context> context =
+      i::Handle<i::Context>::cast(i::Handle<i::Object>(ctx));
+  i::Bootstrapper::DetachGlobal(context);
+}
+
+
 Local<v8::Object> ObjectTemplate::NewInstance() {
   ON_BAILOUT("v8::ObjectTemplate::NewInstance()", return Local<v8::Object>());
   LOG_API("ObjectTemplate::NewInstance");
   EXCEPTION_PREAMBLE();
   i::Handle<i::Object> obj =
       i::Execution::InstantiateObject(Utils::OpenHandle(this),
                                       &has_pending_exception);
   EXCEPTION_BAILOUT_CHECK(Local<v8::Object>());
   return Utils::ToLocal(i::Handle<i::JSObject>::cast(obj));
 }
@@ skipping 597 matching lines @@
       reinterpret_cast<HandleScopeImplementer*>(storage);
   List<void**>* blocks_of_archived_thread = thread_local->Blocks();
   ImplementationUtilities::HandleScopeData* handle_data_of_archived_thread =
       &thread_local->handle_scope_data_;
   Iterate(v, blocks_of_archived_thread, handle_data_of_archived_thread);
 
   return storage + ArchiveSpacePerThread();
 }
 
 } }  // namespace v8::internal