Split window support from V8. ...

include/v8.h

 // 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 1034 matching lines @@
    * This means interceptors in the prototype chain are not called.
    */
   Handle<Value> GetRealNamedPropertyInPrototypeChain(Handle<String> key);
 
   /** Tests for a named lookup interceptor.*/
   bool HasNamedLookupInterceptor();
 
   /** Tests for an index lookup interceptor.*/
   bool HasIndexedLookupInterceptor();
 
+  /**
+   * Turns on access check on the object if the object is an instance of
+   * a template that has access check callbacks. If an object has no
+   * access check info, the object cannot be accessed by anyone.
+   */ 
+  void TurnOnAccessCheck();
 
   static Local<Object> New();
   static Object* Cast(Value* obj);
  private:
   Object();
 };
 
 
 /**
  * An instance of the built-in array constructor (ECMA-262, 15.4.2).
@@ skipping 537 matching lines @@
    * normal objects.
    */
   void MarkAsUndetectable();
 
   /**
    * Sets access check callbacks on the object template.
    *
    * When accessing properties on instances of this object template,
    * the access check callback will be called to determine whether or
    * not to allow cross-context access to the properties.
+   * The last parameter specifies whether access checks are turned
+   * on by default on instances. If access checks are off by default,
+   * they can be turned on on individual instances by calling
+   * Object::TurnOnAccessCheck().
    */
   void SetAccessCheckCallbacks(NamedSecurityCallback named_handler,
                                IndexedSecurityCallback indexed_handler,
-                               Handle<Value> data = Handle<Value>());
+                               Handle<Value> data = Handle<Value>(),
+                               bool turned_on_by_default = true);
 
   /**
    * Gets the number of internal fields for objects generated from
    * this template.
    */
   int InternalFieldCount();
 
   /**
    * Sets the number of internal fields for objects generated from
    * this template.
@@ skipping 411 matching lines @@
   const char** names_;
 };
 
 
 /**
  * A sandboxed execution context with its own set of built-in objects
  * and functions.
  */
 class EXPORT Context {
  public:
+  /** Returns the global object of the context. */
   Local<Object> Global();
 
+  /**
+   * Detaches the global object from its context before
+   * the global object can be reused to create a new context.
+   */
+  void DetachGlobal();
+
   /** Creates a new context. */
   static Persistent<Context> New(
       ExtensionConfiguration* extensions = 0,
       Handle<ObjectTemplate> global_template = Handle<ObjectTemplate>(),
       Handle<Value> global_object = Handle<Value>());
 
   /** Returns the last entered context. */
   static Local<Context> GetEntered();
 
   /** Returns the context that is on the top of the stack. */
   static Local<Context> GetCurrent();
 
-  /** Returns the security context that is currently used. */
-  static Local<Context> GetCurrentSecurityContext();
-
   /**
    * Sets the security token for the context.  To access an object in
    * another context, the security tokens must match.
    */
   void SetSecurityToken(Handle<Value> token);
 
+  /** Restores the security token to the default value. */
+  void UseDefaultSecurityToken();
+
   /** Returns the security token of this context.*/
   Handle<Value> GetSecurityToken();
 
   /**
    * Enter this context.  After entering a context, all code compiled
    * and run is compiled and run in this context.  If another context
    * is already entered, this old context is saved so it can be
    * restored when the new context is exited.
    */
   void Enter();
 
   /**
    * Exit this context.  Exiting the current context restores the
    * context that was in place when entering the current context.
    */
   void Exit();
 
   /** Returns true if the context has experienced an out of memory situation. */
   bool HasOutOfMemoryException();
 
   /** Returns true if V8 has a current context. */
   static bool InContext();
 
-  /** Returns true if V8 has a current security context. */
-  static bool InSecurityContext();
-
   /**
    * Stack-allocated class which sets the execution context for all
    * operations executed within a local scope.
    */
   class EXPORT Scope {
    public:
     inline Scope(Handle<Context> context) : context_(context) {
       context_->Enter();
     }
     inline ~Scope() { context_->Exit(); }
@@ skipping 287 matching lines @@
 
 }  // namespace v8
 
 
 #undef EXPORT
 #undef EXPORT_INLINE
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_