extensions/renderer/module_system.cc

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