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

chrome/renderer/extensions/extension_dispatcher.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/extension_dispatcher.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_piece.h"
@@ skipping 100 matching lines @@
 
     std::vector<std::string> components;
     for (int i = 0; i < args.Length(); ++i)
       components.push_back(*v8::String::Utf8Value(args[i]->ToString()));
 
     LOG(ERROR) << JoinString(components, ',');
     return v8::Undefined();
   }
 };
 
+void InstallAppBindings(ModuleSystem* module_system,
+                        v8::Handle<v8::Object> chrome,
+                        v8::Handle<v8::Object> chrome_hidden) {
+  module_system->SetLazyField(chrome, "app", "app", "chromeApp");
+  module_system->SetLazyField(chrome, "appNotifications", "app",
+                              "chromeAppNotifications");
+  module_system->SetLazyField(chrome_hidden, "app", "app",
+                              "chromeHiddenApp");
+}
+
+void InstallWebstoreBindings(ModuleSystem* module_system,
+                             v8::Handle<v8::Object> chrome,
+                             v8::Handle<v8::Object> chrome_hidden) {
+  module_system->SetLazyField(chrome, "webstore", "webstore", "chromeWebstore");
+  module_system->SetLazyField(chrome_hidden, "webstore", "webstore",
+                              "chromeHiddenWebstore");
+}
+
 }
 
 ExtensionDispatcher::ExtensionDispatcher()
     : is_webkit_initialized_(false),
       webrequest_adblock_(false),
       webrequest_adblock_plus_(false),
       webrequest_other_(false),
       source_map_(&ResourceBundle::GetSharedInstance()) {
   const CommandLine& command_line = *(CommandLine::ForCurrentProcess());
   is_extension_process_ =
       command_line.HasSwitch(switches::kExtensionProcess) ||
       command_line.HasSwitch(switches::kSingleProcess);
 
   if (is_extension_process_) {
     RenderThread::Get()->SetIdleNotificationDelayInMs(
         kInitialExtensionIdleHandlerDelayMs);
   }
 
   user_script_slave_.reset(new UserScriptSlave(&extensions_));
   PopulateSourceMap();
+  PopulateLazyBindingsMap();
 }
 
 ExtensionDispatcher::~ExtensionDispatcher() {
 }
 
 bool ExtensionDispatcher::OnControlMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ExtensionDispatcher, message)
     IPC_MESSAGE_HANDLER(ExtensionMsg_MessageInvoke, OnMessageInvoke)
@@ skipping 270 matching lines @@
                              IDR_PAGE_CAPTURE_CUSTOM_BINDINGS_JS);
   source_map_.RegisterSource("storage", IDR_STORAGE_CUSTOM_BINDINGS_JS);
   source_map_.RegisterSource("tabs", IDR_TABS_CUSTOM_BINDINGS_JS);
   source_map_.RegisterSource("tts", IDR_TTS_CUSTOM_BINDINGS_JS);
   source_map_.RegisterSource("ttsEngine", IDR_TTS_ENGINE_CUSTOM_BINDINGS_JS);
   source_map_.RegisterSource("types", IDR_TYPES_CUSTOM_BINDINGS_JS);
   source_map_.RegisterSource("webRequest", IDR_WEB_REQUEST_CUSTOM_BINDINGS_JS);
   source_map_.RegisterSource("webstore", IDR_WEBSTORE_CUSTOM_BINDINGS_JS);
 }
 
+void ExtensionDispatcher::PopulateLazyBindingsMap() {
+  lazy_bindings_map_["app"] = InstallAppBindings;
+  lazy_bindings_map_["webstore"] = InstallWebstoreBindings;
+}
+
+void ExtensionDispatcher::InstallBindings(ModuleSystem* module_system,
+                                          v8::Handle<v8::Context> v8_context,
+                                          const std::string& api) {
+  std::map<std::string, BindingInstaller>::const_iterator lazy_binding =
+      lazy_bindings_map_.find(api);
+  if (lazy_binding != lazy_bindings_map_.end()) {
+    v8::Handle<v8::Object> global(v8_context->Global());
+    v8::Handle<v8::Object> chrome =
+        global->Get(v8::String::New("chrome"))->ToObject();
+    v8::Handle<v8::Object> chrome_hidden =
+        ChromeV8Context::GetOrCreateChromeHidden(v8_context)->ToObject();
+    (*lazy_binding->second)(module_system, chrome, chrome_hidden);
+  } else {
+    module_system->Require(api);
+  }
+}
+
 void ExtensionDispatcher::DidCreateScriptContext(
     WebFrame* frame, v8::Handle<v8::Context> v8_context, int extension_group,
     int world_id) {
   // TODO(koz): If the caller didn't pass extension_group, use the last value.
   if (extension_group == -1)
     extension_group = g_hack_extension_group;
 
   std::string extension_id = GetExtensionID(frame, world_id);
 
   const Extension* extension = extensions_.GetByID(extension_id);
@@ skipping 12 matching lines @@
       UserScriptSlave::GetDataSourceURLForFrame(frame));
 
   Feature::Context context_type =
       ClassifyJavaScriptContext(extension_id, extension_group, url_info);
 
   ChromeV8Context* context =
       new ChromeV8Context(v8_context, frame, extension_id, context_type);
   v8_context_set_.Add(context);
 
   scoped_ptr<ModuleSystem> module_system(new ModuleSystem(&source_map_));
