module_registry.cc revision a1401311d1ab56c4ed0a474bd38c108f75cb0cd9 
1// Copyright 2013 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "gin/modules/module_registry.h"
6
7#include <string>
8#include <vector>
9
10#include "base/logging.h"
11#include "gin/arguments.h"
12#include "gin/converter.h"
13#include "gin/modules/module_registry_observer.h"
14#include "gin/per_context_data.h"
15#include "gin/per_isolate_data.h"
16#include "gin/public/wrapper_info.h"
17#include "gin/runner.h"
18
19using v8::Context;
20using v8::External;
21using v8::Function;
22using v8::FunctionTemplate;
23using v8::Isolate;
24using v8::Local;
25using v8::Object;
26using v8::ObjectTemplate;
27using v8::Persistent;
28using v8::StackTrace;
29using v8::String;
30using v8::Value;
31
32namespace gin {
33
34struct PendingModule {
35  PendingModule();
36  ~PendingModule();
37
38  std::string id;
39  std::vector<std::string> dependencies;
40  Persistent<Value> factory;
41};
42
43PendingModule::PendingModule() {
44}
45
46PendingModule::~PendingModule() {
47  factory.Reset();
48}
49
50namespace {
51
52// Key for base::SupportsUserData::Data.
53const char kModuleRegistryKey[] = "ModuleRegistry";
54
55struct ModuleRegistryData : public base::SupportsUserData::Data {
56  scoped_ptr<ModuleRegistry> registry;
57};
58
59void Define(const v8::FunctionCallbackInfo<Value>& info) {
60  Arguments args(info);
61
62  if (!info.Length())
63    return args.ThrowTypeError("At least one argument is required.");
64
65  std::string id;
66  std::vector<std::string> dependencies;
67  v8::Handle<Value> factory;
68
69  if (args.PeekNext()->IsString())
70    args.GetNext(&id);
71  if (args.PeekNext()->IsArray())
72    args.GetNext(&dependencies);
73  if (!args.GetNext(&factory))
74    return args.ThrowError();
75
76  scoped_ptr<PendingModule> pending(new PendingModule);
77  pending->id = id;
78  pending->dependencies = dependencies;
79  pending->factory.Reset(args.isolate(), factory);
80
81  ModuleRegistry* registry =
82      ModuleRegistry::From(args.isolate()->GetCurrentContext());
83  registry->AddPendingModule(args.isolate(), pending.Pass());
84}
85
86WrapperInfo g_wrapper_info = { kEmbedderNativeGin };
87
88Local<FunctionTemplate> GetDefineTemplate(Isolate* isolate) {
89  PerIsolateData* data = PerIsolateData::From(isolate);
90  Local<FunctionTemplate> templ = data->GetFunctionTemplate(
91      &g_wrapper_info);
92  if (templ.IsEmpty()) {
93    templ = FunctionTemplate::New(isolate, Define);
94    data->SetFunctionTemplate(&g_wrapper_info, templ);
95  }
96  return templ;
97}
98
99}  // namespace
100
101ModuleRegistry::ModuleRegistry(Isolate* isolate)
102    : modules_(isolate, Object::New(isolate)) {
103}
104
105ModuleRegistry::~ModuleRegistry() {
106  modules_.Reset();
107}
108
109// static
110void ModuleRegistry::RegisterGlobals(Isolate* isolate,
111                                     v8::Handle<ObjectTemplate> templ) {
112  templ->Set(StringToSymbol(isolate, "define"), GetDefineTemplate(isolate));
113}
114
115// static
116void ModuleRegistry::InstallGlobals(v8::Isolate* isolate,
117                                    v8::Handle<v8::Object> obj) {
118  obj->Set(StringToSymbol(isolate, "define"),
119           GetDefineTemplate(isolate)->GetFunction());
120}
121
122// static
123ModuleRegistry* ModuleRegistry::From(v8::Handle<Context> context) {
124  PerContextData* data = PerContextData::From(context);
125  if (!data)
126    return NULL;
127
128  ModuleRegistryData* registry_data = static_cast<ModuleRegistryData*>(
129      data->GetUserData(kModuleRegistryKey));
130  if (!registry_data) {
131    // PerContextData takes ownership of ModuleRegistryData.
132    registry_data = new ModuleRegistryData;
133    registry_data->registry.reset(new ModuleRegistry(context->GetIsolate()));
134    data->SetUserData(kModuleRegistryKey, registry_data);
135  }
136  return registry_data->registry.get();
137}
138
139void ModuleRegistry::AddObserver(ModuleRegistryObserver* observer) {
140  observer_list_.AddObserver(observer);
141}
142
143void ModuleRegistry::RemoveObserver(ModuleRegistryObserver* observer) {
144  observer_list_.RemoveObserver(observer);
145}
146
147void ModuleRegistry::AddBuiltinModule(Isolate* isolate, const std::string& id,
148                                      v8::Handle<Value> module) {
149  DCHECK(!id.empty());
150  RegisterModule(isolate, id, module);
151}
152
153void ModuleRegistry::AddPendingModule(Isolate* isolate,
154                                      scoped_ptr<PendingModule> pending) {
155  const std::string pending_id = pending->id;
156  const std::vector<std::string> pending_dependencies = pending->dependencies;
157  AttemptToLoad(isolate, pending.Pass());
158  FOR_EACH_OBSERVER(ModuleRegistryObserver, observer_list_,
159                    OnDidAddPendingModule(pending_id, pending_dependencies));
160}
161
162void ModuleRegistry::LoadModule(Isolate* isolate,
163                                const std::string& id,
164                                LoadModuleCallback callback) {
165  if (available_modules_.find(id) != available_modules_.end()) {
166    // Should we call the callback asynchronously?
167    callback.Run(GetModule(isolate, id));
168    return;
169  }
170  // Should we support multiple callers waiting on the same module?
171  DCHECK(waiting_callbacks_.find(id) == waiting_callbacks_.end());
172  waiting_callbacks_[id] = callback;
173  unsatisfied_dependencies_.insert(id);
174}
175
176void ModuleRegistry::RegisterModule(Isolate* isolate,
177                                    const std::string& id,
178                                    v8::Handle<Value> module) {
179  if (id.empty() || module.IsEmpty())
180    return;
181
182  unsatisfied_dependencies_.erase(id);
183  available_modules_.insert(id);
184  v8::Handle<Object> modules = Local<Object>::New(isolate, modules_);
185  modules->Set(StringToSymbol(isolate, id), module);
186
187  LoadModuleCallbackMap::iterator it = waiting_callbacks_.find(id);
188  if (it == waiting_callbacks_.end())
189    return;
190  LoadModuleCallback callback = it->second;
191  waiting_callbacks_.erase(it);
192  // Should we call the callback asynchronously?
193  callback.Run(module);
194}
195
196bool ModuleRegistry::CheckDependencies(PendingModule* pending) {
197  size_t num_missing_dependencies = 0;
198  size_t len = pending->dependencies.size();
199  for (size_t i = 0; i < len; ++i) {
200    const std::string& dependency = pending->dependencies[i];
201    if (available_modules_.count(dependency))
202      continue;
203    unsatisfied_dependencies_.insert(dependency);
204    num_missing_dependencies++;
205  }
206  return num_missing_dependencies == 0;
207}
208
209void ModuleRegistry::Load(Isolate* isolate, scoped_ptr<PendingModule> pending) {
210  if (!pending->id.empty() && available_modules_.count(pending->id))
211    return;  // We've already loaded this module.
212
213  uint32_t argc = static_cast<uint32_t>(pending->dependencies.size());
214  std::vector<v8::Handle<Value> > argv(argc);
215  for (uint32_t i = 0; i < argc; ++i)
216    argv[i] = GetModule(isolate, pending->dependencies[i]);
217
218  v8::Handle<Value> module = Local<Value>::New(isolate, pending->factory);
219
220  v8::Handle<Function> factory;
221  if (ConvertFromV8(isolate, module, &factory)) {
222    PerContextData* data = PerContextData::From(isolate->GetCurrentContext());
223    Runner* runner = data->runner();
224    module = runner->Call(factory, runner->global(), argc,
225                          argv.empty() ? NULL : &argv.front());
226    if (pending->id.empty())
227      ConvertFromV8(isolate, factory->GetScriptOrigin().ResourceName(),
228                    &pending->id);
229  }
230
231  RegisterModule(isolate, pending->id, module);
232}
233
234bool ModuleRegistry::AttemptToLoad(Isolate* isolate,
235                                   scoped_ptr<PendingModule> pending) {
236  if (!CheckDependencies(pending.get())) {
237    pending_modules_.push_back(pending.release());
238    return false;
239  }
240  Load(isolate, pending.Pass());
241  return true;
242}
243
244v8::Handle<v8::Value> ModuleRegistry::GetModule(v8::Isolate* isolate,
245                                                const std::string& id) {
246  v8::Handle<Object> modules = Local<Object>::New(isolate, modules_);
247  v8::Handle<String> key = StringToSymbol(isolate, id);
248  DCHECK(modules->HasOwnProperty(key));
249  return modules->Get(key);
250}
251
252void ModuleRegistry::AttemptToLoadMoreModules(Isolate* isolate) {
253  bool keep_trying = true;
254  while (keep_trying) {
255    keep_trying = false;
256    PendingModuleVector pending_modules;
257    pending_modules.swap(pending_modules_);
258    for (size_t i = 0; i < pending_modules.size(); ++i) {
259      scoped_ptr<PendingModule> pending(pending_modules[i]);
260      pending_modules[i] = NULL;
261      if (AttemptToLoad(isolate, pending.Pass()))
262        keep_trying = true;
263    }
264  }
265}
266
267}  // namespace gin
268