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

chrome/renderer/module_system_unittest.cc

Index: chrome/renderer/module_system_unittest.cc
diff --git a/chrome/renderer/module_system_unittest.cc b/chrome/renderer/module_system_unittest.cc
index 6b9b0206e4750e432ed405ae4c8c602bc18a3c03..4d749f44d19587e16db4edc7b6bbdc7efb72800a 100644
--- a/chrome/renderer/module_system_unittest.cc
+++ b/chrome/renderer/module_system_unittest.cc
@@ -15,26 +15,48 @@
 class AssertNatives : public NativeHandler {
  public:
   AssertNatives()
-      : native_function_called_(false),
+      : assertion_made_(false),
         failed_(false) {
     RouteFunction("AssertTrue", base::Bind(&AssertNatives::AssertTrue,
         base::Unretained(this)));
   }
 
-  bool native_function_called() { return native_function_called_; }
+  bool assertion_made() { return assertion_made_; }
   bool failed() { return failed_; }
 
   v8::Handle<v8::Value> AssertTrue(const v8::Arguments& args) {
-    native_function_called_ = true;
+    assertion_made_ = true;
     failed_ = failed_ || !args[0]->ToBoolean()->Value();
     return v8::Undefined();
   }
 
  private:
-  bool native_function_called_;
+  bool assertion_made_;
   bool failed_;
 };
 
