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

chrome/renderer/extensions/module_system.h

 // 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.
 
 #ifndef CHROME_RENDERER_EXTENSIONS_MODULE_SYSTEM_H_
 #define CHROME_RENDERER_EXTENSIONS_MODULE_SYSTEM_H_
 
 #include "base/compiler_specific.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 19 matching lines @@
 // Each module in a ModuleSystem is executed at most once and its exports
 // object cached.
 //
 // Note that a ModuleSystem must be used only in conjunction with a single
 // v8::Context.
 // TODO(koz): Rename this to JavaScriptModuleSystem.
 class ModuleSystem : public NativeHandler {
  public:
   class SourceMap {
    public:
+    virtual ~SourceMap() {}
     virtual v8::Handle<v8::Value> GetSource(const std::string& name) = 0;
     virtual bool Contains(const std::string& name) = 0;
   };
 
+  class ExceptionHandler {
+   public:
+    virtual ~ExceptionHandler() {}
+    virtual void HandleUncaughtException() = 0;
+  };
+
   // Enables native bindings for the duration of its lifetime.
   class NativesEnabledScope {
    public:
     explicit NativesEnabledScope(ModuleSystem* module_system);
     ~NativesEnabledScope();
 
    private:
     ModuleSystem* module_system_;
     DISALLOW_COPY_AND_ASSIGN(NativesEnabledScope);
   };
@@ skipping 38 matching lines @@
   static v8::Handle<v8::Value> LazyFieldGetter(v8::Local<v8::String> property,
                                                const v8::AccessorInfo& info);
 
   // Make |object|.|field| lazily evaluate to the result of
   // require(|module_name|)[|module_field|].
   void SetLazyField(v8::Handle<v8::Object> object,
                     const std::string& field,
                     const std::string& module_name,
                     const std::string& module_field);
 
+  void set_exception_handler(scoped_ptr<ExceptionHandler> handler) {
+    exception_handler_ = handler.Pass();
+  }
+
  private:
   typedef std::map<std::string, linked_ptr<NativeHandler> > NativeHandlerMap;
 
+  // Called when an exception is thrown but not caught.
+  void HandleException(const v8::TryCatch& try_catch);
+
   // Ensure that require_ has been evaluated from require.js.
   void EnsureRequireLoaded();
 
   // Run |code| in the current context with the name |name| used for stack
   // traces.
   v8::Handle<v8::Value> RunString(v8::Handle<v8::String> code,
                                   v8::Handle<v8::String> name);
 
   // Return the named source file stored in the source map.
   // |args[0]| - the name of a source file in source_map_.
@@ skipping 17 matching lines @@
   // performs a lookup on this map.
   SourceMap* source_map_;
 
   // A map from native handler names to native handlers.
   NativeHandlerMap native_handler_map_;
 
   // When 0, natives are disabled, otherwise indicates how many callers have
   // pinned natives as enabled.
   int natives_enabled_;
 
+  // Called when an exception is thrown but not caught in JS.
+  scoped_ptr<ExceptionHandler> exception_handler_;
+
   std::set<std::string> overridden_native_handlers_;
 
   DISALLOW_COPY_AND_ASSIGN(ModuleSystem);
 };
 
 }  // extensions
 
 #endif  // CHROME_RENDERER_EXTENSIONS_MODULE_SYSTEM_H_