+  // Enable natives in startup.
+  ModuleSystem::NativesEnabledScope natives_enabled_scope(module_system.get());
+
   RegisterNativeHandlers(module_system.get(), context);
 
   module_system->RegisterNativeHandler("chrome_hidden",
       scoped_ptr<NativeHandler>(new ChromeHiddenNativeHandler()));
   module_system->RegisterNativeHandler("print",
       scoped_ptr<NativeHandler>(new PrintNativeHandler()));
 
   int manifest_version = 1;
   if (extension)
     manifest_version = extension->manifest_version();
 
   // Create the 'chrome' variable if it doesn't already exist.
   {
     v8::HandleScope handle_scope;
     v8::Handle<v8::String> chrome_string(v8::String::New("chrome"));
     v8::Handle<v8::Object> global(v8::Context::GetCurrent()->Global());
     if (global->Get(chrome_string)->IsUndefined())
       global->Set(chrome_string, v8::Object::New());
   }
 
   // Loading JavaScript is expensive, so only run the full API bindings
   // generation mechanisms in extension pages (NOT all web pages).
   switch (context_type) {
     case Feature::UNSPECIFIED_CONTEXT:
     case Feature::WEB_PAGE_CONTEXT:
       // TODO(kalman): see comment below about ExtensionAPI.
-      module_system->Require("app");
-      module_system->Require("webstore");
+      InstallBindings(module_system.get(), v8_context, "app");
+      InstallBindings(module_system.get(), v8_context, "webstore");
       break;
 
     case Feature::BLESSED_EXTENSION_CONTEXT:
     case Feature::UNBLESSED_EXTENSION_CONTEXT:
     case Feature::CONTENT_SCRIPT_CONTEXT: {
       module_system->Require("json_schema");
       module_system->Require("event_bindings");
       module_system->Require("miscellaneous_bindings");
       module_system->Require("schema_generated_bindings");
       module_system->Require("apitest");
 
       // TODO(kalman): move this code back out of the switch and execute it
       // regardless of |context_type|. ExtensionAPI knows how to return the
       // correct APIs, however, until it doesn't have a 2MB overhead we can't
       // load it in every process.
       scoped_ptr<std::set<std::string> > apis =
         ExtensionAPI::GetInstance()->GetAPIsForContext(
             context_type, extension, url_info.url());
       for (std::set<std::string>::iterator i = apis->begin(); i != apis->end();
           ++i) {
-        module_system->Require(*i);
+        InstallBindings(module_system.get(), v8_context, *i);
       }
 
       break;
     }
   }
 
   // TODO(kalman): this is probably the most unfortunate thing I've ever had to
   // write. We really need to factor things differently to delete the concept
   // of a test extension ID.
   if (IsTestExtensionId(extension_id)) {
     module_system->Require("miscellaneous_bindings");
     module_system->Require("schema_generated_bindings");
-    module_system->Require("extension");
+    InstallBindings(module_system.get(), v8_context, "extension");
   }
 
-  module_system->set_natives_enabled(false);
-
   context->set_module_system(module_system.Pass());
 
   context->DispatchOnLoadEvent(
       is_extension_process_,
       ChromeRenderProcessObserver::is_incognito_process(),
       manifest_version);
 
   VLOG(1) << "Num tracked contexts: " << v8_context_set_.size();
 }
 
@@ skipping 171 matching lines @@
     return Feature::BLESSED_EXTENSION_CONTEXT;
 
   if (extensions_.ExtensionBindingsAllowed(url_info))
     return Feature::UNBLESSED_EXTENSION_CONTEXT;
 
   if (url_info.url().is_valid())
     return Feature::WEB_PAGE_CONTEXT;
 
   return Feature::UNSPECIFIED_CONTEXT;
 }