Speed up creation of DOM node wrappers

bindings/v8/V8Proxy.h

 /*
  * Copyright (C) 2009 Google Inc. 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
@@ skipping 167 matching lines @@
     public:
         // The types of javascript errors that can be thrown.
         enum ErrorType {
             RangeError,
             ReferenceError,
             SyntaxError,
             TypeError,
             GeneralError
         };
 
-        explicit V8Proxy(Frame* frame) : m_frame(frame), m_inlineCode(false), m_timerCallback(false), m_recursion(0) { }
+        explicit V8Proxy(Frame* frame) : m_frame(frame), m_domNodeMap(getDOMNodeMap()), m_inlineCode(false), m_timerCallback(false), m_recursion(0) { }
 
         ~V8Proxy();
 
         Frame* frame() { return m_frame; }
 
         // Clear page-specific data, but keep the global object identify.
         void clearForNavigation();
 
         // Clear page-specific data before shutting down the proxy object.
         void clearForClose();
@@ skipping 350 matching lines @@
         static void setHiddenWindowReference(Frame*, const int internalIndex, v8::Handle<v8::Object>);
 
         static V8ClassIndex::V8WrapperType htmlElementType(HTMLElement*);
 
         // The first V8WrapperType specifies the function descriptor
         // used to create JS object. The second V8WrapperType specifies
         // the actual type of the void* for type casting.
         // For example, a HTML element has HTMLELEMENT for the first V8WrapperType, but always
         // use NODE as the second V8WrapperType. JS wrapper stores the second
         // V8WrapperType and the void* as internal fields.
-        static v8::Local<v8::Object> instantiateV8Object(V8ClassIndex::V8WrapperType, V8ClassIndex::V8WrapperType, void*);
+        static v8::Local<v8::Object> instantiateV8Object(V8ClassIndex::V8WrapperType descType, V8ClassIndex::V8WrapperType cptrType, void* impl)
+        {
+          return instantiateV8Object(NULL, descType, cptrType, impl);
+        }
+
+        static v8::Local<v8::Object> instantiateV8Object(V8Proxy*, V8ClassIndex::V8WrapperType, V8ClassIndex::V8WrapperType, void*);
+
 
         static const char* rangeExceptionName(int exceptionCode);
         static const char* eventExceptionName(int exceptionCode);
         static const char* xmlHttpRequestExceptionName(int exceptionCode);
         static const char* domExceptionName(int exceptionCode);
 
 #if ENABLE(XPATH)
         static const char* xpathExceptionName(int exceptionCode);
 #endif
 
@@ skipping 18 matching lines @@
         // For each possible type of wrapper, we keep a boilerplate object.
         // The boilerplate is used to create additional wrappers of the same type.
         // We keep a single persistent handle to an array of the activated
         // boilerplates.
         v8::Persistent<v8::Array> m_wrapperBoilerplates;
         v8::Persistent<v8::Value> m_objectPrototype;
 
         v8::Persistent<v8::Object> m_global;
         v8::Persistent<v8::Value> m_document;
 
+        DOMWrapperMap<Node>& m_domNodeMap;
+
         // Utility context holding JavaScript functions used internally.
         static v8::Persistent<v8::Context> m_utilityContext;
 
         int m_handlerLineNumber;
 
         // A list of event listeners created for this frame,
         // the list gets cleared when removing all timeouts.
         V8EventListenerList m_eventListeners;
 
         // A list of event listeners create for XMLHttpRequest object for this frame,
@@ skipping 65 matching lines @@
     template <class T> inline v8::Handle<v8::Object> toV8(PassRefPtr<T> object, v8::Local<v8::Object> holder)
     {
         object->ref();
         V8Proxy::setJSWrapperForDOMObject(object.get(), v8::Persistent<v8::Object>::New(holder));
         return holder;
     }
 
 }
 
 #endif // V8Proxy_h