Split window support from V8. ...

src/runtime.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 3805 matching lines @@
   return *adaptor;
 }
 
 
 static Object* Runtime_EvalReceiver(Arguments args) {
   StackFrameLocator locator;
   return locator.FindJavaScriptFrame(1)->receiver();
 }
 
 
+static Object* Runtime_GlobalReceiver(Arguments args) {
+  ASSERT(args.length() == 1);
+  Object* global = args[0];
+  if (!global->IsJSGlobalObject()) return Heap::null_value();
+  return JSGlobalObject::cast(global)->global_receiver();
+}
+
+
 static Object* Runtime_CompileString(Arguments args) {
   HandleScope scope;
   ASSERT(args.length() == 3);
   CONVERT_ARG_CHECKED(String, source, 0);
   CONVERT_ARG_CHECKED(Smi, line_offset, 1);
   bool contextual = args[2]->IsTrue();
   RUNTIME_ASSERT(contextual || args[2]->IsFalse());
 
   // Compute the eval context.
   Handle<Context> context;
@@ skipping 273 matching lines @@
     case NULL_DESCRIPTOR:
       return Heap::undefined_value();
     default:
       UNREACHABLE();
   }
   UNREACHABLE();
   return Heap::undefined_value();
 }
 
 
-static Object* Runtime_DebugGetLocalPropertyDetails(Arguments args) {
+static Object* Runtime_DebugGetPropertyDetails(Arguments args) {
   HandleScope scope;
 
   ASSERT(args.length() == 2);
 
   CONVERT_ARG_CHECKED(JSObject, obj, 0);
   CONVERT_ARG_CHECKED(String, name, 1);
 
   // Check if the name is trivially convertible to an index and get the element
   // if so.
   uint32_t index;
   if (name->AsArrayIndex(&index)) {
     Handle<FixedArray> details = Factory::NewFixedArray(2);
     details->set(0, Runtime::GetElementOrCharAt(obj, index));
     details->set(1, PropertyDetails(NONE, NORMAL).AsSmi());
     return *Factory::NewJSArrayWithElements(details);
   }
 
   // Perform standard local lookup on the object.
   LookupResult result;
-  obj->LocalLookup(*name, &result);
+  obj->Lookup(*name, &result);
   if (result.IsProperty()) {
     Handle<Object> value(DebugLookupResultValue(&result));
     Handle<FixedArray> details = Factory::NewFixedArray(2);
     details->set(0, *value);
     details->set(1, result.GetPropertyDetails().AsSmi());
     return *Factory::NewJSArrayWithElements(details);
   }
   return Heap::undefined_value();
 }
 
@@ skipping 731 matching lines @@
 
   // Traverse the saved contexts chain to find the active context for the
   // selected frame.
   SaveContext* save = Top::save_context();
   while (save != NULL && reinterpret_cast<Address>(save) < frame->sp()) {
     save = save->prev();
   }
   ASSERT(save != NULL);
   SaveContext savex;
   Top::set_context(*(save->context()));
-  Top::set_security_context(*(save->security_context()));
 
   // Create the (empty) function replacing the function on the stack frame for
   // the purpose of evaluating in the context created below. It is important
   // that this function does not describe any parameters and local variables
   // in the context. If it does then this will cause problems with the lookup
   // in Context::Lookup, where context slots for parameters and local variables
   // are looked at before the extension object.
   Handle<JSFunction> go_between =
       Factory::NewFunction(Factory::empty_string(), Factory::undefined_value());
   go_between->set_context(function->context());
@@ skipping 106 matching lines @@
   DisableBreak disable_break_save(disable_break);
 
   // Enter the top context from before the debugger was invoked.
   SaveContext save;
   SaveContext* top = &save;
   while (top != NULL && *top->context() == *Debug::debug_context()) {
     top = top->prev();
   }
   if (top != NULL) {
     Top::set_context(*top->context());
-    Top::set_security_context(*top->security_context());
   }
 
   // Get the global context now set to the top context from before the
   // debugger was invoked.
   Handle<Context> context = Top::global_context();
 
   // Compile the source to be evaluated.
   Handle<JSFunction> boilerplate(Compiler::CompileEval(source, 0, true));
   if (boilerplate.is_null()) return Failure::Exception();
   Handle<JSFunction> compiled_function =
@@ skipping 418 matching lines @@
 
 void Runtime::PerformGC(Object* result) {
   Failure* failure = Failure::cast(result);
   // Try to do a garbage collection; ignore it if it fails. The C
   // entry stub will throw an out-of-memory exception in that case.
   Heap::CollectGarbage(failure->requested(), failure->allocation_space());
 }
 
 
 } }  // namespace v8::internal