2011-04-07 Geoffrey Garen <ggaren@apple.com>
authorggaren@apple.com <ggaren@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 8 Apr 2011 06:34:47 +0000 (06:34 +0000)
committerggaren@apple.com <ggaren@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 8 Apr 2011 06:34:47 +0000 (06:34 +0000)
        Reviewed by Maciej Stachowiak.

        Some Handle<T> cleanup
        https://bugs.webkit.org/show_bug.cgi?id=58109

        * bytecode/SamplingTool.h: Sorted alphabetically because that's the
        WebKit style. Added a Global.h #include that was previously missing
        but harmless.

        * collector/handles/Global.h:
        (JSC::Global::Global): Added a null constructor. No need for a special
        tag, and the tag is incompatible with some data structures.

        (JSC::Global::isHashTableDeletedValue):
        (JSC::Global::~Global):
        (JSC::Global::set):
        (JSC::Global::operator=):
        (JSC::Global::clear):
        (JSC::Global::hashTableDeletedValue): Reordered constructors to be near
        each other.

        (JSC::Global::setWithWriteBarrier): Renamed internalSet to
        setWithWriteBarrier for clarity, and funneled more code into using set
        and setWithWriteBarrier to reduce duplication.

        * collector/handles/Handle.h:
        (JSC::HandleBase::operator!):
        (JSC::HandleBase::HandleBase): Removed isEmpty(), since we already have
        boolean and ! operators.

        (JSC::HandleBase::slot):
        (JSC::HandleBase::setSlot):
        (JSC::Handle::Handle): Added general support for null Handles. This was
        previously outlawed by ASSERTs, but our code has grown to support and
        rely on null Handles.

        * collector/handles/HandleHeap.cpp:
        (JSC::HandleHeap::markWeakHandles):
        (JSC::HandleHeap::finalizeWeakHandles):
        (JSC::HandleHeap::isValidWeakNode): Migrated from isValidWeakHandle,
        and beefed this up a bit.

        * collector/handles/HandleHeap.h:
        (JSC::HandleHeap::globalData): Added accessor, used by some new set functions.

        * collector/handles/Local.h: Moved hash traits to the bottom of the file,
        since this file is about the Local class, not the traits.

        (JSC::::Local): Updated for removal of invalidate().

        (JSC::::operator): Deployed "using" to avoid a lot of this->
        template funny business.

        (JSC::::setWithSlotCheck): Renamed from internalSet, more specific now.

        * interpreter/RegisterFile.h:
        (JSC::RegisterFile::RegisterFile): Updated to use null constructor.

        * jit/JITStubs.cpp:
        (JSC::JITThunks::hostFunctionStub):

        * runtime/JSPropertyNameIterator.h:
        (JSC::Structure::setEnumerationCache):
        * runtime/Structure.h: Removed clearEnumerationCache
        because it was an unused holdover from when the enumeration cache was
        not a handle.

        * runtime/WeakGCMap.h:
        (JSC::WeakGCMap::set): Finish initializing our handle before putting it
        in the table. This seemed more logical, and at one point was required
        to avoid triggering an ASSERT.

        * runtime/WeakGCPtr.h: Inherit from Handle instead of rolling our own
        handle-like behavior, to avoid duplication.

        (JSC::WeakGCPtr::WeakGCPtr):
        (JSC::WeakGCPtr::~WeakGCPtr):
        (JSC::WeakGCPtr::get):
        (JSC::WeakGCPtr::clear):
        (JSC::WeakGCPtr::set):
        (JSC::WeakGCPtr::setWithWriteBarrier): Removed duplicate code and
        standardized on Handle idioms.
2011-04-07  Geoffrey Garen  <ggaren@apple.com>

        Reviewed by Maciej Stachowiak.

        Some Handle<T> cleanup
        https://bugs.webkit.org/show_bug.cgi?id=58109

        * JSRun.h:
        * JSValueWrapper.h: #include a file that was missing before, but was
        harmlessly so until now.
2011-04-07  Geoffrey Garen  <ggaren@apple.com>

        Reviewed by Maciej Stachowiak.

        Some Handle<T> cleanup
        https://bugs.webkit.org/show_bug.cgi?id=58109

        * bindings/js/ScriptValue.h:
        (WebCore::ScriptValue::ScriptValue): Updated for new null constructor.
        (WebCore::ScriptValue::hasNoValue): Updated for removal of isEmpty().
2011-04-07  Geoffrey Garen  <ggaren@apple.com>

        Some Handle<T> cleanup
        https://bugs.webkit.org/show_bug.cgi?id=58109

        * WebProcess/Plugins/Netscape/NPJSObject.cpp:
        (WebKit::NPJSObject::NPJSObject): Updated for new null constructor.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@83259 268f45cc-cd09-0410-ab3c-d52691b4dbfc

