2011-03-15 Geoffrey Garen <ggaren@apple.com>

        Reviewed by Oliver Hunt.

        Removed some more deprecated / unsafe append
        https://bugs.webkit.org/show_bug.cgi?id=56428

        * collector/handles/HandleStack.cpp:
        (JSC::HandleStack::mark):
        * collector/handles/HandleStack.h: Mark the handle stack using a HeapRoot
        marker, since it's a heap root.
        
        * runtime/ArgList.cpp:
        (JSC::MarkedArgumentBuffer::markLists):
        (JSC::MarkedArgumentBuffer::slowAppend):
        * runtime/ArgList.h: Ditto.

        * runtime/Heap.cpp:
        (JSC::Heap::markRoots): Added a mark call for marking the handle stack.
        It seems like Oliver forgot this in his last patch. (!)

        * runtime/MarkStack.h: Removed appendSlots, since it would allow an
        object to embed JSValues directly instead of using WriteBarrier.

        (JSC::MarkStack::append): Added a private append for a list of values.

        (JSC::HeapRootMarker::mark): Access to the above.


git-svn-id: svn://svn.chromium.org/blink/trunk@81193 bbb929c8-8fbe-4397-9dbb-9b2b20218538

third_party/WebKit/Source/JavaScriptCore/ChangeLog

+2011-03-15  Geoffrey Garen  <ggaren@apple.com>
+
+        Reviewed by Oliver Hunt.
+
+        Removed some more deprecated / unsafe append
+        https://bugs.webkit.org/show_bug.cgi?id=56428
+
+        * collector/handles/HandleStack.cpp:
+        (JSC::HandleStack::mark):
+        * collector/handles/HandleStack.h: Mark the handle stack using a HeapRoot
+        marker, since it's a heap root.
+        
+        * runtime/ArgList.cpp:
+        (JSC::MarkedArgumentBuffer::markLists):
+        (JSC::MarkedArgumentBuffer::slowAppend):
+        * runtime/ArgList.h: Ditto.
+
+        * runtime/Heap.cpp:
+        (JSC::Heap::markRoots): Added a mark call for marking the handle stack.
+        It seems like Oliver forgot this in his last patch. (!)
+
+        * runtime/MarkStack.h: Removed appendSlots, since it would allow an
+        object to embed JSValues directly instead of using WriteBarrier.
+
+        (JSC::MarkStack::append): Added a private append for a list of values.
+
+        (JSC::HeapRootMarker::mark): Access to the above.
+
 2011-03-15  Geoffrey Garen  <ggaren@apple.com>
 
         Reviewed by Oliver Hunt.

third_party/WebKit/Source/JavaScriptCore/collector/handles/HandleStack.cpp

@@ -39,7 +39,7 @@ HandleStack::HandleStack()
     grow();
 }
 
-void HandleStack::mark(MarkStack& markStack)
+void HandleStack::mark(HeapRootMarker& heapRootMarker)
 {
     const Vector<HandleSlot>& blocks = m_blockStack.blocks();
     size_t blockLength = m_blockStack.blockLength;
@@ -47,10 +47,10 @@ void HandleStack::mark(MarkStack& markStack)
     int end = blocks.size() - 1;
     for (int i = 0; i < end; ++i) {
         HandleSlot block = blocks[i];
-        markStack.appendSlots(block, blockLength);
+        heapRootMarker.mark(block, blockLength);
     }
     HandleSlot block = blocks[end];
-    markStack.appendSlots(block, m_frame.m_next - block);
+    heapRootMarker.mark(block, m_frame.m_next - block);
 }
 
 void HandleStack::grow()

third_party/WebKit/Source/JavaScriptCore/collector/handles/HandleStack.h

