Add ExceptionHandler to ModuleSystem, remove heap allocated v8::TryCatch.

chrome/renderer/extensions/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/extensions/module_system.h"
 
 #include "base/bind.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebScopedMicrotaskSuppression.h"
 
 namespace {
@@ skipping 45 matching lines @@
 // static
 bool ModuleSystem::IsPresentInCurrentContext() {
   v8::Handle<v8::Object> global(v8::Context::GetCurrent()->Global());
   if (global.IsEmpty())
     return false;
   v8::Handle<v8::Value> module_system =
       global->GetHiddenValue(v8::String::New(kModuleSystem));
   return !module_system.IsEmpty() && !module_system->IsUndefined();
 }
 
+void ModuleSystem::HandleException(const v8::TryCatch& try_catch) {
+  DumpException(try_catch);
+  if (exception_handler_.get())
+    exception_handler_->HandleUncaughtException();
+}
+
 // static
 void ModuleSystem::DumpException(const v8::TryCatch& try_catch) {
   v8::HandleScope handle_scope;
 
   v8::Handle<v8::Message> message(try_catch.Message());
   if (message.IsEmpty()) {
     LOG(ERROR) << "try_catch has no message";
     return;
   }
 
@@ skipping 60 matching lines @@
     natives->Get(v8::String::NewSymbol("require")),
     natives->Get(v8::String::NewSymbol("requireNative")),
     exports,
   };
   {
     WebKit::WebScopedMicrotaskSuppression suppression;
     v8::TryCatch try_catch;
     try_catch.SetCaptureMessage(true);
     func->Call(global, 3, args);
     if (try_catch.HasCaught()) {
-      DumpException(try_catch);
+      HandleException(try_catch);
       return v8::Undefined();
     }
   }
   modules->Set(module_name, exports);
   return handle_scope.Close(exports);
 }
 
 void ModuleSystem::CallModuleMethod(const std::string& module_name,
                                     const std::string& method_name) {
   v8::HandleScope handle_scope;
@@ skipping 10 matching lines @@
   v8::Handle<v8::Function> func =
       v8::Handle<v8::Function>::Cast(value);
   // TODO(jeremya/koz): refer to context_ here, not the current context.
   v8::Handle<v8::Object> global(v8::Context::GetCurrent()->Global());
   {
     WebKit::WebScopedMicrotaskSuppression suppression;
     v8::TryCatch try_catch;
     try_catch.SetCaptureMessage(true);
     func->Call(global, 0, NULL);
     if (try_catch.HasCaught())
-      DumpException(try_catch);
+      HandleException(try_catch);
   }
 }
 
 void ModuleSystem::RegisterNativeHandler(const std::string& name,
     scoped_ptr<NativeHandler> native_handler) {
   native_handler_map_[name] =
       linked_ptr<NativeHandler>(native_handler.release());
 }
 
 void ModuleSystem::OverrideNativeHandler(const std::string& name) {
@@ skipping 56 matching lines @@
 
 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);
+    HandleException(try_catch);
     return handle_scope.Close(result);
   }
 
   result = script->Run();
   if (try_catch.HasCaught())
-    DumpException(try_catch);
+    HandleException(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 20 matching lines @@
   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()));
 }
 
 }  // extensions