22 files changed:
Source/JavaScriptCore/ChangeLog
Source/JavaScriptCore/bytecode/SamplingTool.h
Source/JavaScriptCore/collector/handles/Global.h
Source/JavaScriptCore/collector/handles/Handle.h
Source/JavaScriptCore/collector/handles/HandleHeap.cpp
Source/JavaScriptCore/collector/handles/HandleHeap.h
Source/JavaScriptCore/collector/handles/Local.h
Source/JavaScriptCore/interpreter/RegisterFile.h
Source/JavaScriptCore/jit/JITStubs.cpp
Source/JavaScriptCore/runtime/JSPropertyNameIterator.h
Source/JavaScriptCore/runtime/Structure.h
Source/JavaScriptCore/runtime/WeakGCMap.h
Source/JavaScriptCore/runtime/WeakGCPtr.h
Source/JavaScriptGlue/ChangeLog
Source/JavaScriptGlue/JSRun.h
Source/JavaScriptGlue/JSValueWrapper.h
Source/WebCore/ChangeLog
Source/WebCore/bindings/js/ScriptValue.h
Source/WebCore/dom/EventTarget.cpp
Source/WebCore/dom/EventTarget.h
Source/WebKit2/ChangeLog
Source/WebKit2/WebProcess/Plugins/Netscape/NPJSObject.cpp

index 5a0b280..0c349e7 100644 (file)
@@ -1,3 +1,88 @@
+2011-04-07  Geoffrey Garen  <ggaren@apple.com>
+
+        Reviewed by Maciej Stachowiak.
+
+        Some Handle<T> cleanup
+        https://bugs.webkit.org/show_bug.cgi?id=58109
+
+        * bytecode/SamplingTool.h: Sorted alphabetically because that's the
+        WebKit style. Added a Global.h #include that was previously missing
+        but harmless.
+
+        * collector/handles/Global.h:
+        (JSC::Global::Global): Added a null constructor. No need for a special
+        tag, and the tag is incompatible with some data structures.
+        
+        (JSC::Global::isHashTableDeletedValue):
+        (JSC::Global::~Global):
+        (JSC::Global::set):
+        (JSC::Global::operator=):
+        (JSC::Global::clear):
+        (JSC::Global::hashTableDeletedValue): Reordered constructors to be near
+        each other.
+
+        (JSC::Global::setWithWriteBarrier): Renamed internalSet to
+        setWithWriteBarrier for clarity, and funneled more code into using set
+        and setWithWriteBarrier to reduce duplication.
+
+        * collector/handles/Handle.h:
+        (JSC::HandleBase::operator!):
+        (JSC::HandleBase::HandleBase): Removed isEmpty(), since we already have
+        boolean and ! operators.
+
+        (JSC::HandleBase::slot):
+        (JSC::HandleBase::setSlot):
+        (JSC::Handle::Handle): Added general support for null Handles. This was
+        previously outlawed by ASSERTs, but our code has grown to support and
+        rely on null Handles.
+        
+        * collector/handles/HandleHeap.cpp:
+        (JSC::HandleHeap::markWeakHandles):
+        (JSC::HandleHeap::finalizeWeakHandles):
+        (JSC::HandleHeap::isValidWeakNode): Migrated from isValidWeakHandle,
+        and beefed this up a bit.
+
+        * collector/handles/HandleHeap.h:
+        (JSC::HandleHeap::globalData): Added accessor, used by some new set functions.
+
+        * collector/handles/Local.h: Moved hash traits to the bottom of the file,
+        since this file is about the Local class, not the traits.
+
+        (JSC::::Local): Updated for removal of invalidate().
+
+        (JSC::::operator): Deployed "using" to avoid a lot of this->
+        template funny business.
+
+        (JSC::::setWithSlotCheck): Renamed from internalSet, more specific now.
+
+        * interpreter/RegisterFile.h:
+        (JSC::RegisterFile::RegisterFile): Updated to use null constructor.
+
+        * jit/JITStubs.cpp:
+        (JSC::JITThunks::hostFunctionStub):
+
+        * runtime/JSPropertyNameIterator.h:
+        (JSC::Structure::setEnumerationCache):
+        * runtime/Structure.h: Removed clearEnumerationCache
+        because it was an unused holdover from when the enumeration cache was
+        not a handle.
+
+        * runtime/WeakGCMap.h:
+        (JSC::WeakGCMap::set): Finish initializing our handle before putting it
+        in the table. This seemed more logical, and at one point was required
+        to avoid triggering an ASSERT.
+
+        * runtime/WeakGCPtr.h: Inherit from Handle instead of rolling our own
+        handle-like behavior, to avoid duplication.
+
+        (JSC::WeakGCPtr::WeakGCPtr):
+        (JSC::WeakGCPtr::~WeakGCPtr):
+        (JSC::WeakGCPtr::get):
+        (JSC::WeakGCPtr::clear):
+        (JSC::WeakGCPtr::set):
+        (JSC::WeakGCPtr::setWithWriteBarrier): Removed duplicate code and
+        standardized on Handle idioms.
+
 2011-04-07  Adam Barth  <abarth@webkit.org>
 
         Reviewed by Martin Robinson.
index a0696b1..03a4c84 100644 (file)
 #ifndef SamplingTool_h
 #define SamplingTool_h
 
