[Mojo] Improve JavaScript API for MojoReadMessage

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"
 #include "gin/arguments.h"
 #include "gin/converter.h"
 #include "gin/per_isolate_data.h"
 #include "gin/public/wrapper_info.h"
+#include "gin/try_catch.h"
 
 using v8::Context;
 using v8::External;
 using v8::Function;
 using v8::FunctionTemplate;
 using v8::Handle;
 using v8::Isolate;
 using v8::Local;
 using v8::Object;
 using v8::ObjectTemplate;
@@ skipping 59 matching lines @@
     templ = FunctionTemplate::New(Define);
     data->SetFunctionTemplate(&g_wrapper_info, templ);
   }
   return templ;
 }
 
 Handle<String> GetHiddenValueKey(Isolate* isolate) {
   return StringToSymbol(isolate, "::gin::ModuleRegistry");
 }
 
-std::string GetImplicitModuleName(const std::string& explicit_name) {
-  if (!explicit_name.empty())
-    return explicit_name;
-  std::string implicit_name;
-  Handle<StackTrace> trace = StackTrace::CurrentStackTrace(1);
-  if (!trace->GetFrameCount())
-    return implicit_name;
-  Handle<String> script_name = trace->GetFrame(0)->GetScriptName();
-  if (!script_name.IsEmpty())
-    ConvertFromV8(script_name, &implicit_name);
-  return implicit_name;
-}
-
 }  // namespace
 
 ModuleRegistry::ModuleRegistry(Isolate* isolate)
     : modules_(isolate, Object::New()) {
 }
 
 ModuleRegistry::~ModuleRegistry() {
   modules_.Reset();
 }
 
@@ skipping 72 matching lines @@
     Handle<String> key = StringToSymbol(isolate, pending->dependencies[i]);
     DCHECK(modules->HasOwnProperty(key));
     argv[i] = modules->Get(key);
   }
 
   Handle<Value> module = Local<Value>::New(isolate, pending->factory);
 
   Handle<Function> factory;
   if (ConvertFromV8(module, &factory)) {
     Handle<Object> global = isolate->GetCurrentContext()->Global();
-    module = factory->Call(global, argc, argv.data());
-    // TODO(abarth): What should we do with exceptions?
+    {
+      gin::TryCatch try_catch;
+      module = factory->Call(global, argc, argv.data());
+      if (try_catch.HasCaught())
+        return;  // TODO(abarth): What should we do with the exception?
+    }
+    if (pending->id.empty())
+      ConvertFromV8(factory->GetScriptOrigin().ResourceName(), &pending->id);
   }
 
-  RegisterModule(isolate, GetImplicitModuleName(pending->id), module);
+  RegisterModule(isolate, pending->id, module);
 }
 
 bool ModuleRegistry::AttemptToLoad(Isolate* isolate,
                                    scoped_ptr<PendingModule> pending) {
   if (!CheckDependencies(pending.get())) {
     pending_modules_.push_back(pending.release());
     return false;
   }
   Load(isolate, pending.Pass());
   return true;
 }
 
 void ModuleRegistry::AttemptToLoadMoreModules(Isolate* isolate) {
   bool keep_trying = true;
   while (keep_trying) {
     keep_trying = false;
     PendingModuleVector pending_modules;
     pending_modules.swap(pending_modules_);
     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