Implement lazy JS module initialisation.

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"
 
 namespace {
 
-const char* kLazyObjectSource = "lazy_object_source";
-const char* kLazyObjectName = "lazy_object_name";
-const char* kLazyObject = "lazy_object";
-
-v8::Handle<v8::Object> EvaluateLazySource(v8::Handle<v8::Object> object) {
-  v8::HandleScope handle_scope;
-  v8::Handle<v8::Value> source_value =
-      object->GetHiddenValue(v8::String::New(kLazyObjectSource));
-  CHECK(!source_value.IsEmpty());
-  v8::Handle<v8::String> source = v8::Handle<v8::String>::Cast(source_value);
-  v8::Handle<v8::Value> name =
-      object->GetHiddenValue(v8::String::New(kLazyObjectName));
-  CHECK(!name.IsEmpty());
-  CHECK(name->IsString());
-  v8::Handle<v8::Script> script = v8::Script::New(source, name);
-  v8::Handle<v8::Value> result = script->Run();
-  CHECK(result->IsObject());
-  return handle_scope.Close(v8::Handle<v8::Object>::Cast(result));
-}
-
-v8::Handle<v8::Value> LazyObjectGetter(
-    const v8::Local<v8::String> property,
-    const v8::AccessorInfo& info) {
-  v8::HandleScope handle_scope;
-  v8::Handle<v8::Object> object = info.Holder();
-  v8::Handle<v8::String> lazy_object_name = v8::String::New(kLazyObject);
-  v8::Handle<v8::Value> lazy_object_value =
-      object->GetHiddenValue(lazy_object_name);
-  CHECK(lazy_object_value.IsEmpty() || lazy_object_value->IsObject());
-  v8::Handle<v8::Object> lazy_object =
-      v8::Handle<v8::Object>::Cast(lazy_object_value);
-  if (lazy_object.IsEmpty()) {
-    lazy_object = EvaluateLazySource(object);
-    object->SetHiddenValue(lazy_object_name, lazy_object);
-  }
-  return handle_scope.Close(lazy_object->Get(property));
-}
+const char* kModuleSystem = "module_system";
+const char* kModuleName = "module_name";
+const char* kModuleField = "module_field";
 
 } // namespace
 
 ModuleSystem::ModuleSystem(SourceMap* source_map)
     : source_map_(source_map),
       natives_enabled_(true) {
   RouteFunction("require",
       base::Bind(&ModuleSystem::RequireForJs, base::Unretained(this)));
   RouteFunction("requireNative",
       base::Bind(&ModuleSystem::GetNative, base::Unretained(this)));
@@ skipping 49 matching lines @@
   native_handler_map_[name] =
       linked_ptr<NativeHandler>(native_handler.release());
 }
 
 void ModuleSystem::RunString(const std::string& code, const std::string& name) {
   v8::HandleScope handle_scope;
   RunString(v8::String::New(code.c_str()), v8::String::New(name.c_str()));
 }
 
 // static
-v8::Handle<v8::Object> ModuleSystem::CreateLazyObject(
-    const std::string& source_name, v8::Handle<v8::String> source) {
+v8::Handle<v8::Value> ModuleSystem::GetterRouter(

[not at google - send to devlin, 2012/03/22 00:35:53]

RequireLazyField?

[koz (OOO until 15th September), 2012/03/22 01:13:01]

Yes, or even better - LazyFieldAccessor.

+    v8::Local<v8::String> property, const v8::AccessorInfo& info) {
+  CHECK(!info.Data().IsEmpty());
+  CHECK(info.Data()->IsObject());
   v8::HandleScope handle_scope;
-  v8::Handle<v8::ObjectTemplate> object_template = v8::ObjectTemplate::New();
-  object_template->SetNamedPropertyHandler(LazyObjectGetter, NULL);
-  v8::Handle<v8::Object> object = object_template->NewInstance();
-  object->SetHiddenValue(v8::String::New(kLazyObjectSource), source);
-  object->SetHiddenValue(v8::String::New(kLazyObjectName),
-                         v8::String::New(source_name.c_str()));
+  v8::Handle<v8::Object> parameters = v8::Handle<v8::Object>::Cast(info.Data());
+  v8::Handle<v8::Value> module_system_value =
+      parameters->Get(v8::String::New(kModuleSystem));
+  ModuleSystem* module_system = static_cast<ModuleSystem*>(
+      v8::Handle<v8::External>::Cast(module_system_value)->Value());
 
-  return handle_scope.Close(object);
+  v8::Handle<v8::Object> module = module_system->RequireForJsInner(
+      parameters->Get(v8::String::New(kModuleName))->ToString())->ToObject();
+
+  v8::Handle<v8::String> field =
+      parameters->Get(v8::String::New(kModuleField))->ToString();
+
+  return handle_scope.Close(module->Get(field));
+}
+
+void ModuleSystem::SetLazyField(v8::Handle<v8::Object> object,
+                                const std::string& field,
+                                const std::string& module_name,
+                                const std::string& module_field) {
+  v8::HandleScope handle_scope;
+  v8::Handle<v8::Object> parameters = v8::Object::New();
+  parameters->Set(v8::String::New(kModuleName),
+                  v8::String::New(module_name.c_str()));
+  parameters->Set(v8::String::New(kModuleField),
+                  v8::String::New(module_field.c_str()));
+  parameters->Set(v8::String::New(kModuleSystem), v8::External::New(this));
+
+  object->SetAccessor(v8::String::New(field.c_str()),
+                      &ModuleSystem::GetterRouter,
+                      NULL,
+                      parameters);
 }
 
 v8::Handle<v8::Value> ModuleSystem::RunString(v8::Handle<v8::String> code,
                                               v8::Handle<v8::String> name) {
   v8::HandleScope handle_scope;
   return handle_scope.Close(v8::Script::New(code, name)->Run());
 }
 
 v8::Handle<v8::Value> ModuleSystem::GetSource(
     v8::Handle<v8::String> source_name) {
@@ skipping 20 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()));
 }