Make DOMWrapperWorld::DOMObjectHolderBase fast-allocated.

Source/bindings/core/v8/DOMWrapperWorld.cpp

 /*
  * 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 27 matching lines @@
 #include "bindings/core/v8/V8DOMWrapper.h"
 #include "bindings/core/v8/V8Window.h"
 #include "bindings/core/v8/WindowProxy.h"
 #include "bindings/core/v8/WrapperTypeInfo.h"
 #include "core/dom/ExecutionContext.h"
 #include "wtf/HashTraits.h"
 #include "wtf/StdLibExtras.h"
 
 namespace blink {
 
+class DOMObjectHolderBase {
+    WTF_MAKE_FAST_ALLOCATED(DOMObjectHolderBase);
+public:
+    DOMObjectHolderBase(v8::Isolate* isolate, v8::Local<v8::Value> wrapper)
+        : m_wrapper(isolate, wrapper)
+        , m_world(0)
+    {
+    }
+    virtual ~DOMObjectHolderBase() { }
+
+    DOMWrapperWorld* world() const { return m_world; }
+    void setWorld(DOMWrapperWorld* world) { m_world = world; }
+    void setWeak(void (*callback)(const v8::WeakCallbackInfo<DOMObjectHolderBase>&))
+    {
+        m_wrapper.setWeak(this, callback);
+    }
+
+private:
+    ScopedPersistent<v8::Value> m_wrapper;
+    DOMWrapperWorld* m_world;
+};
+
+template<typename T>
+class DOMObjectHolder : public DOMObjectHolderBase {
+public:
+    static PassOwnPtr<DOMObjectHolder<T>> create(v8::Isolate* isolate, T* object, v8::Local<v8::Value> wrapper)
+    {
+        return adoptPtr(new DOMObjectHolder(isolate, object, wrapper));
+    }
+
+private:
+    DOMObjectHolder(v8::Isolate* isolate, T* object, v8::Local<v8::Value> wrapper)
+        : DOMObjectHolderBase(isolate, wrapper)
+        , m_object(object)
+    {
+    }
+
+    Persistent<T> m_object;
+};
+
 unsigned DOMWrapperWorld::isolatedWorldCount = 0;
 DOMWrapperWorld* DOMWrapperWorld::worldOfInitializingWindow = 0;
 
 PassRefPtr<DOMWrapperWorld> DOMWrapperWorld::create(v8::Isolate* isolate, int worldId, int extensionGroup)
 {
     return adoptRef(new DOMWrapperWorld(isolate, worldId, extensionGroup));
 }
 
 DOMWrapperWorld::DOMWrapperWorld(v8::Isolate* isolate, int worldId, int extensionGroup)
     : m_worldId(worldId)
@@ skipping 156 matching lines @@
 
 void DOMWrapperWorld::setIsolatedWorldContentSecurityPolicy(int worldId, const String& policy)
 {
     ASSERT(isIsolatedWorldId(worldId));
     if (!policy.isEmpty())
         isolatedWorldContentSecurityPolicies().set(worldId, true);
     else
         isolatedWorldContentSecurityPolicies().remove(worldId);
 }
 
+template<typename T>
+void DOMWrapperWorld::registerDOMObjectHolder(v8::Isolate* isolate, T* object, v8::Local<v8::Value> wrapper)
+{
+    registerDOMObjectHolderInternal(DOMObjectHolder<T>::create(isolate, object, wrapper));
+}
+
+template void DOMWrapperWorld::registerDOMObjectHolder(v8::Isolate*, ScriptFunction*, v8::Local<v8::Value>);
+
 void DOMWrapperWorld::registerDOMObjectHolderInternal(PassOwnPtr<DOMObjectHolderBase> holderBase)
 {
     ASSERT(!m_domObjectHolders.contains(holderBase.get()));
     holderBase->setWorld(this);
     holderBase->setWeak(&DOMWrapperWorld::weakCallbackForDOMObjectHolder);
     m_domObjectHolders.add(holderBase);
 }
 
 void DOMWrapperWorld::unregisterDOMObjectHolder(DOMObjectHolderBase* holderBase)
 {
     ASSERT(m_domObjectHolders.contains(holderBase));
     m_domObjectHolders.remove(holderBase);
 }
 
 void DOMWrapperWorld::weakCallbackForDOMObjectHolder(const v8::WeakCallbackInfo<DOMObjectHolderBase>& data)
 {
     DOMObjectHolderBase* holderBase = data.GetParameter();
     holderBase->world()->unregisterDOMObjectHolder(holderBase);
 }
 
 } // namespace blink