Make app_custom_bindings.js lazily evaluated so it doesn't execute on every page load.

chrome/renderer/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_MODULE_SYSTEM_H_
 #define CHROME_RENDERER_MODULE_SYSTEM_H_
 #pragma once
 
 #include "base/compiler_specific.h"
 #include "base/memory/linked_ptr.h"
@@ skipping 21 matching lines @@
 // v8::Context.
 // TODO(koz): Rename this to JavaScriptModuleSystem.
 class ModuleSystem : public NativeHandler {
  public:
   class SourceMap {
    public:
     virtual v8::Handle<v8::Value> GetSource(const std::string& name) = 0;
     virtual bool Contains(const std::string& name) = 0;
   };
 
+  // Enables native bindings for the duration of its lifetime.
+  class NativesEnabledScope {
+   public:
+    explicit NativesEnabledScope(ModuleSystem* module_system);
+    ~NativesEnabledScope();
+
+   private:
+    ModuleSystem* module_system_;

[not at google - send to devlin, 2012/03/26 02:29:49]

Come to think of it this is still subtly flawed, since copying or assigning one
of these won't increment the counter, but destruction will still decrement it.
So maybe you should DISALLOW_COPY_AND_ASSIGN (and come to think of it so should
ModuleSystem).

Or... you could do something totally sweet and make those increment the counter,
and then have ModuleSystem construct and return its own NativesEnabledScopes!

Just kidding. Kinda.

[koz (OOO until 15th September), 2012/03/26 03:58:59]

lol, maybe I'll just add the DISALLOW_COPY_AND_ASSIGN for now...

+  };
+
   // |source_map| is a weak pointer.
   explicit ModuleSystem(SourceMap* source_map);
   virtual ~ModuleSystem();
 
   // Require the specified module. This is the equivalent of calling
   // require('module_name') from the loaded JS files.
   void Require(const std::string& module_name);
   v8::Handle<v8::Value> Require(const v8::Arguments& args);
   v8::Handle<v8::Value> RequireForJs(const v8::Arguments& args);
   v8::Handle<v8::Value> RequireForJsInner(v8::Handle<v8::String> module_name);
 
   // Register |native_handler| as a potential target for requireNative(), so
   // calls to requireNative(|name|) from JS will return a new object created by
   // |native_handler|.
   void RegisterNativeHandler(const std::string& name,
                              scoped_ptr<NativeHandler> native_handler);
 
   // Executes |code| in the current context with |name| as the filename.
   void RunString(const std::string& code, const std::string& name);
 
-  // When false |natives_enabled_| causes calls to GetNative() (the basis of
-  // requireNative() in JS) to throw an exception.
-  void set_natives_enabled(bool natives_enabled) {
-    natives_enabled_ = natives_enabled;
-  }
-
-  static v8::Handle<v8::Value> GetterRouter(v8::Local<v8::String> property,
-                                            const v8::AccessorInfo& info);
+  // Retrieves the lazily defined field specified by |property|.
+  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);
 
  private:
   typedef std::map<std::string, linked_ptr<NativeHandler> > NativeHandlerMap;
@@ skipping 18 matching lines @@
   // Wraps |source| in a (function(require, requireNative, exports) {...}).
   v8::Handle<v8::String> WrapSource(v8::Handle<v8::String> source);
 
   // Throws an exception in the calling JS context.
   v8::Handle<v8::Value> ThrowException(const std::string& message);
 
   // A map from module names to the JS source for that module. GetSource()
   // performs a lookup on this map.
   SourceMap* source_map_;
   NativeHandlerMap native_handler_map_;
-  bool natives_enabled_;
+  // When 0, natives are disabled, otherwise indicates how many callers have
+  // pinned natives as enabled.
+  int natives_enabled_;
 };
 
 #endif  // CHROME_RENDERER_MODULE_SYSTEM_H_