Make miscellaneous_bindings.js not depend on onLoad().

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 177 matching lines @@
                                    const Extension* extension) {
     if (!render_view)
       return false;
 
     ExtensionHelper* helper = ExtensionHelper::Get(render_view);
     return (extension && extension->has_lazy_background_page() &&
             helper->view_type() == chrome::VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
   }
 };
 
+class ProcessInfoNativeHandler : public ChromeV8Extension {
+ public:
+  explicit ProcessInfoNativeHandler(
+      ExtensionDispatcher* dispatcher,
+      const std::string& extension_id,
+      const std::string& context_type,
+      bool is_incognito_context,
+      int manifest_version)
+      : ChromeV8Extension(dispatcher),
+        extension_id_(extension_id),
+        context_type_(context_type),
+        is_incognito_context_(is_incognito_context),
+        manifest_version_(manifest_version) {
+    RouteFunction("GetExtensionId",
+        base::Bind(&ProcessInfoNativeHandler::GetExtensionId,
+                   base::Unretained(this)));
+    RouteFunction("GetContextType",
+        base::Bind(&ProcessInfoNativeHandler::GetContextType,
+                   base::Unretained(this)));
+    RouteFunction("IsIncognitoContext",
+        base::Bind(&ProcessInfoNativeHandler::IsIncognitoContext,
+                   base::Unretained(this)));
+    RouteFunction("GetManifestVersion",
+        base::Bind(&ProcessInfoNativeHandler::GetManifestVersion,
+                   base::Unretained(this)));
+  }
+
+  v8::Handle<v8::Value> GetExtensionId(const v8::Arguments& args) {
+    return v8::String::New(extension_id_.c_str());
+  }
+
+  v8::Handle<v8::Value> GetContextType(const v8::Arguments& args) {
+    return v8::String::New(context_type_.c_str());
+  }
+
+  v8::Handle<v8::Value> IsIncognitoContext(const v8::Arguments& args) {
+    return v8::Boolean::New(is_incognito_context_);
+  }
+
+  v8::Handle<v8::Value> GetManifestVersion(const v8::Arguments& args) {
+    return v8::Integer::New(manifest_version_);
+  }
+
+ private:
+  std::string extension_id_;
+  std::string context_type_;
+  bool is_incognito_context_;
+  int manifest_version_;
+};
+
 class ChannelNativeHandler : public NativeHandler {
  public:
   explicit ChannelNativeHandler(chrome::VersionInfo::Channel channel)
       : channel_(channel) {
     RouteFunction("IsDevChannel",
         base::Bind(&ChannelNativeHandler::IsDevChannel,
                    base::Unretained(this)));
   }
 
   v8::Handle<v8::Value> IsDevChannel(const v8::Arguments& args) {
@@ skipping 475 matching lines @@
 
   module_system->RegisterNativeHandler("chrome_hidden",
       scoped_ptr<NativeHandler>(new ChromeHiddenNativeHandler()));
   module_system->RegisterNativeHandler("print",
       scoped_ptr<NativeHandler>(new PrintNativeHandler()));
   module_system->RegisterNativeHandler("lazy_background_page",
       scoped_ptr<NativeHandler>(new LazyBackgroundPageNativeHandler(this)));
   module_system->RegisterNativeHandler("channel",
       scoped_ptr<NativeHandler>(new ChannelNativeHandler(
           static_cast<chrome::VersionInfo::Channel>(chrome_channel_))));
+
+  int manifest_version = extension ? extension->manifest_version() : 1;
+  module_system->RegisterNativeHandler("process",
+      scoped_ptr<NativeHandler>(new ProcessInfoNativeHandler(
+          this, context->GetExtensionID(),
+          context->GetContextTypeDescription(),
+          ChromeRenderProcessObserver::is_incognito_process(),
+          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());
     v8::Handle<v8::Value> chrome(global->Get(chrome_string));
     if (chrome.IsEmpty() || chrome->IsUndefined())
       global->Set(chrome_string, v8::Object::New());
   }
 
@@ skipping 34 matching lines @@
   if (IsWithinPlatformApp(frame))
     module_system->Require("platformApp");
 
   if (context_type == Feature::BLESSED_EXTENSION_CONTEXT &&
       extension && extension->HasAPIPermission(APIPermission::kBrowserTag)) {
     module_system->Require("browserTag");
   }
 
   context->set_module_system(module_system.Pass());
 
-  int manifest_version = 1;
-  if (extension)
-    manifest_version = extension->manifest_version();
   context->DispatchOnLoadEvent(
       ChromeRenderProcessObserver::is_incognito_process(),
       manifest_version);
 
   VLOG(1) << "Num tracked contexts: " << v8_context_set_.size();
 }
 
 std::string ExtensionDispatcher::GetExtensionID(const WebFrame* frame,
                                                 int world_id) {
   if (world_id != 0) {
@@ skipping 272 matching lines @@
   // APIs, they don't get extension bindings injected. If we end up here it
   // means that a sandboxed page somehow managed to invoke an API anyway, so
   // we should abort.
   WebKit::WebFrame* frame = context->web_frame();
   ExtensionURLInfo url_info(frame->document().securityOrigin(),
       UserScriptSlave::GetDataSourceURLForFrame(frame));
   CHECK(!extensions_.IsSandboxedPage(url_info));
 
   return true;
 }