Fix ASSERTS in worker code in OSX....

third_party/WebKit/WebCore/bindings/v8/V8DOMMap.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 22 matching lines @@
 
 #include "DOMObjectsInclude.h"
 
 #include <v8.h>
 #include <wtf/HashMap.h>
 #include <wtf/MainThread.h>
 #include <wtf/Noncopyable.h>
 #include <wtf/StdLibExtras.h>
 #include <wtf/Threading.h>
 #include <wtf/ThreadSpecific.h>
+#include <wtf/Vector.h>
 
 namespace WebCore {
 
 // DOM binding algorithm:
 //
 // There are two kinds of DOM objects:
 // 1. DOM tree nodes, such as Document, HTMLElement, ...
 //    there classes implement TreeShared<T> interface;
 // 2. Non-node DOM objects, such as CSSRule, Location, etc.
 //    these classes implement a ref-counted scheme.
@@ skipping 43 matching lines @@
 static void weakSVGElementInstanceCallback(v8::Persistent<v8::Value> v8Object, void* domObject);
 
 // SVG non-node elements may have a reference to a context node which should be notified when the element is change.
 static void weakSVGObjectWithContextCallback(v8::Persistent<v8::Value> v8Object, void* domObject);
 #endif
 
 // This is to ensure that we will deref DOM objects from the owning thread, not the GC thread.
 // The helper function will be scheduled by the GC thread to get called from the owning thread.
 static void derefDelayedObjectsInCurrentThread(void*);
 
-// This should be called to remove all DOM objects associated with the current thread when it is tearing down.
-static void removeAllDOMObjectsInCurrentThread();
-
-// A map from a thread ID to thread's specific data.
+// A list of all ThreadSpecific DOM Data objects. Traversed during GC to find a thread-specific map that
+// contains the object - so we can schedule the object to be deleted on the thread which created it.
 class ThreadSpecificDOMData;
-typedef WTF::HashMap<WTF::ThreadIdentifier, ThreadSpecificDOMData*> DOMThreadMap;
-static DOMThreadMap& domThreadMap()
+typedef WTF::Vector<ThreadSpecificDOMData*> DOMDataList;
+static DOMDataList& domDataList()
 {
-    DEFINE_STATIC_LOCAL(DOMThreadMap, staticDOMThreadMap, ());
-    return staticDOMThreadMap;
+    DEFINE_STATIC_LOCAL(DOMDataList, staticDOMDataList, ());
+    return staticDOMDataList;
 }
 
-// Mutex to protect against concurrent access of domThreadMap.
-static WTF::Mutex& domThreadMapMutex()
+// Mutex to protect against concurrent access of DOMDataList.
+static WTF::Mutex& domDataListMutex()
 {
-    DEFINE_STATIC_LOCAL(WTF::Mutex, staticDOMThreadMapMutex, ());
-    return staticDOMThreadMapMutex;
+    DEFINE_STATIC_LOCAL(WTF::Mutex, staticDOMDataListMutex, ());
+    return staticDOMDataListMutex;
 }
 
 class ThreadSpecificDOMData : Noncopyable {
 public:
     enum DOMWrapperMapType {
         DOMNodeMap,
         DOMObjectMap,
         ActiveDOMObjectMap,
 #if ENABLE(SVG)
         DOMSVGElementInstanceMap,
@@ skipping 21 matching lines @@
         : m_domNodeMap(0)
         , m_domObjectMap(0)
         , m_activeDomObjectMap(0)
 #if ENABLE(SVG)
         , m_domSvgElementInstanceMap(0)
         , m_domSvgObjectWithContextMap(0)
 #endif
         , m_delayedProcessingScheduled(false)
         , m_isMainThread(WTF::isMainThread())
     {
-        WTF::MutexLocker locker(domThreadMapMutex());
-        domThreadMap().set(WTF::currentThread(), this);
+        WTF::MutexLocker locker(domDataListMutex());
+        domDataList().append(this);
     }
 
     virtual ~ThreadSpecificDOMData()
     {
-        WTF::MutexLocker locker(domThreadMapMutex());
-        domThreadMap().remove(WTF::currentThread());
+        WTF::MutexLocker locker(domDataListMutex());
+        domDataList().remove(domDataList().find(this));
     }
 
     void* getDOMWrapperMap(DOMWrapperMapType type)
     {
         switch (type) {
         case DOMNodeMap:
             return m_domNodeMap;
         case DOMObjectMap:
             return m_domObjectMap;
         case ActiveDOMObjectMap:
@@ skipping 52 matching lines @@
 #if ENABLE(SVG)
         m_domSvgElementInstanceMap = new InternalDOMWrapperMap<SVGElementInstance>(weakSVGElementInstanceCallback);
         m_domSvgObjectWithContextMap = new InternalDOMWrapperMap<void>(weakSVGObjectWithContextCallback);
 #endif
     }
 
     // This is called when WTF thread is tearing down.
     // We assume that all child threads running V8 instances are created by WTF.
     virtual ~NonMainThreadSpecificDOMData()
     {
-        removeAllDOMObjectsInCurrentThread();
-
         delete m_domNodeMap;
         delete m_domObjectMap;
         delete m_activeDomObjectMap;
 #if ENABLE(SVG)
         delete m_domSvgElementInstanceMap;
         delete m_domSvgObjectWithContextMap;
 #endif
     }
 };
 
@@ skipping 122 matching lines @@
 #endif // ENABLE(SVG)
 
 // Called when the dead object is not in GC thread's map. Go through all thread maps to find the one containing it.
 // Then clear the JS reference and push the DOM object into the delayed queue for it to be deref-ed at later time from the owning thread.
 // * This is called when the GC thread is not the owning thread.
 // * This can be called on any thread that has GC running.
 // * Only one V8 instance is running at a time due to V8::Locker. So we don't need to worry about concurrency.
 template<typename T>
 static void handleWeakObjectInOwningThread(ThreadSpecificDOMData::DOMWrapperMapType mapType, V8ClassIndex::V8WrapperType objectType, T* object)
 {
-    WTF::MutexLocker locker(domThreadMapMutex());
-    for (typename DOMThreadMap::iterator iter(domThreadMap().begin()); iter != domThreadMap().end(); ++iter) {
-        WTF::ThreadIdentifier threadID = iter->first;
-        ThreadSpecificDOMData* threadData = iter->second;
-
-        // Skip the current thread that is GC thread.
-        if (threadID == WTF::currentThread()) {
-            ASSERT(!static_cast<DOMWrapperMap<T>*>(threadData->getDOMWrapperMap(mapType))->contains(object));
-            continue;
-        }
+    WTF::MutexLocker locker(domDataListMutex());
+    DOMDataList& list = domDataList();
+    for (size_t i = 0; i < list.size(); ++i) {
+        ThreadSpecificDOMData* threadData = list[i];
 
         ThreadSpecificDOMData::InternalDOMWrapperMap<T>* domMap = static_cast<ThreadSpecificDOMData::InternalDOMWrapperMap<T>*>(threadData->getDOMWrapperMap(mapType));
         if (domMap->contains(object)) {
             // Clear the JS reference.
             domMap->forgetOnly(object);
 
             // Push into the delayed queue.
             threadData->delayedObjectMap().set(object, objectType);
 
             // Post a task to the owning thread in order to process the delayed queue.
@@ skipping 99 matching lines @@
 #endif
 
     default:
         ASSERT_NOT_REACHED();
         break;
     }
 }
 
 static void derefDelayedObjects()
 {
-    WTF::MutexLocker locker(domThreadMapMutex());
+    WTF::MutexLocker locker(domDataListMutex());
 
     getThreadSpecificDOMData().setDelayedProcessingScheduled(false);
 
     ThreadSpecificDOMData::DelayedObjectMap& delayedObjectMap = getThreadSpecificDOMData().delayedObjectMap();
     for (ThreadSpecificDOMData::DelayedObjectMap::iterator iter(delayedObjectMap.begin()); iter != delayedObjectMap.end(); ++iter) {
         derefObject(iter->second, iter->first);
     }
     delayedObjectMap.clear();
 }
 
@@ skipping 38 matching lines @@
 
 #if ENABLE(SVG)
     // Remove all SVG element instances in the wrapper map.
     removeObjectsFromWrapperMap<SVGElementInstance>(getDOMSVGElementInstanceMap());
 
     // Remove all SVG objects with context in the wrapper map.
     removeObjectsFromWrapperMap<void>(getDOMSVGObjectWithContextMap());
 #endif
 }
 
-static void removeAllDOMObjectsInCurrentThread()
+void removeAllDOMObjectsInCurrentThread()
 {
     // Use the locker only if it has already been invoked before, as by worker thread.
     if (v8::Locker::IsActive()) {
         v8::Locker locker;
         removeAllDOMObjectsInCurrentThreadHelper();
     } else
         removeAllDOMObjectsInCurrentThreadHelper();
 }
 
 } // namespace WebCore