Gin: Allow multiple callers to wait for the same module in ModuleRegistry.

gin/modules/module_registry.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gin/modules/module_registry.h"
 
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 149 matching lines @@
 }
 
 void ModuleRegistry::LoadModule(Isolate* isolate,
                                 const std::string& id,
                                 LoadModuleCallback callback) {
   if (available_modules_.find(id) != available_modules_.end()) {
     // Should we call the callback asynchronously?
     callback.Run(GetModule(isolate, id));
     return;
   }
-  // Should we support multiple callers waiting on the same module?
-  DCHECK(waiting_callbacks_.find(id) == waiting_callbacks_.end());
-  waiting_callbacks_[id] = callback;
+  waiting_callbacks_.insert(std::make_pair(id, callback));
   unsatisfied_dependencies_.insert(id);
 }
 
 void ModuleRegistry::RegisterModule(Isolate* isolate,
                                     const std::string& id,
                                     v8::Handle<Value> module) {
   if (id.empty() || module.IsEmpty())
     return;
 
   unsatisfied_dependencies_.erase(id);
   available_modules_.insert(id);
   v8::Handle<Object> modules = Local<Object>::New(isolate, modules_);
   modules->Set(StringToSymbol(isolate, id), module);
 
-  LoadModuleCallbackMap::iterator it = waiting_callbacks_.find(id);
-  if (it == waiting_callbacks_.end())
-    return;
-  LoadModuleCallback callback = it->second;
-  waiting_callbacks_.erase(it);
-  // Should we call the callback asynchronously?
-  callback.Run(module);
+  std::pair<LoadModuleCallbackMap::iterator, LoadModuleCallbackMap::iterator>
+      range = waiting_callbacks_.equal_range(id);
+  std::vector<LoadModuleCallback> callbacks;
+  callbacks.reserve(waiting_callbacks_.count(id));
+  for (LoadModuleCallbackMap::iterator it = range.first; it != range.second;
+       ++it) {
+    callbacks.push_back(it->second);
+  }
+  waiting_callbacks_.erase(range.first, range.second);
+  for (std::vector<LoadModuleCallback>::iterator it = callbacks.begin();
+       it != callbacks.end();
+       ++it) {
+    // Should we call the callback asynchronously?
+    it->Run(module);
+  }
 }
 
 bool ModuleRegistry::CheckDependencies(PendingModule* pending) {
   size_t num_missing_dependencies = 0;
   size_t len = pending->dependencies.size();
   for (size_t i = 0; i < len; ++i) {
     const std::string& dependency = pending->dependencies[i];
     if (available_modules_.count(dependency))
       continue;
     unsatisfied_dependencies_.insert(dependency);
@@ skipping 54 matching lines @@
     for (size_t i = 0; i < pending_modules.size(); ++i) {
       scoped_ptr<PendingModule> pending(pending_modules[i]);
       pending_modules[i] = NULL;
       if (AttemptToLoad(isolate, pending.Pass()))
         keep_trying = true;
     }
   }
 }
 
 }  // namespace gin