+class CounterNatives : public NativeHandler {
+ public:
+  CounterNatives() : counter_(0) {
+    RouteFunction("Get", base::Bind(&CounterNatives::Get,
+        base::Unretained(this)));
+    RouteFunction("Increment", base::Bind(&CounterNatives::Increment,
+        base::Unretained(this)));
+  }
+
+  v8::Handle<v8::Value> Get(const v8::Arguments& args) {
+    return v8::Integer::New(counter_);
+  }
+
+  v8::Handle<v8::Value> Increment(const v8::Arguments& args) {
+    counter_++;
+    return v8::Undefined();
+  }
+
+ private:
+  int counter_;
+};
+
 class StringSourceMap : public ModuleSystem::SourceMap {
  public:
   StringSourceMap() {}
@@ -58,30 +80,12 @@ class StringSourceMap : public ModuleSystem::SourceMap {
   std::map<std::string, std::string> source_map_;
 };
 
-// Native JS functions for disabling injection in ModuleSystem.
-class DisableNativesHandler : public NativeHandler {
- public:
-  explicit DisableNativesHandler(ModuleSystem* module_system)
-      : module_system_(module_system) {
-    RouteFunction("DisableNatives",
-                  base::Bind(&DisableNativesHandler::DisableNatives,
-                             base::Unretained(this)));
-  }
-
-  v8::Handle<v8::Value> DisableNatives(const v8::Arguments& args) {
-    module_system_->set_natives_enabled(false);
-    return v8::Undefined();
-  }
-
- private:
-  ModuleSystem* module_system_;
-};
-
 class ModuleSystemTest : public testing::Test {
  public:
   ModuleSystemTest()
       : context_(v8::Context::New()),
-        source_map_(new StringSourceMap()) {
+        source_map_(new StringSourceMap()),
+        should_assertions_be_made_(true) {
     context_->Enter();
     assert_natives_ = new AssertNatives();
     module_system_.reset(new ModuleSystem(source_map_.get()));
@@ -100,10 +104,23 @@ class ModuleSystemTest : public testing::Test {
   }
 
   virtual void TearDown() {
-    // All tests must call a native function at least once.
-    ASSERT_TRUE(assert_natives_->native_function_called());
-    ASSERT_FALSE(assert_natives_->failed());
     ASSERT_FALSE(try_catch_.HasCaught());
+    // All tests must assert at least once unless otherwise specified.
+    ASSERT_EQ(should_assertions_be_made_,
+              assert_natives_->assertion_made());
+    ASSERT_FALSE(assert_natives_->failed());
+  }
+
+  void ExpectNoAssertionsMade() {
+    should_assertions_be_made_ = false;
+  }
+
+  v8::Handle<v8::Object> CreateGlobal(const std::string& name) {
+    v8::HandleScope handle_scope;
+    v8::Handle<v8::Object> object = v8::Object::New();
+    v8::Context::GetCurrent()->Global()->Set(v8::String::New(name.c_str()),
+                                             object);
+    return handle_scope.Close(object);
   }
 
   v8::Persistent<v8::Context> context_;
@@ -112,9 +129,11 @@ class ModuleSystemTest : public testing::Test {
   AssertNatives* assert_natives_;
   scoped_ptr<StringSourceMap> source_map_;
   scoped_ptr<ModuleSystem> module_system_;
+  bool should_assertions_be_made_;
 };
 
 TEST_F(ModuleSystemTest, TestRequire) {
+  ModuleSystem::NativesEnabledScope natives_enabled_scope(module_system_.get());
   RegisterModule("test",
       "var Add = require('add').Add;"
       "requireNative('assert').AssertTrue(Add(3, 5) == 8);");
@@ -122,6 +141,7 @@ TEST_F(ModuleSystemTest, TestRequire) {
 }
 
 TEST_F(ModuleSystemTest, TestNestedRequire) {
+  ModuleSystem::NativesEnabledScope natives_enabled_scope(module_system_.get());
   RegisterModule("double",
       "var Add = require('add').Add;"
       "exports.Double = function(x) { return Add(x, x); };");
@@ -132,6 +152,7 @@ TEST_F(ModuleSystemTest, TestNestedRequire) {
 }
 
 TEST_F(ModuleSystemTest, TestModuleInsulation) {
+  ModuleSystem::NativesEnabledScope natives_enabled_scope(module_system_.get());
   RegisterModule("x",
       "var x = 10;"
       "exports.X = function() { return x; };");
@@ -149,30 +170,42 @@ TEST_F(ModuleSystemTest, TestModuleInsulation) {
   module_system_->Require("test");
 }
 
-TEST_F(ModuleSystemTest, TestDisableNativesPreventsNativeModulesBeingLoaded) {
-  module_system_->RegisterNativeHandler("disable",
-      scoped_ptr<NativeHandler>(
-          new DisableNativesHandler(module_system_.get())));
+TEST_F(ModuleSystemTest, TestNativesAreDisabledOutsideANativesEnabledScope) {
   RegisterModule("test",
-      "var assert = requireNative('assert');"
-      "var disable = requireNative('disable');"
-      "disable.DisableNatives();"
-      "var caught = false;"
+      "var assert;"
       "try {"
-      "  requireNative('assert');"
+      "  assert = requireNative('assert');"
       "} catch (e) {"
       "  caught = true;"
       "}"
-      "assert.AssertTrue(caught);");
+      "if (assert) {"
+      "  assert.AssertTrue(true);"
+      "}");
   module_system_->Require("test");
+  ExpectNoAssertionsMade();
+}
+
+TEST_F(ModuleSystemTest, TestNativesAreEnabledWithinANativesEnabledScope) {
+  RegisterModule("test",
+      "var assert = requireNative('assert');"
+      "assert.AssertTrue(true);");
+
+  {
+    ModuleSystem::NativesEnabledScope natives_enabled(module_system_.get());
+    {
+      ModuleSystem::NativesEnabledScope natives_enabled_inner(
+          module_system_.get());
+    }
+    module_system_->Require("test");
+  }
 }
 
 TEST_F(ModuleSystemTest, TestLazyField) {
+  ModuleSystem::NativesEnabledScope natives_enabled_scope(module_system_.get());
   RegisterModule("lazy",
       "exports.x = 5;");
 
-  v8::Handle<v8::Object> object = v8::Object::New();
-  v8::Context::GetCurrent()->Global()->Set(v8::String::New("object"), object);
+  v8::Handle<v8::Object> object = CreateGlobal("object");
 
   module_system_->SetLazyField(object, "blah", "lazy", "x");
 
@@ -181,3 +214,99 @@ TEST_F(ModuleSystemTest, TestLazyField) {
       "assert.AssertTrue(object.blah == 5);");
   module_system_->Require("test");
 }
+
+TEST_F(ModuleSystemTest, TestLazyFieldYieldingObject) {
+  ModuleSystem::NativesEnabledScope natives_enabled_scope(module_system_.get());
+  RegisterModule("lazy",
+      "var object = {};"
+      "object.__defineGetter__('z', function() { return 1; });"
+      "object.x = 5;"
+      "object.y = function() { return 10; };"
+      "exports.object = object;");
+
+  v8::Handle<v8::Object> object = CreateGlobal("object");
+
+  module_system_->SetLazyField(object, "thing", "lazy", "object");
+
+  RegisterModule("test",
+      "var assert = requireNative('assert');"
+      "assert.AssertTrue(object.thing.x == 5);"
+      "assert.AssertTrue(object.thing.y() == 10);"
+      "assert.AssertTrue(object.thing.z == 1);"
+      );
+  module_system_->Require("test");
+}
+
+TEST_F(ModuleSystemTest, TestLazyFieldIsOnlyEvaledOnce) {
+  ModuleSystem::NativesEnabledScope natives_enabled_scope(module_system_.get());
+  module_system_->RegisterNativeHandler(
+      "counter",
+      scoped_ptr<NativeHandler>(new CounterNatives()));
+  RegisterModule("lazy",
+      "requireNative('counter').Increment();"
+      "exports.x = 5;");
+
+  v8::Handle<v8::Object> object = CreateGlobal("object");
+
+  module_system_->SetLazyField(object, "x", "lazy", "x");
+
+  RegisterModule("test",
+      "var assert = requireNative('assert');"
+      "var counter = requireNative('counter');"
+      "assert.AssertTrue(counter.Get() == 0);"
+      "object.x;"
+      "assert.AssertTrue(counter.Get() == 1);"
+      "object.x;"
+      "assert.AssertTrue(counter.Get() == 1);");
+  module_system_->Require("test");
+}
+
+TEST_F(ModuleSystemTest, TestRequireNativesAfterLazyEvaluation) {
+  ModuleSystem::NativesEnabledScope natives_enabled_scope(module_system_.get());
+  RegisterModule("lazy",
+      "exports.x = 5;");
+  v8::Handle<v8::Object> object = CreateGlobal("object");
+
+  module_system_->SetLazyField(object, "x", "lazy", "x");
+  RegisterModule("test",
+      "object.x;"
+      "requireNative('assert').AssertTrue(true);");
+  module_system_->Require("test");
+}
+
+TEST_F(ModuleSystemTest, TestTransitiveRequire) {
+  ModuleSystem::NativesEnabledScope natives_enabled_scope(module_system_.get());
+  RegisterModule("dependency",
+      "exports.x = 5;");
+  RegisterModule("lazy",
+      "exports.output = require('dependency');");
+
+  v8::Handle<v8::Object> object = CreateGlobal("object");
+
+  module_system_->SetLazyField(object, "thing", "lazy", "output");
+
+  RegisterModule("test",
+      "var assert = requireNative('assert');"
+      "assert.AssertTrue(object.thing.x == 5);");
+  module_system_->Require("test");
+}
+
+TEST_F(ModuleSystemTest, TestModulesOnlyGetEvaledOnce) {
+  ModuleSystem::NativesEnabledScope natives_enabled_scope(module_system_.get());
+  module_system_->RegisterNativeHandler(
+      "counter",
+      scoped_ptr<NativeHandler>(new CounterNatives()));
+
+  RegisterModule("incrementsWhenEvaled",
+      "requireNative('counter').Increment();");
+  RegisterModule("test",
+      "var assert = requireNative('assert');"
+      "var counter = requireNative('counter');"
+      "assert.AssertTrue(counter.Get() == 0);"
+      "require('incrementsWhenEvaled');"
+      "assert.AssertTrue(counter.Get() == 1);"
+      "require('incrementsWhenEvaled');"
+      "assert.AssertTrue(counter.Get() == 1);");
+
+  module_system_->Require("test");
+}