Make |Heap::findGCInfo()| threadsafe.

Source/platform/heap/Heap.cpp

 /*
  * Copyright (C) 2013 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 1582 matching lines @@
 #else
     if (!s_heapDoesNotContainCache->lookup(address))
         s_heapDoesNotContainCache->addEntry(address, true);
 #endif
     return 0;
 }
 
 #if ENABLE(GC_TRACING)
 const GCInfo* Heap::findGCInfo(Address address)
 {
+    bool needLockForIteration = !ThreadState::isAnyThreadInGC();
+    if (needLockForIteration)
+        ThreadState::threadAttachMutex().lock();
+
     ThreadState::AttachedThreadStateSet& threads = ThreadState::attachedThreads();
     for (ThreadState::AttachedThreadStateSet::iterator it = threads.begin(), end = threads.end(); it != end; ++it) {
         if (const GCInfo* gcInfo = (*it)->findGCInfo(address)) {
+            if (needLockForIteration)
+                ThreadState::threadAttachMutex().unlock();

[Mads Ager (chromium), 2014/06/06 06:54:01]

Do we have a scoped lock object that we could use instead of having to
explicitly unlock at all returns? MutexLocker?

[kouhei (in TOK), 2014/06/06 06:58:26]

I tried to use MutexLocker, but it requires lock at the c-tor, so it can't be
used for optional locks. I'll try to modify it to support use case like this.

[Mads Ager (chromium), 2014/06/06 07:03:30]

Nah, don't bother for this change. This code is never going to be on by default
and it is correct as it is. Was just wondering if we had it already. :)

             return gcInfo;
         }
     }
+    if (needLockForIteration)
+        ThreadState::threadAttachMutex().unlock();
     return 0;
 }
 
 void Heap::dumpPathToObjectOnNextGC(void* p)
 {
     static_cast<MarkingVisitor*>(s_markingVisitor)->dumpPathToObjectOnNextGC(p);
 }
 #endif
 
 void Heap::pushTraceCallback(void* object, TraceCallback callback)
@@ skipping 158 matching lines @@
 template class ThreadHeap<FinalizedHeapObjectHeader>;
 template class ThreadHeap<HeapObjectHeader>;
 
 Visitor* Heap::s_markingVisitor;
 CallbackStack* Heap::s_markingStack;
 CallbackStack* Heap::s_weakCallbackStack;
 HeapDoesNotContainCache* Heap::s_heapDoesNotContainCache;
 bool Heap::s_shutdownCalled = false;
 bool Heap::s_lastGCWasConservative = false;
 }