Split window support from V8. ...

src/api.h

 // Copyright 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 244 matching lines @@
   static inline v8::internal::Handle<v8::internal::JSFunction>
       OpenHandle(Function* data);
   static inline v8::internal::Handle<v8::internal::JSObject>
       OpenHandle(Message* message);
   static inline v8::internal::Handle<v8::internal::Context>
       OpenHandle(v8::Context* context);
   static inline v8::internal::Handle<v8::internal::SignatureInfo>
       OpenHandle(v8::Signature* sig);
   static inline v8::internal::Handle<v8::internal::TypeSwitchInfo>
       OpenHandle(v8::TypeSwitch* that);
+  static inline v8::internal::Handle<v8::internal::Proxy>
+      OpenHandle(v8::External* that);
 };
 
 
 template <class T>
 static inline T* ToApi(v8::internal::Handle<v8::internal::Object> obj) {
   return reinterpret_cast<T*>(obj.location());
 }
 
 
 template <class T>
@@ skipping 43 matching lines @@
 MAKE_OPEN_HANDLE(Signature, SignatureInfo)
 MAKE_OPEN_HANDLE(TypeSwitch, TypeSwitchInfo)
 MAKE_OPEN_HANDLE(Data, Object)
 MAKE_OPEN_HANDLE(Object, JSObject)
 MAKE_OPEN_HANDLE(Array, JSArray)
 MAKE_OPEN_HANDLE(String, String)
 MAKE_OPEN_HANDLE(Script, JSFunction)
 MAKE_OPEN_HANDLE(Function, JSFunction)
 MAKE_OPEN_HANDLE(Message, JSObject)
 MAKE_OPEN_HANDLE(Context, Context)
+MAKE_OPEN_HANDLE(External, Proxy)
 
 #undef MAKE_OPEN_HANDLE
 
 
 namespace internal {
 
 // This class is here in order to be able to declare it a friend of
 // HandleScope.  Moving these methods to be members of HandleScope would be
 // neat in some ways, but it would expose external implementation details in
 // our public header file, which is undesirable.
 //
 // There is a singleton instance of this class to hold the per-thread data.
 // For multithreaded V8 programs this data is copied in and out of storage
 // so that the currently executing thread always has its own copy of this
 // data.
 class HandleScopeImplementer {
  public:
 
   HandleScopeImplementer()
       : blocks(0),
         entered_contexts_(0),
-        saved_contexts_(0),
-        saved_security_contexts_(0) {
+        saved_contexts_(0) {
     Initialize();
   }
 
   void Initialize() {
     blocks.Initialize(0);
     entered_contexts_.Initialize(0);
     saved_contexts_.Initialize(0);
-    saved_security_contexts_.Initialize(0);
     spare = NULL;
     ignore_out_of_memory = false;
     call_depth = 0;
   }
 
   static HandleScopeImplementer* instance();
 
   // Threading support for handle data.
   static int ArchiveSpacePerThread();
   static char* RestoreThread(char* from);
@@ skipping 15 matching lines @@
   inline bool LeaveLastContext();
 
   // Returns the last entered context or an empty handle if no
   // contexts have been entered.
   inline Handle<Object> LastEnteredContext();
 
   inline void SaveContext(Handle<Object> context);
   inline Handle<Object> RestoreContext();
   inline bool HasSavedContexts();
 
-  inline void SaveSecurityContext(Handle<Object> context);
-  inline Handle<Object> RestoreSecurityContext();
-  inline bool HasSavedSecurityContexts();
-
   inline List<void**>* Blocks() { return &blocks; }
 
   inline bool IgnoreOutOfMemory() { return ignore_out_of_memory; }
   inline void SetIgnoreOutOfMemory(bool value) { ignore_out_of_memory = value; }
 
  private:
   List<void**> blocks;
   Object** spare;
   int call_depth;
   // Used as a stack to keep track of entered contexts.
   List<Handle<Object> > entered_contexts_;
   // Used as a stack to keep track of saved contexts.
   List<Handle<Object> > saved_contexts_;
-  // Used as a stack to keep track of saved security contexts.
-  List<Handle<Object> > saved_security_contexts_;
   bool ignore_out_of_memory;
   // This is only used for threading support.
   ImplementationUtilities::HandleScopeData handle_scope_data_;
 
   static void Iterate(ObjectVisitor* v,
                       List<void**>* blocks,
                       ImplementationUtilities::HandleScopeData* handle_data);
   char* RestoreThreadHelper(char* from);
   char* ArchiveThreadHelper(char* to);
 
@@ skipping 12 matching lines @@
 Handle<Object> HandleScopeImplementer::RestoreContext() {
   return saved_contexts_.RemoveLast();
 }
 
 
 bool HandleScopeImplementer::HasSavedContexts() {
   return !saved_contexts_.is_empty();
 }
 
 
-void HandleScopeImplementer::SaveSecurityContext(Handle<Object> context) {
-  saved_security_contexts_.Add(context);
-}
-
-
-Handle<Object> HandleScopeImplementer::RestoreSecurityContext() {
-  return saved_security_contexts_.RemoveLast();
-}
-
-
-bool HandleScopeImplementer::HasSavedSecurityContexts() {
-  return !saved_security_contexts_.is_empty();
-}
-
-
 void HandleScopeImplementer::EnterContext(Handle<Object> context) {
   entered_contexts_.Add(context);
 }
 
 
 bool HandleScopeImplementer::LeaveLastContext() {
   if (entered_contexts_.is_empty()) return false;
   entered_contexts_.RemoveLast();
   return true;
 }
@@ skipping 31 matching lines @@
 #ifdef DEBUG
   ImplementationUtilities::ZapHandleRange(
       reinterpret_cast<void**>(spare),
       reinterpret_cast<void**>(&spare[kHandleBlockSize]));
 #endif
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_API_H_