Changeset 108010 in webkit for trunk/Source/JavaScriptCore/heap/Weak.h

Timestamp:

Feb 16, 2012, 5:56:13 PM (13 years ago)

Author:

[email protected]

Message:

Made Weak<T> single-owner, adding PassWeak<T>
​https://bugs.webkit.org/show_bug.cgi?id=78740

Reviewed by Sam Weinig.

Source/JavaScriptCore:

This works basically the same way as OwnPtr<T> and PassOwnPtr<T>.

This clarifies the semantics of finalizers: It's ambiguous and probably
a bug to copy a finalizer (i.e., it's a bug to run a C++ destructor
twice), so I've made Weak<T> non-copyable. Anywhere we used to copy a
Weak<T>, we now use PassWeak<T>.

This also makes Weak<T> HashMaps more efficient.

• API/JSClassRef.cpp:

(OpaqueJSClass::prototype): Use PassWeak<T> instead of set(), since
set() is gone now.

• JavaScriptCore.xcodeproj/project.pbxproj: Export!

• heap/PassWeak.h: Added.

(JSC):
(PassWeak):
(JSC::PassWeak::PassWeak):
(JSC::PassWeak::~PassWeak):
(JSC::PassWeak::get):
(JSC::::leakHandle):
(JSC::adoptWeak):
(JSC::operator==):
(JSC::operator!=): This is the Weak<T> version of PassOwnPtr<T>.

• heap/Weak.h:

(Weak):
(JSC::Weak::Weak):
(JSC::Weak::release):
(JSC::Weak::hashTableDeletedValue):
(JSC::=):
(JSC): Changed to be non-copyable, removing a lot of copying-related
APIs. Added hash traits so hash maps still work.

• jit/JITStubs.cpp:

(JSC::JITThunks::hostFunctionStub):

• runtime/RegExpCache.cpp:

(JSC::RegExpCache::lookupOrCreate): Use PassWeak<T>, as required by
our new hash map API.

Source/WebCore:

• bindings/js/JSDOMBinding.cpp:

(WebCore::jsStringSlowCase): Use PassWeak<T>, as required by our new
hash map API.

• bindings/js/JSDOMBinding.h:

(WebCore::getCachedWrapper):
(WebCore::cacheWrapper): Use PassWeak<T> and raw pointer, as required by
our new hash map API.

• bindings/js/JSEventListener.h:

(WebCore::JSEventListener::setWrapper):

• bindings/js/ScriptWrappable.h:

(WebCore::ScriptWrappable::setWrapper):

• bridge/jsc/BridgeJSC.cpp:

(JSC::Bindings::Instance::createRuntimeObject):

• bridge/runtime_root.cpp:

(JSC::Bindings::RootObject::addRuntimeObject): Use PassWeak<T>, as
required by our new hash map and Weak<T> APIs.

Source/WebKit2:

• WebProcess/Plugins/Netscape/NPRuntimeObjectMap.cpp:

(WebKit::NPRuntimeObjectMap::getOrCreateJSObject): Use raw pointer and
PassWeak<T>, as required by our new hash map API.

File:

• trunk/Source/JavaScriptCore/heap/Weak.h (modified) (10 diffs)

trunk/Source/JavaScriptCore/heap/Weak.h

