Fix for issue #28606. Removed loop which iterated over all threads in the thread registry to check …

runtime/vm/dart_api_state.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef RUNTIME_VM_DART_API_STATE_H_
 #define RUNTIME_VM_DART_API_STATE_H_
 
 #include "include/dart_api.h"
 
 #include "platform/utils.h"
@@ skipping 438 matching lines @@
 static const int kPersistentHandlesPerChunk = 64;
 static const int kOffsetOfRawPtrInPersistentHandle = 0;
 class PersistentHandles : Handles<kPersistentHandleSizeInWords,
                                   kPersistentHandlesPerChunk,
                                   kOffsetOfRawPtrInPersistentHandle> {
  public:
   PersistentHandles()
       : Handles<kPersistentHandleSizeInWords,
                 kPersistentHandlesPerChunk,
                 kOffsetOfRawPtrInPersistentHandle>(),
+        mutex_(new Mutex()),

[bkonyi, 2017/02/02 22:22:34]

It looks like PersistentHandles contains shared handles within the current
isolate, so I feel there might be the potential for a race condition here. I
noticed FinalizablePersistentHandles does have locks, so I've added them as
well. 

[bkonyi, 2017/02/02 22:43:03]

As discussed with Siva, this isn't needed. Removed in patch set 2.

[siva, 2017/02/02 22:51:13]

FinalizablePersistentHandles has a lock because we have background finalization
done in a different thread.

PersistentHandles should only be accessed from the mutator thread.

         free_list_(NULL) {
     if (FLAG_trace_handles) {
       OS::PrintErr("*** Starting a new Persistent handle block 0x%" Px "\n",
                    reinterpret_cast<intptr_t>(this));
     }
   }
   ~PersistentHandles() {
+    delete mutex_;
     free_list_ = NULL;
     if (FLAG_trace_handles) {
       OS::PrintErr("***   Handle Counts for 0x(%" Px "):Scoped = %d\n",
                    reinterpret_cast<intptr_t>(this), CountHandles());
       OS::PrintErr("*** Deleting Persistent handle block 0x%" Px "\n",
                    reinterpret_cast<intptr_t>(this));
     }
   }
 
   // Accessors.
   PersistentHandle* free_list() const { return free_list_; }
   void set_free_list(PersistentHandle* value) { free_list_ = value; }
 
   // Visit all object pointers stored in the various handles.
   void VisitObjectPointers(ObjectPointerVisitor* visitor) {
+    MutexLocker ml(mutex_);
     Handles<kPersistentHandleSizeInWords, kPersistentHandlesPerChunk,
             kOffsetOfRawPtrInPersistentHandle>::VisitObjectPointers(visitor);
   }
 
   // Visit all the handles.
   void Visit(HandleVisitor* visitor) {
+    MutexLocker ml(mutex_);
     Handles<kPersistentHandleSizeInWords, kPersistentHandlesPerChunk,
             kOffsetOfRawPtrInPersistentHandle>::Visit(visitor);
   }
 
   // Allocates a persistent handle, these have to be destroyed explicitly
   // by calling FreeHandle.
   PersistentHandle* AllocateHandle() {
+    MutexLocker ml(mutex_);
     PersistentHandle* handle;
     if (free_list_ != NULL) {
       handle = free_list_;
       free_list_ = handle->Next();
     } else {
       handle = reinterpret_cast<PersistentHandle*>(AllocateScopedHandle());
     }
     handle->set_raw(Object::null());
     return handle;
   }
 
   void FreeHandle(PersistentHandle* handle) {
+    MutexLocker ml(mutex_);
     handle->FreeHandle(free_list());
     set_free_list(handle);
   }
 
   // Validate if passed in handle is a Persistent Handle.
   bool IsValidHandle(Dart_PersistentHandle object) const {
+    MutexLocker ml(mutex_);
     return IsValidScopedHandle(reinterpret_cast<uword>(object));
   }
 
   bool IsFreeHandle(Dart_PersistentHandle object) const {
+    MutexLocker ml(mutex_);
     PersistentHandle* handle = free_list_;
     while (handle != NULL) {
       if (handle == reinterpret_cast<PersistentHandle*>(object)) {
         return true;
       }
       handle = handle->Next();
     }
     return false;
   }
 
   // Returns a count of active handles (used for testing purposes).
   int CountHandles() const { return CountScopedHandles(); }
 
  private:
+  Mutex* mutex_;
   PersistentHandle* free_list_;
   DISALLOW_COPY_AND_ASSIGN(PersistentHandles);
 };
 
 
 // Finalizable persistent handles repository structure.
 static const int kFinalizablePersistentHandleSizeInWords =
     sizeof(FinalizablePersistentHandle) / kWordSize;
 static const int kFinalizablePersistentHandlesPerChunk = 64;
 static const int kOffsetOfRawPtrInFinalizablePersistentHandle = 0;
@@ skipping 321 matching lines @@
   ref->set_callback(callback);
   ref->set_is_queued_for_finalization(false);
   // This may trigger GC, so it must be called last.
   ref->SetExternalSize(external_size, isolate);
   return ref;
 }
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_DART_API_STATE_H_