@@ -35,7 +35,7 @@
 namespace JSC {
 
 class LocalScope;
-class MarkStack;
+class HeapRootMarker;
 
 class HandleStack {
 public:
@@ -52,7 +52,7 @@ public:
 
     HandleSlot push();
 
-    void mark(MarkStack&);
+    void mark(HeapRootMarker&);
 
 private:
     void grow();

third_party/WebKit/Source/JavaScriptCore/runtime/ArgList.cpp

@@ -39,12 +39,12 @@ void ArgList::getSlice(int startIndex, ArgList& result) const
     result = ArgList(m_args + startIndex, m_argCount - startIndex);
 }
 
-void MarkedArgumentBuffer::markLists(MarkStack& markStack, ListSet& markSet)
+void MarkedArgumentBuffer::markLists(HeapRootMarker& heapRootMarker, ListSet& markSet)
 {
     ListSet::iterator end = markSet.end();
     for (ListSet::iterator it = markSet.begin(); it != end; ++it) {
         MarkedArgumentBuffer* list = *it;
-        markStack.deprecatedAppendValues(list->m_buffer, list->m_size);
+        heapRootMarker.mark(reinterpret_cast<JSValue*>(list->m_buffer), list->m_size);
     }
 }
 
@@ -56,8 +56,8 @@ void MarkedArgumentBuffer::slowAppend(JSValue v)
     // our Vector's inline capacity, though, our values move to the 
     // heap, where they do need explicit marking.
     if (!m_markSet) {
-        // We can only register for explicit marking once we know which heap
-        // is the current one, i.e., when a non-immediate value is appended.
+        // FIXME: Even if v is not a JSCell*, if previous values in the buffer
+        // are, then they won't be marked!
         if (Heap* heap = Heap::heap(v)) {
             ListSet& markSet = heap->markListSet();
             markSet.add(this);

third_party/WebKit/Source/JavaScriptCore/runtime/ArgList.h

@@ -141,7 +141,7 @@ namespace JSC {
         const_iterator begin() const { return m_buffer; }
         const_iterator end() const { return m_buffer + m_size; }
 
-        static void markLists(MarkStack&, ListSet&);
+        static void markLists(HeapRootMarker&, ListSet&);
 
     private:
         void slowAppend(JSValue);

third_party/WebKit/Source/JavaScriptCore/runtime/Heap.cpp

@@ -227,12 +227,13 @@ void Heap::markRoots()
     markStack.drain();
 
     if (m_markListSet && m_markListSet->size())
-        MarkedArgumentBuffer::markLists(markStack, *m_markListSet);
+        MarkedArgumentBuffer::markLists(heapRootMarker, *m_markListSet);
     if (m_globalData->exception)
         heapRootMarker.mark(&m_globalData->exception);
     markStack.drain();
 
     m_handleHeap.markStrongHandles(markStack);
+    m_handleStack.mark(heapRootMarker);
 
     // Mark the small strings cache last, since it will clear itself if nothing
     // else has marked it.

third_party/WebKit/Source/JavaScriptCore/runtime/MarkStack.h

@@ -72,12 +72,6 @@ namespace JSC {
                 m_markSets.append(MarkSet(values, values + count, properties));
         }
         
-        void appendSlots(HandleSlot values, size_t count, MarkSetProperties properties = NoNullValues)
-        {
-            if (count)
-                m_markSets.append(MarkSet(values, values + count, properties));
-        }
-
         void append(ConservativeRoots& conservativeRoots)
         {
             JSCell** roots = conservativeRoots.roots();
@@ -98,6 +92,7 @@ namespace JSC {
     private:
         friend class HeapRootMarker; // Allowed to mark a JSValue* or JSCell** directly.
         void append(JSValue*);
+        void append(JSValue*, size_t count);
         void append(JSCell**);
 
         void internalAppend(JSCell*);
@@ -216,6 +211,13 @@ namespace JSC {
 #endif
     };
 
+    inline void MarkStack::append(JSValue* slot, size_t count)
+    {
+        if (!count)
+            return;
+        m_markSets.append(MarkSet(slot, slot + count, NoNullValues));
+    }
+
     // Privileged class for marking JSValues directly. It is only safe to use
     // this class to mark direct heap roots that are marked during every GC pass.
     // All other references should be wrapped in WriteBarriers and marked through
@@ -227,6 +229,7 @@ namespace JSC {
         
     public:
         void mark(JSValue*);
+        void mark(JSValue*, size_t);
         void mark(JSString**);
         void mark(JSCell**);
 
@@ -244,6 +247,11 @@ namespace JSC {
         m_markStack.append(slot);
     }
 
+    inline void HeapRootMarker::mark(JSValue* slot, size_t count)
+    {
+        m_markStack.append(slot, count);
+    }
+
     inline void HeapRootMarker::mark(JSString** slot)
     {
         m_markStack.append(reinterpret_cast<JSCell**>(slot));