@@ -1 +1 @@
 /*
- * Copyright (C) 2009 Apple Inc. All rights reserved.
+ * Copyright (C) 2009, 2012 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31 +31 @@
 #include "HandleHeap.h"
 #include "JSGlobalData.h"
+#include "PassWeak.h"
 
 namespace JSC {
@@ -36 +37 @@
 // A weakly referenced handle that becomes 0 when the value it points to is garbage collected.
 template <typename T> class Weak : public Handle<T> {
+    WTF_MAKE_NONCOPYABLE(Weak);
+
     using Handle<T>::slot;
     using Handle<T>::setSlot;
@@ -47 +50 @@
     }
 
-    Weak(JSGlobalData& globalData, ExternalType value = ExternalType(), WeakHandleOwner* weakOwner = 0, void* context = 0)
+    Weak(std::nullptr_t)
+        : Handle<T>()
+    {
+    }
+
+    Weak(JSGlobalData& globalData, ExternalType externalType = ExternalType(), WeakHandleOwner* weakOwner = 0, void* context = 0)
         : Handle<T>(globalData.heap.handleHeap()->allocate())
     {
         HandleHeap::heapFor(slot())->makeWeak(slot(), weakOwner, context);
-        set(value);
+        JSValue value = HandleTypes<T>::toJSValue(externalType);
+        HandleHeap::heapFor(slot())->writeBarrier(slot(), value);
+        *slot() = value;
     }
 
@@ -60 +70 @@
         validateCell(get());
     }
-    
-    Weak(const Weak& other)
-        : Handle<T>()
-    {
-        if (!other.slot())
-            return;
-        setSlot(HandleHeap::heapFor(other.slot())->copyWeak(other.slot()));
-    }
 
-    template <typename U> Weak(const Weak<U>& other)
-        : Handle<T>()
-    {
-        if (!other.slot())
-            return;
-        setSlot(HandleHeap::heapFor(other.slot())->copyWeak(other.slot()));
-    }
-    
     enum HashTableDeletedValueTag { HashTableDeletedValue };
     bool isHashTableDeletedValue() const { return slot() == hashTableDeletedValue(); }
     Weak(HashTableDeletedValueTag)
         : Handle<T>(hashTableDeletedValue())
+    {
+    }
+
+    template<typename U> Weak(const PassWeak<U>& other)
+        : Handle<T>(other.leakHandle())
     {
     }
@@ -94 +93 @@
     }
 
+    Weak& operator=(const PassWeak<T>&);
+
     ExternalType get() const { return  HandleTypes<T>::getFromSlot(slot()); }
     
+    PassWeak<T> release() { PassWeak<T> tmp = adoptWeak<T>(slot()); setSlot(0); return tmp; }
+
     void clear()
     {
@@ -102 +105 @@
         HandleHeap::heapFor(slot())->deallocate(slot());
         setSlot(0);
-    }
-    
-    void set(JSGlobalData& globalData, ExternalType value, WeakHandleOwner* weakOwner = 0, void* context = 0)
-    {
-        if (!slot()) {
-            setSlot(globalData.heap.handleHeap()->allocate());
-            HandleHeap::heapFor(slot())->makeWeak(slot(), weakOwner, context);
-        }
-        ASSERT(HandleHeap::heapFor(slot())->hasWeakOwner(slot(), weakOwner));
-        set(value);
-    }
-
-    template <typename U> Weak& operator=(const Weak<U>& other)
-    {
-        clear();
-        if (other.slot())
-            setSlot(HandleHeap::heapFor(other.slot())->copyWeak(other.slot()));
-        return *this;
-    }
-
-    Weak& operator=(const Weak& other)
-    {
-        clear();
-        if (other.slot())
-            setSlot(HandleHeap::heapFor(other.slot())->copyWeak(other.slot()));
-        return *this;
     }
     
@@ -140 +117 @@
 private:
     static HandleSlot hashTableDeletedValue() { return reinterpret_cast<HandleSlot>(-1); }
-
-    void set(ExternalType externalType)
-    {
-        ASSERT(slot());
-        JSValue value = HandleTypes<T>::toJSValue(externalType);
-        HandleHeap::heapFor(slot())->writeBarrier(slot(), value);
-        *slot() = value;
-    }
 };
 
@@ -153 +122 @@
 {
     a.swap(b);
+}
+
+template<typename T> inline Weak<T>& Weak<T>::operator=(const PassWeak<T>& o)
+{
+    clear();
+    setSlot(o.leakHandle());
+    return *this;
 }
 
@@ -163 +139 @@
 };
 
-template<typename P> struct HashTraits<JSC::Weak<P> > : SimpleClassHashTraits<JSC::Weak<P> > { };
+template<typename T> struct HashTraits<JSC::Weak<T> > : SimpleClassHashTraits<JSC::Weak<T> > {
+    typedef JSC::Weak<T> StorageType;
+
+    typedef std::nullptr_t EmptyValueType;
+    static EmptyValueType emptyValue() { return EmptyValueType(); }
+
+    typedef JSC::PassWeak<T> PassInType;
+    static void store(PassInType value, StorageType& storage) { storage = value; }
+
+    typedef JSC::PassWeak<T> PassOutType;
+    static PassOutType passOut(StorageType& value) { return value.release(); }
+    static PassOutType passOut(EmptyValueType) { return PassOutType(); }
+
+    typedef typename StorageType::ExternalType PeekType;
+    static PeekType peek(const StorageType& value) { return value.get(); }
+    static PeekType peek(EmptyValueType) { return PeekType(); }
+};
 
 }