1// Copyright 2014 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 "extensions/renderer/module_system.h"
6
7#include "base/bind.h"
8#include "base/command_line.h"
9#include "base/debug/trace_event.h"
10#include "base/stl_util.h"
11#include "base/strings/string_util.h"
12#include "base/strings/stringprintf.h"
13#include "content/public/renderer/render_view.h"
14#include "extensions/common/extension.h"
15#include "extensions/common/extensions_client.h"
16#include "extensions/renderer/console.h"
17#include "extensions/renderer/safe_builtins.h"
18#include "extensions/renderer/script_context.h"
19#include "gin/modules/module_registry.h"
20#include "third_party/WebKit/public/web/WebFrame.h"
21#include "third_party/WebKit/public/web/WebScopedMicrotaskSuppression.h"
22
23namespace extensions {
24
25namespace {
26
27const char* kModuleSystem = "module_system";
28const char* kModuleName = "module_name";
29const char* kModuleField = "module_field";
30const char* kModulesField = "modules";
31
32// Logs a fatal error for the calling context, with some added metadata about
33// the context:
34//  - Its type (blessed, unblessed, etc).
35//  - Whether it's valid.
36//  - The extension ID, if one exists.
37//
38// This will only actual be fatal in in dev/canary, since in too many cases
39// we're at the mercy of the extension or web page's environment. They can mess
40// up our JS in unexpected ways. Hopefully dev/canary channel will pick up such
41// problems, but given the wider variety on stable/beta it's impossible to know.
42void Fatal(ScriptContext* context, const std::string& message) {
43  // Prepend some context metadata.
44  std::string full_message = "(";
45  if (!context->is_valid())
46    full_message += "Invalid ";
47  full_message += context->GetContextTypeDescription();
48  full_message += " context";
49  if (context->extension()) {
50    full_message += " for ";
51    full_message += context->extension()->id();
52  }
53  full_message += ") ";
54  full_message += message;
55
56  if (ExtensionsClient::Get()->ShouldSuppressFatalErrors())
57    console::Error(context->isolate()->GetCallingContext(), full_message);
58  else
59    console::Fatal(context->isolate()->GetCallingContext(), full_message);
60}
61
62void Warn(v8::Isolate* isolate, const std::string& message) {
63  console::Warn(isolate->GetCallingContext(), message);
64}
65
66// Default exception handler which logs the exception.
67class DefaultExceptionHandler : public ModuleSystem::ExceptionHandler {
68 public:
69  explicit DefaultExceptionHandler(ScriptContext* context)
70      : context_(context) {}
71
72  // Fatally dumps the debug info from |try_catch| to the console.
73  // Make sure this is never used for exceptions that originate in external
74  // code!
75  virtual void HandleUncaughtException(const v8::TryCatch& try_catch) OVERRIDE {
76    v8::HandleScope handle_scope(context_->isolate());
77    std::string stack_trace = "<stack trace unavailable>";
78    if (!try_catch.StackTrace().IsEmpty()) {
79      v8::String::Utf8Value stack_value(try_catch.StackTrace());
80      if (*stack_value)
81        stack_trace.assign(*stack_value, stack_value.length());
82      else
83        stack_trace = "<could not convert stack trace to string>";
84    }
85    Fatal(context_, CreateExceptionString(try_catch) + "{" + stack_trace + "}");
86  }
87
88 private:
89  ScriptContext* context_;
90};
91
92}  // namespace
93
94std::string ModuleSystem::ExceptionHandler::CreateExceptionString(
95    const v8::TryCatch& try_catch) {
96  v8::Handle<v8::Message> message(try_catch.Message());
97  if (message.IsEmpty()) {
98    return "try_catch has no message";
99  }
100
101  std::string resource_name = "<unknown resource>";
102  if (!message->GetScriptOrigin().ResourceName().IsEmpty()) {
103    v8::String::Utf8Value resource_name_v8(
104        message->GetScriptOrigin().ResourceName()->ToString());
105    resource_name.assign(*resource_name_v8, resource_name_v8.length());
106  }
107
108  std::string error_message = "<no error message>";
109  if (!message->Get().IsEmpty()) {
110    v8::String::Utf8Value error_message_v8(message->Get());
111    error_message.assign(*error_message_v8, error_message_v8.length());
112  }
113
114  return base::StringPrintf("%s:%d: %s",
115                            resource_name.c_str(),
116                            message->GetLineNumber(),
117                            error_message.c_str());
118}
119
120ModuleSystem::ModuleSystem(ScriptContext* context, SourceMap* source_map)
121    : ObjectBackedNativeHandler(context),
122      context_(context),
123      source_map_(source_map),
124      natives_enabled_(0),
125      exception_handler_(new DefaultExceptionHandler(context)),
126      weak_factory_(this) {
127  RouteFunction(
128      "require",
129      base::Bind(&ModuleSystem::RequireForJs, base::Unretained(this)));
130  RouteFunction(
131      "requireNative",
132      base::Bind(&ModuleSystem::RequireNative, base::Unretained(this)));
133  RouteFunction(
134      "requireAsync",
135      base::Bind(&ModuleSystem::RequireAsync, base::Unretained(this)));
136  RouteFunction("privates",
137                base::Bind(&ModuleSystem::Private, base::Unretained(this)));
138
139  v8::Handle<v8::Object> global(context->v8_context()->Global());
140  v8::Isolate* isolate = context->isolate();
141  global->SetHiddenValue(v8::String::NewFromUtf8(isolate, kModulesField),
142                         v8::Object::New(isolate));
143  global->SetHiddenValue(v8::String::NewFromUtf8(isolate, kModuleSystem),
144                         v8::External::New(isolate, this));
145
146  gin::ModuleRegistry::From(context->v8_context())->AddObserver(this);
147}
148
149ModuleSystem::~ModuleSystem() { Invalidate(); }
150
151void ModuleSystem::Invalidate() {
152  if (!is_valid())
153    return;
154
155  // Clear the module system properties from the global context. It's polite,
156  // and we use this as a signal in lazy handlers that we no longer exist.
157  {
158    v8::HandleScope scope(GetIsolate());
159    v8::Handle<v8::Object> global = context()->v8_context()->Global();
160    global->DeleteHiddenValue(
161        v8::String::NewFromUtf8(GetIsolate(), kModulesField));
162    global->DeleteHiddenValue(
163        v8::String::NewFromUtf8(GetIsolate(), kModuleSystem));
164  }
165
166  // Invalidate all of the successfully required handlers we own.
167  for (NativeHandlerMap::iterator it = native_handler_map_.begin();
168       it != native_handler_map_.end();
169       ++it) {
170    it->second->Invalidate();
171  }
172
173  ObjectBackedNativeHandler::Invalidate();
174}
175
176ModuleSystem::NativesEnabledScope::NativesEnabledScope(
177    ModuleSystem* module_system)
178    : module_system_(module_system) {
179  module_system_->natives_enabled_++;
180}
181
182ModuleSystem::NativesEnabledScope::~NativesEnabledScope() {
183  module_system_->natives_enabled_--;
184  CHECK_GE(module_system_->natives_enabled_, 0);
185}
186
187void ModuleSystem::HandleException(const v8::TryCatch& try_catch) {
188  exception_handler_->HandleUncaughtException(try_catch);
189}
190
191v8::Handle<v8::Value> ModuleSystem::Require(const std::string& module_name) {
192  v8::EscapableHandleScope handle_scope(GetIsolate());
193  return handle_scope.Escape(RequireForJsInner(
194      v8::String::NewFromUtf8(GetIsolate(), module_name.c_str())));
195}
196
197void ModuleSystem::RequireForJs(
198    const v8::FunctionCallbackInfo<v8::Value>& args) {
199  v8::Handle<v8::String> module_name = args[0]->ToString();
200  args.GetReturnValue().Set(RequireForJsInner(module_name));
201}
202
203v8::Local<v8::Value> ModuleSystem::RequireForJsInner(
204    v8::Handle<v8::String> module_name) {
205  v8::EscapableHandleScope handle_scope(GetIsolate());
206  v8::Context::Scope context_scope(context()->v8_context());
207
208  v8::Handle<v8::Object> global(context()->v8_context()->Global());
209
210  // The module system might have been deleted. This can happen if a different
211  // context keeps a reference to us, but our frame is destroyed (e.g.
212  // background page keeps reference to chrome object in a closed popup).
213  v8::Handle<v8::Value> modules_value = global->GetHiddenValue(
214      v8::String::NewFromUtf8(GetIsolate(), kModulesField));
215  if (modules_value.IsEmpty() || modules_value->IsUndefined()) {
216    Warn(GetIsolate(), "Extension view no longer exists");
217    return v8::Undefined(GetIsolate());
218  }
219
220  v8::Handle<v8::Object> modules(v8::Handle<v8::Object>::Cast(modules_value));
221  v8::Local<v8::Value> exports(modules->Get(module_name));
222  if (!exports->IsUndefined())
223    return handle_scope.Escape(exports);
224
225  exports = LoadModule(*v8::String::Utf8Value(module_name));
226  modules->Set(module_name, exports);
227  return handle_scope.Escape(exports);
228}
229
230v8::Local<v8::Value> ModuleSystem::CallModuleMethod(
231    const std::string& module_name,
232    const std::string& method_name) {
233  v8::EscapableHandleScope handle_scope(GetIsolate());
234  v8::Handle<v8::Value> no_args;
235  return handle_scope.Escape(
236      CallModuleMethod(module_name, method_name, 0, &no_args));
237}
238
239v8::Local<v8::Value> ModuleSystem::CallModuleMethod(
240    const std::string& module_name,
241    const std::string& method_name,
242    std::vector<v8::Handle<v8::Value> >* args) {
243  return CallModuleMethod(
244      module_name, method_name, args->size(), vector_as_array(args));
245}
246
247v8::Local<v8::Value> ModuleSystem::CallModuleMethod(
248    const std::string& module_name,
249    const std::string& method_name,
250    int argc,
251    v8::Handle<v8::Value> argv[]) {
252  TRACE_EVENT2("v8",
253               "v8.callModuleMethod",
254               "module_name",
255               module_name,
256               "method_name",
257               method_name);
258
259  v8::EscapableHandleScope handle_scope(GetIsolate());
260  v8::Context::Scope context_scope(context()->v8_context());
261
262  v8::Local<v8::Value> module;
263  {
264    NativesEnabledScope natives_enabled(this);
265    module = RequireForJsInner(
266        v8::String::NewFromUtf8(GetIsolate(), module_name.c_str()));
267  }
268
269  if (module.IsEmpty() || !module->IsObject()) {
270    Fatal(context_,
271          "Failed to get module " + module_name + " to call " + method_name);
272    return handle_scope.Escape(
273        v8::Local<v8::Primitive>(v8::Undefined(GetIsolate())));
274  }
275
276  v8::Local<v8::Value> value = v8::Handle<v8::Object>::Cast(module)->Get(
277      v8::String::NewFromUtf8(GetIsolate(), method_name.c_str()));
278  if (value.IsEmpty() || !value->IsFunction()) {
279    Fatal(context_, module_name + "." + method_name + " is not a function");
280    return handle_scope.Escape(
281        v8::Local<v8::Primitive>(v8::Undefined(GetIsolate())));
282  }
283
284  v8::Handle<v8::Function> func = v8::Handle<v8::Function>::Cast(value);
285  v8::Local<v8::Value> result;
286  {
287    v8::TryCatch try_catch;
288    try_catch.SetCaptureMessage(true);
289    result = context_->CallFunction(func, argc, argv);
290    if (try_catch.HasCaught())
291      HandleException(try_catch);
292  }
293  return handle_scope.Escape(result);
294}
295
296void ModuleSystem::RegisterNativeHandler(
297    const std::string& name,
298    scoped_ptr<NativeHandler> native_handler) {
299  native_handler_map_[name] =
300      linked_ptr<NativeHandler>(native_handler.release());
301}
302
303void ModuleSystem::OverrideNativeHandlerForTest(const std::string& name) {
304  overridden_native_handlers_.insert(name);
305}
306
307void ModuleSystem::RunString(const std::string& code, const std::string& name) {
308  v8::HandleScope handle_scope(GetIsolate());
309  RunString(v8::String::NewFromUtf8(GetIsolate(), code.c_str()),
310            v8::String::NewFromUtf8(GetIsolate(), name.c_str()));
311}
312
313// static
314void ModuleSystem::NativeLazyFieldGetter(
315    v8::Local<v8::String> property,
316    const v8::PropertyCallbackInfo<v8::Value>& info) {
317  LazyFieldGetterInner(property, info, &ModuleSystem::RequireNativeFromString);
318}
319
320// static
321void ModuleSystem::LazyFieldGetter(
322    v8::Local<v8::String> property,
323    const v8::PropertyCallbackInfo<v8::Value>& info) {
324  LazyFieldGetterInner(property, info, &ModuleSystem::Require);
325}
326
327// static
328void ModuleSystem::LazyFieldGetterInner(
329    v8::Local<v8::String> property,
330    const v8::PropertyCallbackInfo<v8::Value>& info,
331    RequireFunction require_function) {
332  CHECK(!info.Data().IsEmpty());
333  CHECK(info.Data()->IsObject());
334  v8::HandleScope handle_scope(info.GetIsolate());
335  v8::Handle<v8::Object> parameters = v8::Handle<v8::Object>::Cast(info.Data());
336  // This context should be the same as context()->v8_context().
337  v8::Handle<v8::Context> context = parameters->CreationContext();
338  v8::Handle<v8::Object> global(context->Global());
339  v8::Handle<v8::Value> module_system_value = global->GetHiddenValue(
340      v8::String::NewFromUtf8(info.GetIsolate(), kModuleSystem));
341  if (module_system_value.IsEmpty() || !module_system_value->IsExternal()) {
342    // ModuleSystem has been deleted.
343    // TODO(kalman): See comment in header file.
344    Warn(info.GetIsolate(),
345         "Module system has been deleted, does extension view exist?");
346    return;
347  }
348
349  ModuleSystem* module_system = static_cast<ModuleSystem*>(
350      v8::Handle<v8::External>::Cast(module_system_value)->Value());
351
352  std::string name =
353      *v8::String::Utf8Value(
354          parameters->Get(v8::String::NewFromUtf8(info.GetIsolate(),
355                                                  kModuleName))->ToString());
356
357  // Switch to our v8 context because we need functions created while running
358  // the require()d module to belong to our context, not the current one.
359  v8::Context::Scope context_scope(context);
360  NativesEnabledScope natives_enabled_scope(module_system);
361
362  v8::TryCatch try_catch;
363  v8::Handle<v8::Value> module_value = (module_system->*require_function)(name);
364  if (try_catch.HasCaught()) {
365    module_system->HandleException(try_catch);
366    return;
367  }
368  if (module_value.IsEmpty() || !module_value->IsObject()) {
369    // require_function will have already logged this, we don't need to.
370    return;
371  }
372
373  v8::Handle<v8::Object> module = v8::Handle<v8::Object>::Cast(module_value);
374  v8::Handle<v8::String> field =
375      parameters->Get(v8::String::NewFromUtf8(info.GetIsolate(), kModuleField))
376          ->ToString();
377
378  if (!module->Has(field)) {
379    std::string field_str = *v8::String::Utf8Value(field);
380    Fatal(module_system->context_,
381          "Lazy require of " + name + "." + field_str + " did not set the " +
382              field_str + " field");
383    return;
384  }
385
386  v8::Local<v8::Value> new_field = module->Get(field);
387  if (try_catch.HasCaught()) {
388    module_system->HandleException(try_catch);
389    return;
390  }
391
392  // Ok for it to be undefined, among other things it's how bindings signify
393  // that the extension doesn't have permission to use them.
394  CHECK(!new_field.IsEmpty());
395
396  // Delete the getter and set this field to |new_field| so the same object is
397  // returned every time a certain API is accessed.
398  v8::Handle<v8::Value> val = info.This();
399  if (val->IsObject()) {
400    v8::Handle<v8::Object> object = v8::Handle<v8::Object>::Cast(val);
401    object->Delete(property);
402    object->Set(property, new_field);
403  } else {
404    NOTREACHED();
405  }
406  info.GetReturnValue().Set(new_field);
407}
408
409void ModuleSystem::SetLazyField(v8::Handle<v8::Object> object,
410                                const std::string& field,
411                                const std::string& module_name,
412                                const std::string& module_field) {
413  SetLazyField(
414      object, field, module_name, module_field, &ModuleSystem::LazyFieldGetter);
415}
416
417void ModuleSystem::SetLazyField(v8::Handle<v8::Object> object,
418                                const std::string& field,
419                                const std::string& module_name,
420                                const std::string& module_field,
421                                v8::AccessorGetterCallback getter) {
422  v8::HandleScope handle_scope(GetIsolate());
423  v8::Handle<v8::Object> parameters = v8::Object::New(GetIsolate());
424  parameters->Set(v8::String::NewFromUtf8(GetIsolate(), kModuleName),
425                  v8::String::NewFromUtf8(GetIsolate(), module_name.c_str()));
426  parameters->Set(v8::String::NewFromUtf8(GetIsolate(), kModuleField),
427                  v8::String::NewFromUtf8(GetIsolate(), module_field.c_str()));
428  object->SetAccessor(v8::String::NewFromUtf8(GetIsolate(), field.c_str()),
429                      getter,
430                      NULL,
431                      parameters);
432}
433
434void ModuleSystem::SetNativeLazyField(v8::Handle<v8::Object> object,
435                                      const std::string& field,
436                                      const std::string& module_name,
437                                      const std::string& module_field) {
438  SetLazyField(object,
439               field,
440               module_name,
441               module_field,
442               &ModuleSystem::NativeLazyFieldGetter);
443}
444
445v8::Handle<v8::Value> ModuleSystem::RunString(v8::Handle<v8::String> code,
446                                              v8::Handle<v8::String> name) {
447  v8::EscapableHandleScope handle_scope(GetIsolate());
448  v8::Context::Scope context_scope(context()->v8_context());
449
450  // Prepend extensions:: to |name| so that internal code can be differentiated
451  // from external code in stack traces. This has no effect on behaviour.
452  std::string internal_name =
453      base::StringPrintf("extensions::%s", *v8::String::Utf8Value(name));
454
455  blink::WebScopedMicrotaskSuppression suppression;
456  v8::TryCatch try_catch;
457  try_catch.SetCaptureMessage(true);
458  v8::Handle<v8::Script> script(
459      v8::Script::Compile(code,
460                          v8::String::NewFromUtf8(GetIsolate(),
461                                                  internal_name.c_str(),
462                                                  v8::String::kNormalString,
463                                                  internal_name.size())));
464  if (try_catch.HasCaught()) {
465    HandleException(try_catch);
466    return v8::Undefined(GetIsolate());
467  }
468
469  v8::Local<v8::Value> result = script->Run();
470  if (try_catch.HasCaught()) {
471    HandleException(try_catch);
472    return v8::Undefined(GetIsolate());
473  }
474
475  return handle_scope.Escape(result);
476}
477
478v8::Handle<v8::Value> ModuleSystem::GetSource(const std::string& module_name) {
479  v8::EscapableHandleScope handle_scope(GetIsolate());
480  if (!source_map_->Contains(module_name))
481    return v8::Undefined(GetIsolate());
482  return handle_scope.Escape(
483      v8::Local<v8::Value>(source_map_->GetSource(GetIsolate(), module_name)));
484}
485
486void ModuleSystem::RequireNative(
487    const v8::FunctionCallbackInfo<v8::Value>& args) {
488  CHECK_EQ(1, args.Length());
489  std::string native_name = *v8::String::Utf8Value(args[0]->ToString());
490  args.GetReturnValue().Set(RequireNativeFromString(native_name));
491}
492
493v8::Handle<v8::Value> ModuleSystem::RequireNativeFromString(
494    const std::string& native_name) {
495  if (natives_enabled_ == 0) {
496    // HACK: if in test throw exception so that we can test the natives-disabled
497    // logic; however, under normal circumstances, this is programmer error so
498    // we could crash.
499    if (exception_handler_) {
500      return GetIsolate()->ThrowException(
501          v8::String::NewFromUtf8(GetIsolate(), "Natives disabled"));
502    }
503    Fatal(context_, "Natives disabled for requireNative(" + native_name + ")");
504    return v8::Undefined(GetIsolate());
505  }
506
507  if (overridden_native_handlers_.count(native_name) > 0u) {
508    return RequireForJsInner(
509        v8::String::NewFromUtf8(GetIsolate(), native_name.c_str()));
510  }
511
512  NativeHandlerMap::iterator i = native_handler_map_.find(native_name);
513  if (i == native_handler_map_.end()) {
514    Fatal(context_,
515          "Couldn't find native for requireNative(" + native_name + ")");
516    return v8::Undefined(GetIsolate());
517  }
518  return i->second->NewInstance();
519}
520
521void ModuleSystem::RequireAsync(
522    const v8::FunctionCallbackInfo<v8::Value>& args) {
523  CHECK_EQ(1, args.Length());
524  std::string module_name = *v8::String::Utf8Value(args[0]->ToString());
525  v8::Handle<v8::Promise::Resolver> resolver(
526      v8::Promise::Resolver::New(GetIsolate()));
527  args.GetReturnValue().Set(resolver->GetPromise());
528  scoped_ptr<v8::UniquePersistent<v8::Promise::Resolver> > persistent_resolver(
529      new v8::UniquePersistent<v8::Promise::Resolver>(GetIsolate(), resolver));
530  gin::ModuleRegistry* module_registry =
531      gin::ModuleRegistry::From(context_->v8_context());
532  if (!module_registry) {
533    Warn(GetIsolate(), "Extension view no longer exists");
534    resolver->Reject(v8::Exception::Error(v8::String::NewFromUtf8(
535        GetIsolate(), "Extension view no longer exists")));
536    return;
537  }
538  module_registry->LoadModule(GetIsolate(),
539                              module_name,
540                              base::Bind(&ModuleSystem::OnModuleLoaded,
541                                         weak_factory_.GetWeakPtr(),
542                                         base::Passed(&persistent_resolver)));
543  if (module_registry->available_modules().count(module_name) == 0)
544    LoadModule(module_name);
545}
546
547v8::Handle<v8::String> ModuleSystem::WrapSource(v8::Handle<v8::String> source) {
548  v8::EscapableHandleScope handle_scope(GetIsolate());
549  // Keep in order with the arguments in RequireForJsInner.
550  v8::Handle<v8::String> left = v8::String::NewFromUtf8(
551      GetIsolate(),
552      "(function(define, require, requireNative, requireAsync, exports, "
553      "console, privates,"
554      "$Array, $Function, $JSON, $Object, $RegExp, $String, $Error) {"
555      "'use strict';");
556  v8::Handle<v8::String> right = v8::String::NewFromUtf8(GetIsolate(), "\n})");
557  return handle_scope.Escape(v8::Local<v8::String>(
558      v8::String::Concat(left, v8::String::Concat(source, right))));
559}
560
561void ModuleSystem::Private(const v8::FunctionCallbackInfo<v8::Value>& args) {
562  CHECK_EQ(1, args.Length());
563  CHECK(args[0]->IsObject());
564  v8::Local<v8::Object> obj = args[0].As<v8::Object>();
565  v8::Local<v8::String> privates_key =
566      v8::String::NewFromUtf8(GetIsolate(), "privates");
567  v8::Local<v8::Value> privates = obj->GetHiddenValue(privates_key);
568  if (privates.IsEmpty()) {
569    privates = v8::Object::New(args.GetIsolate());
570    obj->SetHiddenValue(privates_key, privates);
571  }
572  args.GetReturnValue().Set(privates);
573}
574
575v8::Handle<v8::Value> ModuleSystem::LoadModule(const std::string& module_name) {
576  v8::EscapableHandleScope handle_scope(GetIsolate());
577  v8::Context::Scope context_scope(context()->v8_context());
578
579  v8::Handle<v8::Value> source(GetSource(module_name));
580  if (source.IsEmpty() || source->IsUndefined()) {
581    Fatal(context_, "No source for require(" + module_name + ")");
582    return v8::Undefined(GetIsolate());
583  }
584  v8::Handle<v8::String> wrapped_source(
585      WrapSource(v8::Handle<v8::String>::Cast(source)));
586  // Modules are wrapped in (function(){...}) so they always return functions.
587  v8::Handle<v8::Value> func_as_value =
588      RunString(wrapped_source,
589                v8::String::NewFromUtf8(GetIsolate(), module_name.c_str()));
590  if (func_as_value.IsEmpty() || func_as_value->IsUndefined()) {
591    Fatal(context_, "Bad source for require(" + module_name + ")");
592    return v8::Undefined(GetIsolate());
593  }
594
595  v8::Handle<v8::Function> func = v8::Handle<v8::Function>::Cast(func_as_value);
596
597  v8::Handle<v8::Object> define_object = v8::Object::New(GetIsolate());
598  gin::ModuleRegistry::InstallGlobals(GetIsolate(), define_object);
599
600  v8::Local<v8::Value> exports = v8::Object::New(GetIsolate());
601  v8::Handle<v8::Object> natives(NewInstance());
602  CHECK(!natives.IsEmpty());  // this can happen if v8 has issues
603
604  // These must match the argument order in WrapSource.
605  v8::Handle<v8::Value> args[] = {
606      // AMD.
607      define_object->Get(v8::String::NewFromUtf8(GetIsolate(), "define")),
608      // CommonJS.
609      natives->Get(v8::String::NewFromUtf8(
610          GetIsolate(), "require", v8::String::kInternalizedString)),
611      natives->Get(v8::String::NewFromUtf8(
612          GetIsolate(), "requireNative", v8::String::kInternalizedString)),
613      natives->Get(v8::String::NewFromUtf8(
614          GetIsolate(), "requireAsync", v8::String::kInternalizedString)),
615      exports,
616      // Libraries that we magically expose to every module.
617      console::AsV8Object(),
618      natives->Get(v8::String::NewFromUtf8(
619          GetIsolate(), "privates", v8::String::kInternalizedString)),
620      // Each safe builtin. Keep in order with the arguments in WrapSource.
621      context_->safe_builtins()->GetArray(),
622      context_->safe_builtins()->GetFunction(),
623      context_->safe_builtins()->GetJSON(),
624      context_->safe_builtins()->GetObjekt(),
625      context_->safe_builtins()->GetRegExp(),
626      context_->safe_builtins()->GetString(),
627      context_->safe_builtins()->GetError(),
628  };
629  {
630    v8::TryCatch try_catch;
631    try_catch.SetCaptureMessage(true);
632    context_->CallFunction(func, arraysize(args), args);
633    if (try_catch.HasCaught()) {
634      HandleException(try_catch);
635      return v8::Undefined(GetIsolate());
636    }
637  }
638  return handle_scope.Escape(exports);
639}
640
641void ModuleSystem::OnDidAddPendingModule(
642    const std::string& id,
643    const std::vector<std::string>& dependencies) {
644  if (!source_map_->Contains(id))
645    return;
646
647  gin::ModuleRegistry* registry =
648      gin::ModuleRegistry::From(context_->v8_context());
649  DCHECK(registry);
650  for (std::vector<std::string>::const_iterator it = dependencies.begin();
651       it != dependencies.end();
652       ++it) {
653    if (registry->available_modules().count(*it) == 0)
654      LoadModule(*it);
655  }
656  registry->AttemptToLoadMoreModules(GetIsolate());
657}
658
659void ModuleSystem::OnModuleLoaded(
660    scoped_ptr<v8::UniquePersistent<v8::Promise::Resolver> > resolver,
661    v8::Handle<v8::Value> value) {
662  if (!is_valid())
663    return;
664  v8::HandleScope handle_scope(GetIsolate());
665  v8::Handle<v8::Promise::Resolver> resolver_local(
666      v8::Local<v8::Promise::Resolver>::New(GetIsolate(), *resolver));
667  resolver_local->Resolve(value);
668}
669
670}  // namespace extensions
671