Split window support from V8. ...

src/handles.cc

 // Copyright 2006-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 44 matching lines @@
   CALL_HEAP_FUNCTION(content->AddKeysFromJSArray(*array), FixedArray);
 }
 
 
 Handle<FixedArray> UnionOfKeys(Handle<FixedArray> first,
                                Handle<FixedArray> second) {
   CALL_HEAP_FUNCTION(first->UnionOfKeys(*second), FixedArray);
 }
 
 
-Handle<JSGlobalObject> ReinitializeJSGlobalObject(
+Handle<JSGlobalProxy> ReinitializeJSGlobalProxy(
     Handle<JSFunction> constructor,
-    Handle<JSGlobalObject> global) {
-  CALL_HEAP_FUNCTION(Heap::ReinitializeJSGlobalObject(*constructor, *global),
-                     JSGlobalObject);
+    Handle<JSGlobalProxy> global) {
+  CALL_HEAP_FUNCTION(Heap::ReinitializeJSGlobalProxy(*constructor, *global),
+                     JSGlobalProxy);
 }
 
 
 void SetExpectedNofProperties(Handle<JSFunction> func, int nof) {
   func->shared()->set_expected_nof_properties(nof);
   if (func->has_initial_map()) {
     Handle<Map> new_initial_map =
         Factory::CopyMapDropTransitions(Handle<Map>(func->initial_map()));
     new_initial_map->set_unused_property_fields(nof);
     func->set_initial_map(*new_initial_map);
@@ skipping 398 matching lines @@
 }
 
 
 void LoadLazy(Handle<JSFunction> fun, bool* pending_exception) {
   HandleScope scope;
   Handle<FixedArray> info(FixedArray::cast(fun->shared()->lazy_load_data()));
   int index = Smi::cast(info->get(0))->value();
   ASSERT(index >= 0);
   Handle<Context> compile_context(Context::cast(info->get(1)));
   Handle<Context> function_context(Context::cast(info->get(2)));
-  Handle<Context> security_context(Context::cast(info->get(3)));
   Handle<Object> receiver(compile_context->global()->builtins());
 
   Vector<const char> name = Natives::GetScriptName(index);
 
   Handle<JSFunction> boilerplate;
 
   if (!Bootstrapper::NativesCacheLookup(name, &boilerplate)) {
     Handle<String> source_code = Bootstrapper::NativesSourceLookup(index);
     Handle<String> script_name = Factory::NewStringFromAscii(name);
     bool allow_natives_syntax = FLAG_allow_natives_syntax;
@@ skipping 14 matching lines @@
   // We shouldn't get here if compiling the script failed.
   ASSERT(!boilerplate.is_null());
 
   // When the debugger running in its own context touches lazy loaded
   // functions loading can be triggered. In that case ensure that the
   // execution of the boilerplate is in the correct context.
   SaveContext save;
   if (!Debug::debug_context().is_null() &&
       Top::context() == *Debug::debug_context()) {
     Top::set_context(*compile_context);
-    Top::set_security_context(*security_context);
   }
 
   // Reset the lazy load data before running the script to make sure
   // not to get recursive lazy loading.
   fun->shared()->set_lazy_load_data(Heap::undefined_value());
 
   // Run the script.
   Handle<JSFunction> script_fun(
       Factory::NewFunctionFromBoilerplate(boilerplate, function_context));
   Execution::Call(script_fun, receiver, 0, NULL, pending_exception);
 
   // If lazy loading failed, restore the unloaded state of fun.
   if (*pending_exception) fun->shared()->set_lazy_load_data(*info);
 }
 
 
 void SetupLazy(Handle<JSFunction> fun,
                int index,
                Handle<Context> compile_context,
-               Handle<Context> function_context,
-               Handle<Context> security_context) {
-  Handle<FixedArray> arr = Factory::NewFixedArray(4);
+               Handle<Context> function_context) {
+  Handle<FixedArray> arr = Factory::NewFixedArray(3);
   arr->set(0, Smi::FromInt(index));
   arr->set(1, *compile_context);  // Compile in this context
   arr->set(2, *function_context);  // Set function context to this
-  arr->set(3, *security_context);  // Receiver for call
   fun->shared()->set_lazy_load_data(*arr);
 }
 
 } }  // namespace v8::internal