+#include "Global.h"
+#include "Nodes.h"
+#include "Opcode.h"
 #include <wtf/Assertions.h>
 #include <wtf/HashMap.h>
 #include <wtf/Threading.h>
 
-#include "Nodes.h"
-#include "Opcode.h"
-
 namespace JSC {
 
     class ScriptExecutable;
index 571fe31..10f5db0 100644 (file)
 
 namespace JSC {
 
-/*
-    A Global is a persistent handle whose lifetime is not limited to any given
-    scope. Use Globals for data members and global variables.
-*/
-
+// A Global is a persistent handle whose lifetime is not limited to any given scope.
 template <typename T> class Global : public Handle<T> {
+    using Handle<T>::slot;
+    using Handle<T>::setSlot;
+
 public:
     typedef typename Handle<T>::ExternalType ExternalType;
-    Global(JSGlobalData& globalData, ExternalType ptr = ExternalType())
+    
+    Global()
+        : Handle<T>()
+    {
+    }
+    
+    Global(JSGlobalData& globalData, ExternalType value = ExternalType())
         : Handle<T>(globalData.allocateGlobalHandle())
     {
-        internalSet(ptr);
+        set(value);
     }
 
     Global(JSGlobalData& globalData, Handle<T> handle)
         : Handle<T>(globalData.allocateGlobalHandle())
     {
-        internalSet(handle.get());
+        set(handle.get());
+    }
+    
+    Global(const Global& other)
+        : Handle<T>()
+    {
+        if (!other.slot())
+            return;
+        setSlot(HandleHeap::heapFor(other.slot())->allocate());
+        set(other.get());
+    }
+
+    template <typename U> Global(const Global<U>& other)
+        : Handle<T>()
+    {
+        if (!other.slot())
+            return;
+        setSlot(HandleHeap::heapFor(other.slot())->allocate());
+        set(other.get());
     }
     
-    enum EmptyValueTag { EmptyValue };
-    Global(EmptyValueTag)
-        : Handle<T>(0, HandleBase::DontNullCheckSlot)
+    enum HashTableDeletedValueTag { HashTableDeletedValue };
+    bool isHashTableDeletedValue() const { return slot() == hashTableDeletedValue(); }
+    Global(HashTableDeletedValueTag)
+        : Handle<T>(hashTableDeletedValue())
     {
     }
 
     ~Global()
     {
-        HandleSlot slot = this->slot();
-        if (slot)
-            HandleHeap::heapFor(slot)->deallocate(slot);
+        clear();
     }
 
     void set(JSGlobalData& globalData, ExternalType value)
     {
-        if (!value) {
-            clear();
-            return;
-        }
-        if (!this->slot())
-            this->setSlot(globalData.allocateGlobalHandle());
-        internalSet(value);
+        if (!slot())
+            setSlot(globalData.allocateGlobalHandle());
+        set(value);
     }
 
-    template <typename U> Global& operator=(const Global<U>& handle)
+    template <typename U> Global& operator=(const Global<U>& other)
     {
-        if (handle.slot()) {
-            if (!this->slot())
-                this->setSlot(HandleHeap::heapFor(handle.slot())->allocate());
-            internalSet(handle.get());
-        } else
+        if (!other.slot()) {
             clear();
-        
+            return *this;
+        }
+
+        set(*HandleHeap::heapFor(other.slot())->globalData(), other.get());
         return *this;
     }
     
-    Global& operator=(const Global& handle)
+    Global& operator=(const Global& other)
     {
-        if (handle.slot()) {
-            if (!this->slot())
-                this->setSlot(HandleHeap::heapFor(handle.slot())->allocate());
-            internalSet(handle.get());
-        } else
+        if (!other.slot()) {
             clear();
-        
+            return *this;
+        }
+
+        set(*HandleHeap::heapFor(other.slot())->globalData(), other.get());
         return *this;
     }
 
     void clear()
     {
-        if (this->slot())
-            internalSet(ExternalType());
+        if (!slot())
+            return;
+        HandleHeap::heapFor(slot())->deallocate(slot());
+        setSlot(0);
     }
 
-    enum HashTableDeletedValueType { HashTableDeletedValue };
-    const static intptr_t HashTableDeletedValueTag = 0x1;
-    Global(HashTableDeletedValueType)
-        : Handle<T>(reinterpret_cast<HandleSlot>(HashTableDeletedValueTag))
-    {
-    }
-    bool isHashTableDeletedValue() const { return slot() == reinterpret_cast<HandleSlot>(HashTableDeletedValueTag); }
+private:
+    static HandleSlot hashTableDeletedValue() { return reinterpret_cast<HandleSlot>(-1); }
 
-    template <typename U> Global(const Global<U>& other)
-        : Handle<T>(other.slot() ? HandleHeap::heapFor(other.slot())->allocate() : 0, Handle<T>::DontNullCheckSlot)
+    void set(ExternalType externalType)
     {
-        if (other.slot())
-            internalSet(other.get());
+        ASSERT(slot());
+        JSValue value = HandleTypes<T>::toJSValue(externalType);
+        HandleHeap::heapFor(slot())->writeBarrier(slot(), value);
+        *slot() = value;
     }
-    
-    Global(const Global& other)
-        : Handle<T>(other.slot() ? HandleHeap::heapFor(other.slot())->allocate() : 0, Handle<T>::DontNullCheckSlot)
-    {
-        if (other.slot())
-            internalSet(other.get());
-    }
-
-protected:
-    void internalSet(ExternalType value)
-    {
-        JSValue newValue(HandleTypes<T>::toJSValue(value));
-        HandleSlot slot = this->slot();
-        ASSERT(slot);
-        HandleHeap::heapFor(slot)->writeBarrier(slot, newValue);
-        *slot = newValue;
-    }
-
-    using Handle<T>::slot;
-    
 };
 
 }
@@ -149,7 +143,7 @@ namespace WTF {
 
 template<typename P> struct HashTraits<JSC::Global<P> > : GenericHashTraits<JSC::Global<P> > {
     static const bool emptyValueIsZero = true;
-    static JSC::Global<P> emptyValue() { return JSC::Global<P>(JSC::Global<P>::EmptyValue); }
+    static JSC::Global<P> emptyValue() { return JSC::Global<P>(); }
     static void constructDeletedValue(JSC::Global<P>& slot) { new (&slot) JSC::Global<P>(JSC::Global<P>::HashTableDeletedValue); }
     static bool isDeletedValue(const JSC::Global<P>& value) { return value.isHashTableDeletedValue(); }
 };
index c1d8a35..6d08242 100644 (file)
@@ -49,39 +49,21 @@ class HandleBase {
     friend class HandleHeap;
 
 public:
-    bool operator!() const { return isEmpty(); }
+    bool operator!() const { return !m_slot || !*m_slot; }
 
     // This conversion operator allows implicit conversion to bool but not to other integer types.
     typedef JSValue (HandleBase::*UnspecifiedBoolType);
     operator UnspecifiedBoolType*() const { return (m_slot && *m_slot) ? reinterpret_cast<UnspecifiedBoolType*>(1) : 0; }
 
-    bool isEmpty() const { return !m_slot || !*m_slot; }
-
 protected:
     HandleBase(HandleSlot slot)
         : m_slot(slot)
     {
-        ASSERT(slot);
     }
 
-    enum DontNullCheckSlotTag { DontNullCheckSlot };
-    HandleBase(HandleSlot slot, DontNullCheckSlotTag)
-        : m_slot(slot)
-    {
-    }
-    
     HandleSlot slot() const { return m_slot; }
-    void invalidate()
-    {
-        // It is unsafe to use a handle after invalidating it.
-        m_slot = 0;
-    }
-
-    // needed by Global<>::operator= and Global<>::set if it's an empty handle
     void setSlot(HandleSlot slot)
     {
-        ASSERT(!m_slot);
-        ASSERT(slot);
         m_slot = slot;
     }
 
@@ -165,15 +147,10 @@ public:
     ExternalType get() const { return HandleTypes<T>::getFromSlot(this->slot()); }
 
 protected:
-
-    Handle(HandleSlot slot)
+    Handle(HandleSlot slot = 0)
         : HandleBase(slot)
     {
     }
-    Handle(HandleSlot slot, HandleBase::DontNullCheckSlotTag)
-        : HandleBase(slot, HandleBase::DontNullCheckSlot)
-    {
-    }
     
 private:
     friend class HandleHeap;
index 51a4a7e..b1505f4 100644 (file)
 
 namespace JSC {
 
-#if !ASSERT_DISABLED
-static inline bool isValidWeakHandle(HandleSlot handle)
-{
-    JSValue value = *handle;
-    if (!value || !value.isCell())
-        return false;
-
-    JSCell* cell = value.asCell();
-    if (!cell || !cell->structure())
-        return false;
-
-#if ENABLE(JSC_ZOMBIES)
-    if (cell->isZombie())
-        return false;
-#endif
-
-    return true;
-}
-#endif
-
 WeakHandleOwner::~WeakHandleOwner()
 {
 }
@@ -97,7 +77,7 @@ void HandleHeap::markWeakHandles(HeapRootMarker& heapRootMarker)
 
         Node* end = m_weakList.end();
         for (Node* node = m_weakList.begin(); node != end; node = node->next()) {
-            ASSERT(isValidWeakHandle(node->slot()));
+            ASSERT(isValidWeakNode(node));
             JSCell* cell = node->slot()->asCell();
             if (Heap::isMarked(cell))
                 continue;
@@ -120,7 +100,7 @@ void HandleHeap::finalizeWeakHandles()
     for (Node* node = m_weakList.begin(); node != end; node = m_nextToFinalize) {
         m_nextToFinalize = node->next();
 
-        ASSERT(isValidWeakHandle(node->slot()));
+        ASSERT(isValidWeakNode(node));
         JSCell* cell = node->slot()->asCell();
         if (Heap::isMarked(cell))
             continue;
@@ -173,4 +153,27 @@ unsigned HandleHeap::protectedGlobalObjectCount()
     return count;
 }
 
+#if !ASSERT_DISABLED
+bool HandleHeap::isValidWeakNode(Node* node)
+{
+    if (!node->isWeak())
+        return false;
+
+    JSValue value = *node->slot();
+    if (!value || !value.isCell())
+        return false;
+
+    JSCell* cell = value.asCell();
+    if (!cell || !cell->structure())
+        return false;
+
+#if ENABLE(JSC_ZOMBIES)
+    if (cell->isZombie())
+        return false;
+#endif
+
+    return true;
+}
+#endif
+
 } // namespace JSC
index ad68c9a..0559e7b 100644 (file)
@@ -51,6 +51,8 @@ public:
     static HandleHeap* heapFor(HandleSlot);
 
     HandleHeap(JSGlobalData*);
+    
+    JSGlobalData* globalData();
 
     HandleSlot allocate();
     void deallocate(HandleSlot);
@@ -105,6 +107,10 @@ private:
     static Node* toNode(HandleSlot);
 
     void grow();
+    
+#if !ASSERT_DISABLED
+    bool isValidWeakNode(Node*);
+#endif
 
     JSGlobalData* m_globalData;
     BlockStack<Node> m_blockStack;
@@ -121,6 +127,11 @@ inline HandleHeap* HandleHeap::heapFor(HandleSlot handle)
     return toNode(handle)->handleHeap();
 }
 
+inline JSGlobalData* HandleHeap::globalData()
+{
+    return m_globalData;
+}
+
 inline HandleSlot HandleHeap::toHandle(Node* node)
 {
     return reinterpret_cast<HandleSlot>(node);
index 035e9e9..0458099 100644 (file)
 */
 
 namespace JSC {
-template <typename T> class Local;
-}
-
-namespace WTF {
-
-template<typename T> struct VectorTraits<JSC::Local<T> > {
-    static const bool needsDestruction = false;
-    static const bool needsInitialization = true;
-    static const bool canInitializeWithMemset = false;
-    static const bool canMoveWithMemcpy = true;
-    static const bool canCopyWithMemcpy = false;
-    static const bool canFillWithMemset = false;
-    static const bool canCompareWithMemcmp = true;
-};
-
-}
-
-namespace JSC {
 
 template <typename T> class Local : public Handle<T> {
     friend class LocalScope;
+    using Handle<T>::slot;
+
 public:
     typedef typename Handle<T>::ExternalType ExternalType;
+
     Local(JSGlobalData&, ExternalType = ExternalType());
     Local(JSGlobalData&, Handle<T>);
     Local(const Local<T>&); // Adopting constructor. Used to return a Local to a calling function.
 
     Local& operator=(ExternalType);
     Local& operator=(Handle<T>);
-    
-    using Handle<T>::slot;
 
 private:
     Local(HandleSlot, ExternalType); // Used by LocalScope::release() to move a Local to a containing scope.
-    void internalSet(ExternalType value)
-    {
-        JSValue newValue(HandleTypes<T>::toJSValue(value));
-        HandleSlot slot = this->slot();
-        *slot = newValue;
-    }
+    void set(ExternalType);
 };
 
 template <typename T> inline Local<T>::Local(JSGlobalData& globalData, ExternalType value)
     : Handle<T>(globalData.allocateLocalHandle())
 {
-    internalSet(value);
+    set(value);
 }
 
-template <typename T> inline Local<T>::Local(JSGlobalData& globalData, Handle<T> handle)
+template <typename T> inline Local<T>::Local(JSGlobalData& globalData, Handle<T> other)
     : Handle<T>(globalData.allocateLocalHandle())
 {
-    internalSet(handle.get());
+    set(other.get());
 }
 
-template <typename T> inline Local<T>::Local(const Local<T>& o)
-    : Handle<T>(o.slot())
+template <typename T> inline Local<T>::Local(const Local<T>& other)
+    : Handle<T>(other.slot())
 {
-    const_cast<Local<T>&>(o).invalidate(); // Prevent accidental sharing.
+    const_cast<Local<T>&>(other).setSlot(0); // Prevent accidental sharing.
 }
 
 template <typename T> inline Local<T>::Local(HandleSlot slot, ExternalType value)
@@ -103,16 +81,23 @@ template <typename T> inline Local<T>::Local(HandleSlot slot, ExternalType value
 
 template <typename T> inline Local<T>& Local<T>::operator=(ExternalType value)
 {
-    internalSet(value);
+    set(value);
     return *this;
 }
 
-template <typename T> inline Local<T>& Local<T>::operator=(Handle<T> handle)
+template <typename T> inline Local<T>& Local<T>::operator=(Handle<T> other)
 {
-    internalSet(handle.get());
+    set(other.get());
     return *this;
 }
 
+template <typename T> inline void Local<T>::set(ExternalType value)
+{
+    ASSERT(slot());
+    *slot() = value;
+}
+
+
 template <typename T, unsigned inlineCapacity = 0> class LocalStack {
     typedef typename Handle<T>::ExternalType ExternalType;
 public:
@@ -154,4 +139,18 @@ private:
 
 }
 
+namespace WTF {
+
+template<typename T> struct VectorTraits<JSC::Local<T> > {
+    static const bool needsDestruction = false;
+    static const bool needsInitialization = true;
+    static const bool canInitializeWithMemset = false;
+    static const bool canMoveWithMemcpy = true;
+    static const bool canCopyWithMemcpy = false;
+    static const bool canFillWithMemset = false;
+    static const bool canCompareWithMemcmp = true;
+};
+
+}
+
 #endif
index 7eaecae..70a0b92 100644 (file)
@@ -167,7 +167,7 @@ namespace JSC {
         , m_start(0)
         , m_end(0)
         , m_max(0)
-        , m_globalObject(globalData, &m_globalObjectOwner, this)
+        , m_globalObject(globalData, 0, &m_globalObjectOwner, this)
     {
         ASSERT(maxGlobals && isPageAligned(maxGlobals));
         ASSERT(capacity && isPageAligned(capacity));
index cac9f02..db415c5 100644 (file)
@@ -3495,7 +3495,7 @@ MacroAssemblerCodePtr JITThunks::ctiStub(JSGlobalData* globalData, ThunkGenerato
 
 NativeExecutable* JITThunks::hostFunctionStub(JSGlobalData* globalData, NativeFunction function)
 {
-    std::pair<HostFunctionStubMap::iterator, bool> entry = m_hostFunctionStubMap->add(function, Global<NativeExecutable>(Global<NativeExecutable>::EmptyValue));
+    std::pair<HostFunctionStubMap::iterator, bool> entry = m_hostFunctionStubMap->add(function, Global<NativeExecutable>());
     if (entry.second)
         entry.first->second.set(*globalData, NativeExecutable::create(*globalData, JIT::compileCTINativeCall(globalData, m_executablePool, function), function, ctiNativeConstruct(), callHostFunctionAsConstructor));
     return entry.first->second.get();
@@ -3503,7 +3503,7 @@ NativeExecutable* JITThunks::hostFunctionStub(JSGlobalData* globalData, NativeFu
 
 NativeExecutable* JITThunks::hostFunctionStub(JSGlobalData* globalData, NativeFunction function, ThunkGenerator generator)
 {
-    std::pair<HostFunctionStubMap::iterator, bool> entry = m_hostFunctionStubMap->add(function, Global<NativeExecutable>(Global<NativeExecutable>::EmptyValue));
+    std::pair<HostFunctionStubMap::iterator, bool> entry = m_hostFunctionStubMap->add(function, Global<NativeExecutable>());
     if (entry.second) {
         MacroAssemblerCodePtr code = globalData->canUseJIT() ? generator(globalData, m_executablePool.get()) : MacroAssemblerCodePtr();
         entry.first->second.set(*globalData, NativeExecutable::create(*globalData, code, function, ctiNativeConstruct(), callHostFunctionAsConstructor));
index 499396c..f98c40e 100644 (file)
@@ -93,12 +93,7 @@ namespace JSC {
     inline void Structure::setEnumerationCache(JSGlobalData& globalData, JSPropertyNameIterator* enumerationCache)
     {
         ASSERT(!isDictionary());
-        m_enumerationCache.set(globalData, enumerationCache, 0);
-    }
-
-    inline void Structure::clearEnumerationCache()
-    {
-        m_enumerationCache.clear();
+        m_enumerationCache.set(globalData, enumerationCache);
     }
 
     inline JSPropertyNameIterator* Structure::enumerationCache()
index 46e4670..15d95c4 100644 (file)
@@ -142,7 +142,6 @@ namespace JSC {
         void disableSpecificFunctionTracking() { m_specificFunctionThrashCount = maxSpecificFunctionThrashCount; }
 
         void setEnumerationCache(JSGlobalData&, JSPropertyNameIterator* enumerationCache); // Defined in JSPropertyNameIterator.h.
-        void clearEnumerationCache(); // Defined in JSPropertyNameIterator.h.
         JSPropertyNameIterator* enumerationCache(); // Defined in JSPropertyNameIterator.h.
         void getPropertyNames(PropertyNameArray&, EnumerationMode mode);
 
index 8038ffb..2aff09a 100644 (file)
@@ -94,8 +94,8 @@ public:
         HandleSlot slot = iter.first->second;
         if (iter.second) {
             slot = globalData.allocateGlobalHandle();
-            iter.first->second = slot;
             HandleHeap::heapFor(slot)->makeWeak(slot, this, key);
+            iter.first->second = slot;
         }
         HandleHeap::heapFor(slot)->writeBarrier(slot, value);
         *slot = value;
index 9a66203..4e3a446 100644 (file)
 #ifndef WeakGCPtr_h
 #define WeakGCPtr_h
 
-#include "Global.h"
-#include "Heap.h"
+#include "Assertions.h"
+#include "Handle.h"
+#include "HandleHeap.h"
+#include "JSGlobalData.h"
 
 namespace JSC {
-// A smart pointer whose get() function returns 0 for cells that have died
 
-template <typename T> class WeakGCPtr : public HandleConverter<WeakGCPtr<T>, T> {
-    WTF_MAKE_NONCOPYABLE(WeakGCPtr);
+// A smart pointer that becomes 0 when the value it points to is garbage collected.
+template <typename T> class WeakGCPtr : public Handle<T> {
+    using Handle<T>::slot;
+    using Handle<T>::setSlot;
 
 public:
-    typedef typename HandleTypes<T>::ExternalType ExternalType;
-    
+    typedef typename Handle<T>::ExternalType ExternalType;
+
     WeakGCPtr()
-        : m_slot(0)
+        : Handle<T>()
     {
     }
-    
-    WeakGCPtr(JSGlobalData& globalData, WeakHandleOwner* weakOwner = 0, void* context = 0)
-        : m_slot(globalData.allocateGlobalHandle())
+
+    WeakGCPtr(JSGlobalData& globalData, ExternalType value = ExternalType(), WeakHandleOwner* weakOwner = 0, void* context = 0)
+        : Handle<T>(globalData.allocateGlobalHandle())
     {
-        HandleHeap::heapFor(m_slot)->makeWeak(m_slot, weakOwner, context);
+        HandleHeap::heapFor(slot())->makeWeak(slot(), weakOwner, context);
+        set(value);
     }
-    
-    WeakGCPtr(JSGlobalData& globalData, ExternalType value, WeakHandleOwner* weakOwner = 0, void* context = 0)
-        : m_slot(globalData.allocateGlobalHandle())
+
+    WeakGCPtr(const WeakGCPtr& other)
+        : Handle<T>()
     {
-        HandleHeap::heapFor(m_slot)->makeWeak(m_slot, weakOwner, context);
-        internalSet(value);
+        if (!other.slot())
+            return;
+        setSlot(HandleHeap::heapFor(other.slot())->allocate());
+        set(other.get());
     }
 
-    ExternalType get() const { return  HandleTypes<T>::getFromSlot(m_slot); }
-    
-    void clear()
+    template <typename U> WeakGCPtr(const WeakGCPtr<U>& other)
+        : Handle<T>()
     {
-        if (m_slot)
-            internalSet(ExternalType());
+        if (!other.slot())
+            return;
+        setSlot(HandleHeap::heapFor(other.slot())->allocate());
+        set(other.get());
     }
     
-    bool operator!() const { return !m_slot || !*m_slot; }
-
-    // This conversion operator allows implicit conversion to bool but not to other integer types.
-    typedef ExternalType (WeakGCPtr::*UnspecifiedBoolType);
-    operator UnspecifiedBoolType*() const { return !*this ? 0 : reinterpret_cast<UnspecifiedBoolType*>(1); }
-
     ~WeakGCPtr()
     {
-        if (!m_slot)
-            return;
-        HandleHeap::heapFor(m_slot)->deallocate(m_slot);
+        clear();
     }
 
+    ExternalType get() const { return  HandleTypes<T>::getFromSlot(slot()); }
+    
+    void clear()
+    {
+        if (!slot())
+            return;
+        HandleHeap::heapFor(slot())->deallocate(slot());
+        setSlot(0);
+    }
+    
     void set(JSGlobalData& globalData, ExternalType value, WeakHandleOwner* weakOwner = 0, void* context = 0)
     {
-        if (!this->m_slot) {
-            this->m_slot = globalData.allocateGlobalHandle();
-            HandleHeap::heapFor(this->m_slot)->makeWeak(this->m_slot, weakOwner, context);
+        if (!slot()) {
+            setSlot(globalData.allocateGlobalHandle());
+            HandleHeap::heapFor(slot())->makeWeak(slot(), weakOwner, context);
         }
-        ASSERT(HandleHeap::heapFor(this->m_slot)->hasWeakOwner(this->m_slot, weakOwner));
-        this->internalSet(value);
+        ASSERT(HandleHeap::heapFor(slot())->hasWeakOwner(slot(), weakOwner));
+        set(value);
     }
 
 private:
-    void internalSet(ExternalType value)
+    void set(ExternalType externalType)
     {
-        ASSERT(m_slot);
-        JSValue newValue(HandleTypes<T>::toJSValue(value));
-        HandleHeap::heapFor(m_slot)->writeBarrier(m_slot, newValue);
-        *m_slot = newValue;
+        ASSERT(slot());
+        JSValue value = HandleTypes<T>::toJSValue(externalType);
+        HandleHeap::heapFor(slot())->writeBarrier(slot(), value);
+        *slot() = value;
     }
-
-    HandleSlot m_slot;
 };
 
 } // namespace JSC
index a222748..d591c11 100644 (file)
@@ -1,3 +1,14 @@
+2011-04-07  Geoffrey Garen  <ggaren@apple.com>
+
+        Reviewed by Maciej Stachowiak.
+
+        Some Handle<T> cleanup
+        https://bugs.webkit.org/show_bug.cgi?id=58109
+
+        * JSRun.h:
+        * JSValueWrapper.h: #include a file that was missing before, but was
+        harmlessly so until now.
+
 2011-03-30  Timur Iskhodzhanov  <timurrrr@google.com>
 
         Reviewed by Alexey Proskuryakov.
index d7aa682..8dbe6fe 100644 (file)
@@ -29,6 +29,7 @@
 #ifndef JSRun_h
 #define JSRun_h
 
+#include <JavaScriptCore/Global.h>
 #include "JSBase.h"
 #include "JSUtils.h"
 
index 9d27f89..dcfaa5a 100644 (file)
@@ -29,6 +29,7 @@
 #ifndef JSValueWrapper_h
 #define JSValueWrapper_h
 
+#include <JavaScriptCore/Global.h>
 #include "JSUtils.h"
 #include "JSBase.h"
 #include "JSObject.h"
index 4379107..8218762 100644 (file)
@@ -1,3 +1,14 @@
+2011-04-07  Geoffrey Garen  <ggaren@apple.com>
+
+        Reviewed by Maciej Stachowiak.
+
+        Some Handle<T> cleanup
+        https://bugs.webkit.org/show_bug.cgi?id=58109
+
+        * bindings/js/ScriptValue.h:
+        (WebCore::ScriptValue::ScriptValue): Updated for new null constructor.
+        (WebCore::ScriptValue::hasNoValue): Updated for removal of isEmpty().
+
 2011-04-07  Dominic Cooney  <dominicc@google.com>
 
         Reviewed by Dimitri Glazkov.
index b69ace7..7592550 100644 (file)
@@ -45,7 +45,7 @@ class SerializedScriptValue;
 
 class ScriptValue {
 public:
-    ScriptValue() : m_value(JSC::Global<JSC::Unknown>::EmptyValue) { }
+    ScriptValue() { }
     ScriptValue(JSC::JSGlobalData& globalData, JSC::JSValue value) : m_value(globalData, value) {}
     virtual ~ScriptValue() {}
 
@@ -57,7 +57,7 @@ public:
     bool isUndefined() const;
     bool isObject() const;
     bool isFunction() const;
-    bool hasNoValue() const { return m_value.isEmpty(); }
+    bool hasNoValue() const { return !m_value; }
 
     bool operator==(const ScriptValue& other) const { return m_value == other.m_value; }
 
index d84d66b..62d4fa9 100644 (file)
@@ -209,10 +209,10 @@ bool EventTarget::addEventListener(const AtomicString& eventType, PassRefPtr<Eve
     EventTargetData* d = ensureEventTargetData();
 
     pair<EventListenerMap::iterator, bool> result = d->eventListenerMap.add(eventType, 0);
-    EventListenerVector*& entry = result.first->second;
+    OwnPtr<EventListenerVector>& entry = result.first->second;
     const bool isNewEntry = result.second;
     if (isNewEntry)
-        entry = new EventListenerVector();
+        entry = adoptPtr(new EventListenerVector());
 
     RegisteredEventListener registeredListener(listener, useCapture);
     if (!isNewEntry) {
@@ -233,7 +233,7 @@ bool EventTarget::removeEventListener(const AtomicString& eventType, EventListen
     EventListenerMap::iterator result = d->eventListenerMap.find(eventType);
     if (result == d->eventListenerMap.end())
         return false;
-    EventListenerVector* entry = result->second;
+    OwnPtr<EventListenerVector>& entry = result->second;
 
     RegisteredEventListener registeredListener(listener, useCapture);
     size_t index = entry->find(registeredListener);
@@ -241,10 +241,8 @@ bool EventTarget::removeEventListener(const AtomicString& eventType, EventListen
         return false;
 
     entry->remove(index);
-    if (entry->isEmpty()) {
-        delete entry;
+    if (entry->isEmpty())
         d->eventListenerMap.remove(result);
-    }
 
     // Notify firing events planning to invoke the listener at 'index' that
     // they have one less listener to invoke.
index 3544ce6..44d9db0 100644 (file)
@@ -84,7 +84,7 @@ namespace WebCore {
     typedef Vector<FiringEventIterator, 1> FiringEventIteratorVector;
 
     typedef Vector<RegisteredEventListener, 1> EventListenerVector;
-    typedef HashMap<AtomicString, EventListenerVector*> EventListenerMap;
+    typedef HashMap<AtomicString, OwnPtr<EventListenerVector>> EventListenerMap;
 
     struct EventTargetData {
         WTF_MAKE_NONCOPYABLE(EventTargetData); WTF_MAKE_FAST_ALLOCATED;
index 10b210b..b0654f6 100644 (file)
@@ -1,3 +1,11 @@
+2011-04-07  Geoffrey Garen  <ggaren@apple.com>
+
+        Some Handle<T> cleanup
+        https://bugs.webkit.org/show_bug.cgi?id=58109
+
+        * WebProcess/Plugins/Netscape/NPJSObject.cpp:
+        (WebKit::NPJSObject::NPJSObject): Updated for new null constructor.
+
 2011-04-07  Jessie Berlin  <jberlin@apple.com>
 
         Max build fix.
index 4c687f4..7720e88 100644 (file)
@@ -55,7 +55,6 @@ NPJSObject* NPJSObject::create(JSGlobalData& globalData, NPRuntimeObjectMap* obj
 
 NPJSObject::NPJSObject()
     : m_objectMap(0)
-    , m_jsObject(Global<JSObject>::EmptyValue)
 {
 }