Make loader lock new-allocated to avoid shutdown crash.

runtime/bin/loader.cc

 // Copyright (c) 2016, 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.
 
 
 #include "bin/loader.h"
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 #include "bin/extensions.h"
@@ skipping 590 matching lines @@
     free(part_uri);
     return Dart_LoadSource(library,
                            part_uri_obj,
                            Builtin::PartSource(id, url_string), 0, 0);
   }
   // All cases should have been handled above.
   UNREACHABLE();
 }
 
 
-Mutex Loader::loader_infos_lock_;
+void Loader::InitOnce() {
+  loader_infos_lock_ = new Mutex();

[zra, 2016/07/13 14:51:38]

Can this be deleted in a Loader::Shutdown() call somewhere in Dart::Cleanup()?

[Florian Schneider, 2016/07/13 16:13:58]

It could be. But since it is in the embedder, and only called before they whole
VM exits, there's no leak - and it won't be called from Process::Exit either.

I'd rather don't delete, because then I don't have to worry about potential
use-after-free.

[zra, 2016/07/13 16:16:06]

sgtm. Didn't notice this was in bin/

+}
+
+
+Mutex* Loader::loader_infos_lock_;
 Loader::LoaderInfo* Loader::loader_infos_ = NULL;
 intptr_t Loader::loader_infos_length_ = 0;
 intptr_t Loader::loader_infos_capacity_ = 0;
 
 
 // Add a mapping from |port| to |isolate_data| (really the loader). When a
 // native message arrives, we use this map to report the I/O result to the
 // correct loader.
 // This happens whenever an isolate begins loading.
 void Loader::AddLoader(Dart_Port port, IsolateData* isolate_data) {
-  MutexLocker ml(&loader_infos_lock_);
+  MutexLocker ml(loader_infos_lock_);
   ASSERT(LoaderForLocked(port) == NULL);
   if (loader_infos_length_ == loader_infos_capacity_) {
     // Grow to an initial capacity or double in size.
     loader_infos_capacity_ =
         (loader_infos_capacity_ == 0) ? 4 : loader_infos_capacity_ * 2;
     loader_infos_ =
         reinterpret_cast<Loader::LoaderInfo*>(
             realloc(loader_infos_,
                     sizeof(Loader::LoaderInfo) * loader_infos_capacity_));
     ASSERT(loader_infos_ != NULL);
     // Initialize new entries.
     for (intptr_t i = loader_infos_length_; i < loader_infos_capacity_; i++) {
       loader_infos_[i].port = ILLEGAL_PORT;
       loader_infos_[i].isolate_data = NULL;
     }
   }
   ASSERT(loader_infos_length_ < loader_infos_capacity_);
   loader_infos_[loader_infos_length_].port = port;
   loader_infos_[loader_infos_length_].isolate_data = isolate_data;
   loader_infos_length_++;
   ASSERT(LoaderForLocked(port) != NULL);
 }
 
 
 // Remove |port| from the map.
 // This happens once an isolate has finished loading.
 void Loader::RemoveLoader(Dart_Port port) {
-  MutexLocker ml(&loader_infos_lock_);
+  MutexLocker ml(loader_infos_lock_);
   const intptr_t index = LoaderIndexFor(port);
   ASSERT(index >= 0);
   const intptr_t last = loader_infos_length_ - 1;
   ASSERT(last >= 0);
   if (index != last) {
     // Swap with the tail.
     loader_infos_[index] = loader_infos_[last];
   }
   loader_infos_length_--;
 }
@@ skipping 12 matching lines @@
 Loader* Loader::LoaderForLocked(Dart_Port port) {
   intptr_t index = LoaderIndexFor(port);
   if (index < 0) {
     return NULL;
   }
   return loader_infos_[index].isolate_data->loader();
 }
 
 
 Loader* Loader::LoaderFor(Dart_Port port) {
-  MutexLocker ml(&loader_infos_lock_);
+  MutexLocker ml(loader_infos_lock_);
   return LoaderForLocked(port);
 }
 
 
 void Loader::NativeMessageHandler(Dart_Port dest_port_id,
                                   Dart_CObject* message) {
-  MutexLocker ml(&loader_infos_lock_);
+  MutexLocker ml(loader_infos_lock_);
   Loader* loader = LoaderForLocked(dest_port_id);
   if (loader == NULL) {
     return;
   }
   loader->QueueMessage(message);
 }
 
 }  // namespace bin
 }  // namespace dart