Bring toiger up to date with bleeding edge 984.

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 2185 matching lines @@
   if (i::Snapshot::Initialize()) {
     i::Serializer::disable();
     return true;
   } else {
     return i::V8::Initialize(NULL);
   }
 }
 
 
 const char* v8::V8::GetVersion() {
-  return "0.4.6 (candidate)";
+  return "0.4.7 (candidate)";
 }
 
 
 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.
+  v8::Handle<ObjectTemplate> proxy_template = global_template;
+  i::Handle<i::FunctionTemplateInfo> proxy_constructor;
+  i::Handle<i::FunctionTemplateInfo> global_constructor;
+
   if (!global_template.IsEmpty()) {
-    i::Handle<i::FunctionTemplateInfo> constructor =
-        EnsureConstructor(Utils::OpenHandle(*global_template));
+    // Make sure that the global_template has a constructor.
+    global_constructor = EnsureConstructor(Utils::OpenHandle(*global_template));
 
-    // Create a fresh template for global proxy object.
-    Local<ObjectTemplate> proxy_template = ObjectTemplate::New();
+    // Create a fresh template for the global proxy object.
+    proxy_template = ObjectTemplate::New();
+    proxy_constructor = EnsureConstructor(Utils::OpenHandle(*proxy_template));
 
-    i::Handle<i::FunctionTemplateInfo> proxy_constructor =
-      EnsureConstructor(Utils::OpenHandle(*proxy_template));
-
-    // Set the global template to be the prototype template
-    // of global proxy template.
+    // Set the global template to be the prototype template of global
+    // proxy template.
     proxy_constructor->set_prototype_template(
         *Utils::OpenHandle(*global_template));
 
-    // Migrate security handlers from global_template to proxy_template.
-    if (!constructor->access_check_info()->IsUndefined()) {
-       proxy_constructor->set_access_check_info(
-           constructor->access_check_info());
-       proxy_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());
+    // Migrate security handlers from global_template to
+    // proxy_template.  Temporarily removing access check information
+    // from the global template.
+    if (!global_constructor->access_check_info()->IsUndefined()) {
+      proxy_constructor->set_access_check_info(
+          global_constructor->access_check_info());
+      proxy_constructor->set_needs_access_check(
+          global_constructor->needs_access_check());
+      global_constructor->set_needs_access_check(false);
+      global_constructor->set_access_check_info(i::Heap::undefined_value());
     }
-
-    global_template = proxy_template;
   }
 
+  // Create the environment.
   i::Handle<i::Context> env = i::Bootstrapper::CreateEnvironment(
       Utils::OpenHandle(*global_object),
-      global_template, extensions);
+      proxy_template,
+      extensions);
+
+  // Restore the access check info on the global template.
+  if (!global_template.IsEmpty()) {
+    ASSERT(!global_constructor.is_null());
+    ASSERT(!proxy_constructor.is_null());
+    global_constructor->set_access_check_info(
+        proxy_constructor->access_check_info());
+    global_constructor->set_needs_access_check(
+        proxy_constructor->needs_access_check());
+  }
+
   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;
@@ skipping 348 matching lines @@
 }
 
 
 void V8::SetFailedAccessCheckCallbackFunction(
       FailedAccessCheckCallback callback) {
   if (IsDeadCheck("v8::V8::SetFailedAccessCheckCallbackFunction()")) return;
   i::Top::SetFailedAccessCheckCallback(callback);
 }
 
 
-void V8::AddObjectToGroup(void* group_id, Persistent<Object> obj) {
-  if (IsDeadCheck("v8::V8::AddObjectToGroup()")) return;
-  i::GlobalHandles::AddToGroup(group_id, reinterpret_cast<i::Object**>(*obj));
+void V8::AddObjectGroup(Persistent<Value>* objects, size_t length) {
+  if (IsDeadCheck("v8::V8::AddObjectGroup()")) return;
+  STATIC_ASSERT(sizeof(Persistent<Value>) == sizeof(i::Object**));
+  i::GlobalHandles::AddGroup(reinterpret_cast<i::Object***>(objects), length);
 }
 
 
 int V8::AdjustAmountOfExternalAllocatedMemory(int change_in_bytes) {
   if (IsDeadCheck("v8::V8::AdjustAmountOfExternalAllocatedMemory()")) return 0;
   return i::Heap::AdjustAmountOfExternalAllocatedMemory(change_in_bytes);
 }
 
 
 void V8::SetGlobalGCPrologueCallback(GCCallback callback) {
@@ skipping 352 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