Split window support from V8. ...

src/top.h

 // 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 24 matching lines @@
 
 #define RETURN_IF_SCHEDULED_EXCEPTION() \
   if (Top::has_scheduled_exception()) return Top::PromoteScheduledException()
 
 // Top has static variables used for JavaScript execution.
 
 class SaveContext;  // Forward decleration.
 
 class ThreadLocalTop BASE_EMBEDDED {
  public:
-  Context* security_context_;
   // The context where the current execution method is created and for variable
   // lookups.
   Context* context_;
   Object* pending_exception_;
   // Use a separate value for scheduled exceptions to preserve the
   // invariants that hold about pending_exception.  We may want to
   // unify them later.
   Object* scheduled_exception_;
   bool external_caught_exception_;
   v8::TryCatch* try_catch_handler_;
   SaveContext* save_context_;
 
   // Stack.
   Address c_entry_fp_;  // the frame pointer of the top c entry frame
   Address handler_;   // try-blocks are chained through the stack
   bool stack_is_cooked_;
   inline bool stack_is_cooked() { return stack_is_cooked_; }
   inline void set_stack_is_cooked(bool value) { stack_is_cooked_ = value; }
 
   // Generated code scratch locations.
   int32_t formal_count_;
 
   // Call back function to report unsafe JS accesses.
   v8::FailedAccessCheckCallback failed_access_check_callback_;
 };
 
 #define TOP_ADDRESS_LIST(C) \
-  C(handler_address)                    \
+  C(handler_address)                   \
   C(c_entry_fp_address)                \
   C(context_address)                   \
   C(pending_exception_address)         \
-  C(external_caught_exception_address) \
-  C(security_context_address)
+  C(external_caught_exception_address)
 
 class Top {
  public:
   enum AddressId {
 #define C(name) k_##name,
     TOP_ADDRESS_LIST(C)
 #undef C
     k_top_address_count
   };
 
   static Address get_address_from_id(AddressId id);
 
-  // Access to the security context from which JS execution started.
-  // In a browser world, it is the JS context of the frame which initiated
-  // JavaScript execution.
-  static Context* security_context() { return thread_local_.security_context_; }
-  static void set_security_context(Context* context) {
-    ASSERT(context == NULL || context->IsGlobalContext());
-    thread_local_.security_context_ = context;
-  }
-  static Context** security_context_address() {
-    return &thread_local_.security_context_;
-  }
-
   // Access to top context (where the current function object was created).
   static Context* context() { return thread_local_.context_; }
   static void set_context(Context* context) {
     thread_local_.context_ = context;
   }
   static Context** context_address() { return &thread_local_.context_; }
 
   static SaveContext* save_context() {return thread_local_.save_context_; }
   static void set_save_context(SaveContext* save) {
     thread_local_.save_context_ = save;
@@ skipping 123 matching lines @@
   // Out of resource exception helpers.
   static Failure* StackOverflow();
 
   // Administration
   static void Initialize();
   static void TearDown();
   static void Iterate(ObjectVisitor* v);
   static void Iterate(ObjectVisitor* v, ThreadLocalTop* t);
   static char* Iterate(ObjectVisitor* v, char* t);
 
-  static Handle<JSObject> global() {
-    return Handle<JSObject>(context()->global());
+  // Returns the global object of the current context. It could be
+  // a builtin object, or a js global object.
+  static Handle<GlobalObject> global() {
+    return Handle<GlobalObject>(context()->global());
   }
+
+  // Returns the global proxy object of the current context.
+  static Object* global_proxy() {
+    return context()->global_proxy();
+  }
+
   static Handle<Context> global_context();
 
   static Handle<JSBuiltinsObject> builtins() {
     return Handle<JSBuiltinsObject>(thread_local_.context_->builtins());
   }
-  static Handle<JSBuiltinsObject> security_context_builtins() {
-    return Handle<JSBuiltinsObject>(
-        thread_local_.security_context_->builtins());
-  }
 
   static Object* LookupSpecialFunction(JSObject* receiver,
                                        JSObject* prototype,
                                        JSFunction* value);
 
   static void RegisterTryCatchHandler(v8::TryCatch* that);
   static void UnregisterTryCatchHandler(v8::TryCatch* that);
 
 #define TOP_GLOBAL_CONTEXT_FIELD_ACCESSOR(index, type, name)  \
   static Handle<type> name() {                                \
@@ skipping 33 matching lines @@
   friend class ExecutionAccess;
 
   static void FillCache();
 };
 
 
 class SaveContext BASE_EMBEDDED {
  public:
   SaveContext() :
       context_(Top::context()),
-      security_context_(Top::security_context()),
       prev_(Top::save_context()) {
     Top::set_save_context(this);
   }
 
   ~SaveContext() {
     Top::set_context(*context_);
-    Top::set_security_context(*security_context_);
     Top::set_save_context(prev_);
   }
 
   Handle<Context> context() { return context_; }
-  Handle<Context> security_context() { return security_context_; }
   SaveContext* prev() { return prev_; }
 
  private:
   Handle<Context> context_;
-  Handle<Context> security_context_;
   SaveContext* prev_;
 };
 
 
 class AssertNoContextChange BASE_EMBEDDED {
 #ifdef DEBUG
  public:
   AssertNoContextChange() :
-      context_(Top::context()),
-      security_context_(Top::security_context()) {
+      context_(Top::context()) {
   }
 
   ~AssertNoContextChange() {
     ASSERT(Top::context() == *context_);
-    ASSERT(Top::security_context() == *security_context_);
   }
 
  private:
   HandleScope scope_;
   Handle<Context> context_;
-  Handle<Context> security_context_;
 #else
  public:
   AssertNoContextChange() { }
 #endif
 };
 
 
 class ExecutionAccess BASE_EMBEDDED {
  public:
   ExecutionAccess();
   ~ExecutionAccess();
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_TOP_H_