Extensions: pass ChromeV8Context around instead of v8::Handle.

chrome/renderer/extensions/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/dispatcher.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/json/json_reader.h"
@@ skipping 101 matching lines @@
     v8::Handle<v8::Object> chrome_object(v8::Object::New());
     global->Set(chrome_string, chrome_object);
     return chrome_object;
   }
   CHECK(chrome->IsObject());
   return chrome->ToObject();
 }
 
 class TestFeaturesNativeHandler : public ObjectBackedNativeHandler {
  public:
-  explicit TestFeaturesNativeHandler(v8::Handle<v8::Context> context)
+  explicit TestFeaturesNativeHandler(ChromeV8Context* context)
       : ObjectBackedNativeHandler(context) {
     RouteFunction("GetAPIFeatures",
         base::Bind(&TestFeaturesNativeHandler::GetAPIFeatures,
                    base::Unretained(this)));
   }
 
  private:
   v8::Handle<v8::Value> GetAPIFeatures(const v8::Arguments& args) {
     base::Value* value = base::JSONReader::Read(
         ResourceBundle::GetSharedInstance().GetRawDataResource(
             IDR_EXTENSION_API_FEATURES).as_string());
     scoped_ptr<content::V8ValueConverter> converter(
         content::V8ValueConverter::create());
-    return converter->ToV8Value(value, v8_context());
+    return converter->ToV8Value(value, context()->v8_context());
   }
 };
 
 class SchemaRegistryNativeHandler : public ObjectBackedNativeHandler {
  public:
   SchemaRegistryNativeHandler(V8SchemaRegistry* registry,
-                              v8::Handle<v8::Context> context)
+                              ChromeV8Context* context)
       : ObjectBackedNativeHandler(context),
         registry_(registry) {
     RouteFunction("GetSchema",
         base::Bind(&SchemaRegistryNativeHandler::GetSchema,
                    base::Unretained(this)));
   }
 
  private:
   v8::Handle<v8::Value> GetSchema(const v8::Arguments& args) {
     return registry_->GetSchema(*v8::String::AsciiValue(args[0]));
   }
 
   V8SchemaRegistry* registry_;
 };
 
 class V8ContextNativeHandler : public ObjectBackedNativeHandler {
  public:
   V8ContextNativeHandler(ChromeV8Context* context, Dispatcher* dispatcher)
-      : ObjectBackedNativeHandler(context->v8_context()),
+      : ObjectBackedNativeHandler(context),
         context_(context),
         dispatcher_(dispatcher) {
     RouteFunction("GetAvailability",
         base::Bind(&V8ContextNativeHandler::GetAvailability,
                    base::Unretained(this)));
     RouteFunction("GetModuleSystem",
         base::Bind(&V8ContextNativeHandler::GetModuleSystem,
                    base::Unretained(this)));
   }
 
@@ skipping 20 matching lines @@
         v8_context);
     return context->module_system()->NewInstance();
   }
 
   ChromeV8Context* context_;
   Dispatcher* dispatcher_;
 };
 
 class ChromeHiddenNativeHandler : public ObjectBackedNativeHandler {
  public:
-  explicit ChromeHiddenNativeHandler(v8::Handle<v8::Context> context)
+  explicit ChromeHiddenNativeHandler(ChromeV8Context* context)
       : ObjectBackedNativeHandler(context) {
     RouteFunction("GetChromeHidden",
         base::Bind(&ChromeHiddenNativeHandler::GetChromeHidden,
                    base::Unretained(this)));
   }
 
   v8::Handle<v8::Value> GetChromeHidden(const v8::Arguments& args) {
-    return ChromeV8Context::GetOrCreateChromeHidden(v8_context());
+    return ChromeV8Context::GetOrCreateChromeHidden(context()->v8_context());
   }
 };
 
 class ChromeNativeHandler : public ObjectBackedNativeHandler {
  public:
-  explicit ChromeNativeHandler(v8::Handle<v8::Context> context)
+  explicit ChromeNativeHandler(ChromeV8Context* context)
       : ObjectBackedNativeHandler(context) {
     RouteFunction("GetChrome",
         base::Bind(&ChromeNativeHandler::GetChrome, base::Unretained(this)));
   }
 
   v8::Handle<v8::Value> GetChrome(const v8::Arguments& args) {
-    return GetOrCreateChrome(v8_context());
+    return GetOrCreateChrome(context()->v8_context());
   }
 };
 
 class PrintNativeHandler : public ObjectBackedNativeHandler {
  public:
-  explicit PrintNativeHandler(v8::Handle<v8::Context> context)
+  explicit PrintNativeHandler(ChromeV8Context* context)
       : ObjectBackedNativeHandler(context) {
     RouteFunction("Print",
         base::Bind(&PrintNativeHandler::Print,
                    base::Unretained(this)));
   }
 
   v8::Handle<v8::Value> Print(const v8::Arguments& args) {
     if (args.Length() < 1)
       return v8::Undefined();
 
     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();
   }
 };
 
 class LazyBackgroundPageNativeHandler : public ChromeV8Extension {
  public:
   LazyBackgroundPageNativeHandler(Dispatcher* dispatcher,
-                                  v8::Handle<v8::Context> context)
+                                  ChromeV8Context* context)
       : ChromeV8Extension(dispatcher, context) {
     RouteFunction("IncrementKeepaliveCount",
         base::Bind(&LazyBackgroundPageNativeHandler::IncrementKeepaliveCount,
                    base::Unretained(this)));
     RouteFunction("DecrementKeepaliveCount",
         base::Bind(&LazyBackgroundPageNativeHandler::DecrementKeepaliveCount,
                    base::Unretained(this)));
   }
 
   v8::Handle<v8::Value> IncrementKeepaliveCount(const v8::Arguments& args) {
-    ChromeV8Context* context =
-        dispatcher()->v8_context_set().GetByV8Context(v8_context());
+    ChromeV8Context* context = GetContext();

[not at google - send to devlin, 2013/05/29 17:41:55]

could inline this as context() too, etc below.

[marja, 2013/05/31 10:06:44]

Done.

     if (!context)
       return v8::Undefined();
     RenderView* render_view = context->GetRenderView();
     if (IsContextLazyBackgroundPage(render_view, context->extension())) {
       render_view->Send(new ExtensionHostMsg_IncrementLazyKeepaliveCount(
           render_view->GetRoutingID()));
     }
     return v8::Undefined();
   }
 
   v8::Handle<v8::Value> DecrementKeepaliveCount(const v8::Arguments& args) {
-    ChromeV8Context* context =
-        dispatcher()->v8_context_set().GetByV8Context(v8_context());
+    ChromeV8Context* context = GetContext();
     if (!context)
       return v8::Undefined();
     RenderView* render_view = context->GetRenderView();
     if (IsContextLazyBackgroundPage(render_view, context->extension())) {
       render_view->Send(new ExtensionHostMsg_DecrementLazyKeepaliveCount(
           render_view->GetRoutingID()));
     }
     return v8::Undefined();
   }
 
  private:
   bool IsContextLazyBackgroundPage(RenderView* render_view,
                                    const Extension* extension) {
     if (!render_view)
       return false;
 
     ExtensionHelper* helper = ExtensionHelper::Get(render_view);
     return (extension && BackgroundInfo::HasLazyBackgroundPage(extension) &&
             helper->view_type() == VIEW_TYPE_EXTENSION_BACKGROUND_PAGE);
   }
 };
 
 class ProcessInfoNativeHandler : public ChromeV8Extension {
  public:
   ProcessInfoNativeHandler(Dispatcher* dispatcher,
-                           v8::Handle<v8::Context> context,
+                           ChromeV8Context* context,
                            const std::string& extension_id,
                            const std::string& context_type,
                            bool is_incognito_context,
                            int manifest_version,
                            bool send_request_disabled)
       : ChromeV8Extension(dispatcher, context),
         extension_id_(extension_id),
         context_type_(context_type),
         is_incognito_context_(is_incognito_context),
         manifest_version_(manifest_version),
@@ skipping 43 matching lines @@
  private:
   std::string extension_id_;
   std::string context_type_;
   bool is_incognito_context_;
   int manifest_version_;
   bool send_request_disabled_;
 };
 
 class LoggingNativeHandler : public ObjectBackedNativeHandler {
  public:
-  explicit LoggingNativeHandler(v8::Handle<v8::Context> context)
+  explicit LoggingNativeHandler(ChromeV8Context* context)
       : ObjectBackedNativeHandler(context) {
     RouteFunction("DCHECK",
         base::Bind(&LoggingNativeHandler::Dcheck, base::Unretained(this)));
     RouteFunction("CHECK",
         base::Bind(&LoggingNativeHandler::Check, base::Unretained(this)));
   }
 
   v8::Handle<v8::Value> Check(const v8::Arguments& args) {
     bool check_value;
     std::string error_message;
@@ skipping 381 matching lines @@
           !context->GetAvailability(api_name).is_available()) {
         only_ancestor_available = true;
         break;
       }
       bind_object = GetOrCreateObject(bind_object, split[i]);
     }
     if (only_ancestor_available)
       continue;
 
     if (lazy_bindings_map_.find(api_name) != lazy_bindings_map_.end()) {
-      InstallBindings(module_system, context->v8_context(), api_name);
+      InstallBindings(
+          module_system, context->v8_context(), api_name);
     } else if (!source_map_.Contains(api_name)) {
       module_system->RegisterNativeHandler(
           api_name,
           scoped_ptr<NativeHandler>(new BindingGeneratingNativeHandler(
               module_system,
               api_name,
               "binding")));
       module_system->SetNativeLazyField(bind_object,
                                         split.back(),
                                         api_name,
                                         "binding");
     } else {
       module_system->SetLazyField(bind_object,
                                   split.back(),
                                   api_name,
                                   "binding");
     }
   }
 }
 
 void Dispatcher::RegisterNativeHandlers(ModuleSystem* module_system,
                                         ChromeV8Context* context) {
-  v8::Handle<v8::Context> v8_context = context->v8_context();
-
   module_system->RegisterNativeHandler("event_bindings",
-      scoped_ptr<NativeHandler>(EventBindings::Create(this, v8_context)));
+      scoped_ptr<NativeHandler>(EventBindings::Create(this, context)));
   module_system->RegisterNativeHandler("miscellaneous_bindings",
-      scoped_ptr<NativeHandler>(MiscellaneousBindings::Get(this, v8_context)));
+      scoped_ptr<NativeHandler>(MiscellaneousBindings::Get(this, context)));
   module_system->RegisterNativeHandler("apiDefinitions",
       scoped_ptr<NativeHandler>(new ApiDefinitionsNatives(this, context)));
   module_system->RegisterNativeHandler("sendRequest",
       scoped_ptr<NativeHandler>(
           new SendRequestNatives(this, request_sender_.get(), context)));
   module_system->RegisterNativeHandler("setIcon",
       scoped_ptr<NativeHandler>(
           new SetIconNatives(this, request_sender_.get(), context)));
   module_system->RegisterNativeHandler(
       "contentWatcherNative",
-      content_watcher_->MakeNatives(v8_context));
+      content_watcher_->MakeNatives(context));
   module_system->RegisterNativeHandler("activityLogger",
-      scoped_ptr<NativeHandler>(new APIActivityLogger(this, v8_context)));
+      scoped_ptr<NativeHandler>(new APIActivityLogger(this, context)));
 
   // Natives used by multiple APIs.
   module_system->RegisterNativeHandler("file_system_natives",
-      scoped_ptr<NativeHandler>(new FileSystemNatives(v8_context)));
+      scoped_ptr<NativeHandler>(new FileSystemNatives(context)));
 
   // Custom bindings.
   module_system->RegisterNativeHandler("app",
       scoped_ptr<NativeHandler>(new AppBindings(this, context)));
   module_system->RegisterNativeHandler("app_runtime",
       scoped_ptr<NativeHandler>(
-          new AppRuntimeCustomBindings(this, v8_context)));
+          new AppRuntimeCustomBindings(this, context)));
   module_system->RegisterNativeHandler("app_window",
       scoped_ptr<NativeHandler>(
-          new AppWindowCustomBindings(this, v8_context)));
+          new AppWindowCustomBindings(this, context)));
   module_system->RegisterNativeHandler("context_menus",
       scoped_ptr<NativeHandler>(
-          new ContextMenusCustomBindings(this, v8_context)));
+          new ContextMenusCustomBindings(this, context)));
   module_system->RegisterNativeHandler("extension",
       scoped_ptr<NativeHandler>(
-          new ExtensionCustomBindings(this, v8_context)));
+          new ExtensionCustomBindings(this, context)));
   module_system->RegisterNativeHandler("sync_file_system",
       scoped_ptr<NativeHandler>(
-          new SyncFileSystemCustomBindings(this, v8_context)));
+          new SyncFileSystemCustomBindings(this, context)));
   module_system->RegisterNativeHandler("file_browser_handler",
       scoped_ptr<NativeHandler>(new FileBrowserHandlerCustomBindings(
-          this, v8_context)));
+          this, context)));
   module_system->RegisterNativeHandler("file_browser_private",
       scoped_ptr<NativeHandler>(new FileBrowserPrivateCustomBindings(
-          this, v8_context)));
+          this, context)));
   module_system->RegisterNativeHandler("i18n",
       scoped_ptr<NativeHandler>(
-          new I18NCustomBindings(this, v8_context)));
+          new I18NCustomBindings(this, context)));
   module_system->RegisterNativeHandler("mediaGalleries",
       scoped_ptr<NativeHandler>(
-          new MediaGalleriesCustomBindings(this, v8_context)));
+          new MediaGalleriesCustomBindings(this, context)));
   module_system->RegisterNativeHandler("page_actions",
       scoped_ptr<NativeHandler>(
-          new PageActionsCustomBindings(this, v8_context)));
+          new PageActionsCustomBindings(this, context)));
   module_system->RegisterNativeHandler("page_capture",
       scoped_ptr<NativeHandler>(
-          new PageCaptureCustomBindings(this, v8_context)));
+          new PageCaptureCustomBindings(this, context)));
   module_system->RegisterNativeHandler("runtime",
       scoped_ptr<NativeHandler>(new RuntimeCustomBindings(this, context)));
   module_system->RegisterNativeHandler("tabs",
-      scoped_ptr<NativeHandler>(new TabsCustomBindings(this, v8_context)));
+      scoped_ptr<NativeHandler>(new TabsCustomBindings(this, context)));
   module_system->RegisterNativeHandler("tts",
-      scoped_ptr<NativeHandler>(new TTSCustomBindings(this, v8_context)));
+      scoped_ptr<NativeHandler>(new TTSCustomBindings(this, context)));
   module_system->RegisterNativeHandler("web_request",
       scoped_ptr<NativeHandler>(
-          new WebRequestCustomBindings(this, v8_context)));
+          new WebRequestCustomBindings(this, context)));
   module_system->RegisterNativeHandler("webstore",
       scoped_ptr<NativeHandler>(new WebstoreBindings(this, context)));
 }
 
 void Dispatcher::PopulateSourceMap() {
   source_map_.RegisterSource("event_bindings", IDR_EVENT_BINDINGS_JS);
   source_map_.RegisterSource("miscellaneous_bindings",
       IDR_MISCELLANEOUS_BINDINGS_JS);
   source_map_.RegisterSource("json", IDR_JSON_JS);
   source_map_.RegisterSource("json_schema", IDR_JSON_SCHEMA_JS);
@@ skipping 140 matching lines @@
   ExtensionURLInfo url_info(frame->document().securityOrigin(),
       UserScriptSlave::GetDataSourceURLForFrame(frame));
 
   Feature::Context context_type =
       ClassifyJavaScriptContext(extension_id, extension_group, url_info);
 
   ChromeV8Context* context =
       new ChromeV8Context(v8_context, frame, extension, context_type);
   v8_context_set_.Add(context);
 
-  scoped_ptr<ModuleSystem> module_system(new ModuleSystem(v8_context,
+  scoped_ptr<ModuleSystem> module_system(new ModuleSystem(context,
                                                           &source_map_));
   // Enable natives in startup.
   ModuleSystem::NativesEnabledScope natives_enabled_scope(module_system.get());
 
   RegisterNativeHandlers(module_system.get(), context);
 
   module_system->RegisterNativeHandler("chrome",
-      scoped_ptr<NativeHandler>(new ChromeNativeHandler(v8_context)));
+      scoped_ptr<NativeHandler>(new ChromeNativeHandler(context)));
   module_system->RegisterNativeHandler("chrome_hidden",
-      scoped_ptr<NativeHandler>(new ChromeHiddenNativeHandler(v8_context)));
+      scoped_ptr<NativeHandler>(new ChromeHiddenNativeHandler(context)));
   module_system->RegisterNativeHandler("print",
-      scoped_ptr<NativeHandler>(new PrintNativeHandler(v8_context)));
+      scoped_ptr<NativeHandler>(new PrintNativeHandler(context)));
   module_system->RegisterNativeHandler("lazy_background_page",
       scoped_ptr<NativeHandler>(
-          new LazyBackgroundPageNativeHandler(this, v8_context)));
+          new LazyBackgroundPageNativeHandler(this, context)));
   module_system->RegisterNativeHandler("logging",
-      scoped_ptr<NativeHandler>(new LoggingNativeHandler(v8_context)));
+      scoped_ptr<NativeHandler>(new LoggingNativeHandler(context)));
   module_system->RegisterNativeHandler("schema_registry",
       scoped_ptr<NativeHandler>(
-          new SchemaRegistryNativeHandler(v8_schema_registry(), v8_context)));
+          new SchemaRegistryNativeHandler(v8_schema_registry(), context)));
   module_system->RegisterNativeHandler("v8_context",
       scoped_ptr<NativeHandler>(new V8ContextNativeHandler(context, this)));
   module_system->RegisterNativeHandler("test_features",
-      scoped_ptr<NativeHandler>(new TestFeaturesNativeHandler(v8_context)));
+      scoped_ptr<NativeHandler>(new TestFeaturesNativeHandler(context)));
 
   int manifest_version = extension ? extension->manifest_version() : 1;
   bool send_request_disabled =
       (extension && Manifest::IsUnpackedLocation(extension->location()) &&
        BackgroundInfo::HasLazyBackgroundPage(extension));
   module_system->RegisterNativeHandler("process",
       scoped_ptr<NativeHandler>(new ProcessInfoNativeHandler(
-          this, v8_context, context->GetExtensionID(),
+          this, context, context->GetExtensionID(),
           context->GetContextTypeDescription(),
           ChromeRenderProcessObserver::is_incognito_process(),
           manifest_version, send_request_disabled)));
 
   GetOrCreateChrome(v8_context);
 
   // 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:
@@ skipping 394 matching lines @@
     std::string error_msg = base::StringPrintf(kMessage, function_name.c_str());
     v8::ThrowException(
         v8::Exception::Error(v8::String::New(error_msg.c_str())));
     return false;
   }
 
   return true;
 }
 
 }  // namespace extensions