Plumb listenerIDs correctly for events that clobber chrome.Event.prototype.dispatch.

chrome/renderer/module_system.cc

 // Copyright (c) 2012 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 "chrome/renderer/module_system.h"
 
 #include "base/bind.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebScopedMicrotaskSuppression.h"
 
 namespace {
@@ skipping 42 matching lines @@
 
 // static
 bool ModuleSystem::IsPresentInCurrentContext() {
   v8::Handle<v8::Object> global(v8::Context::GetCurrent()->Global());
   v8::Handle<v8::Value> module_system =
       global->GetHiddenValue(v8::String::New(kModuleSystem));
   return !module_system.IsEmpty() && !module_system->IsUndefined();
 }
 
 // static
-void ModuleSystem::DumpException(v8::Handle<v8::Message> message) {
+void ModuleSystem::DumpException(const v8::TryCatch& try_catch) {
+  v8::Handle<v8::Message> message(try_catch.Message());
+
   LOG(ERROR) << "["
              << *v8::String::Utf8Value(
                  message->GetScriptResourceName()->ToString())
              << "(" << message->GetLineNumber() << ")] "
-             << *v8::String::Utf8Value(message->Get());
+             << *v8::String::Utf8Value(message->Get())
+             << "{" << *v8::String::Utf8Value(try_catch.StackTrace()) << "}";
 }
 
 void ModuleSystem::Require(const std::string& module_name) {
   v8::HandleScope handle_scope;
   RequireForJsInner(v8::String::New(module_name.c_str()));
 }
 
 v8::Handle<v8::Value> ModuleSystem::RequireForJs(const v8::Arguments& args) {
   v8::HandleScope handle_scope;
   v8::Handle<v8::String> module_name = args[0]->ToString();
@@ skipping 10 matching lines @@
   if (!exports->IsUndefined())
     return handle_scope.Close(exports);
 
   v8::Handle<v8::Value> source(GetSource(module_name));
   if (source->IsUndefined())
     return handle_scope.Close(v8::Undefined());
   v8::Handle<v8::String> wrapped_source(WrapSource(
       v8::Handle<v8::String>::Cast(source)));
   v8::Handle<v8::Function> func =
       v8::Handle<v8::Function>::Cast(RunString(wrapped_source, module_name));
-  if (func.IsEmpty())
-    return handle_scope.Close(v8::Handle<v8::Value>());
+  if (func.IsEmpty()) {
+    return ThrowException(std::string(*v8::String::AsciiValue(module_name)) +
+        ": Bad source");
+  }
 
   exports = v8::Object::New();
   v8::Handle<v8::Object> natives(NewInstance());
   v8::Handle<v8::Value> args[] = {
     natives->Get(v8::String::NewSymbol("require")),
     natives->Get(v8::String::NewSymbol("requireNative")),
     exports,
   };
   {
     WebKit::WebScopedMicrotaskSuppression suppression;
+    v8::TryCatch try_catch;
     func->Call(global, 3, args);
+    if (try_catch.HasCaught()) {
+      DumpException(try_catch);
+      return v8::Undefined();
+    }
   }
   modules->Set(module_name, exports);
   return handle_scope.Close(exports);
 }
 
 void ModuleSystem::RegisterNativeHandler(const std::string& name,
     scoped_ptr<NativeHandler> native_handler) {
   native_handler_map_[name] =
       linked_ptr<NativeHandler>(native_handler.release());
 }
@@ skipping 55 matching lines @@
                       NULL,
                       parameters);
 }
 
 v8::Handle<v8::Value> ModuleSystem::RunString(v8::Handle<v8::String> code,
                                               v8::Handle<v8::String> name) {
   v8::HandleScope handle_scope;
   WebKit::WebScopedMicrotaskSuppression suppression;
   v8::Handle<v8::Value> result;
   v8::TryCatch try_catch;
-  try_catch.SetCaptureMessage(true);
   v8::Handle<v8::Script> script(v8::Script::New(code, name));
   if (try_catch.HasCaught()) {
-    DumpException(try_catch.Message());
+    DumpException(try_catch);
     return handle_scope.Close(result);
   }
 
   result = script->Run();
   if (try_catch.HasCaught())
-    DumpException(try_catch.Message());
+    DumpException(try_catch);
 
   return handle_scope.Close(result);
 }
 
 v8::Handle<v8::Value> ModuleSystem::GetSource(
     v8::Handle<v8::String> source_name) {
   v8::HandleScope handle_scope;
   std::string module_name = *v8::String::AsciiValue(source_name);
   if (!source_map_->Contains(module_name))
     return v8::Undefined();
@@ skipping 18 matching lines @@
   v8::Handle<v8::String> left =
       v8::String::New("(function(require, requireNative, exports) {");
   v8::Handle<v8::String> right = v8::String::New("\n})");
   return handle_scope.Close(
       v8::String::Concat(left, v8::String::Concat(source, right)));
 }
 
 v8::Handle<v8::Value> ModuleSystem::ThrowException(const std::string& message) {
   return v8::ThrowException(v8::String::New(message.c_str()));
 }