Regenerate Extensions API bindings when optional permissions change

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 578 matching lines @@
                                       const std::string& v8_extension_name,
                                       int extension_group,
                                       int world_id) {
   g_hack_extension_group = extension_group;
   return true;
 }
 
 v8::Handle<v8::Object> Dispatcher::GetOrCreateObject(
     v8::Handle<v8::Object> object,
     const std::string& field) {
-  v8::HandleScope handle_scope;
   v8::Handle<v8::String> key = v8::String::New(field.c_str());
   // If the object has a callback property, it is assumed it is an unavailable
   // API, so it is safe to delete. This is checked before GetOrCreateObject is
   // called.
   if (object->HasRealNamedCallbackProperty(key)) {
     object->Delete(key);
   } else if (object->HasRealNamedProperty(key)) {
     v8::Handle<v8::Value> value = object->Get(key);
     CHECK(value->IsObject());
-    return handle_scope.Close(v8::Handle<v8::Object>::Cast(value));
+    return v8::Handle<v8::Object>::Cast(value);
   }
 
   v8::Handle<v8::Object> new_object = v8::Object::New();
   object->Set(key, new_object);
-  return handle_scope.Close(new_object);
+  return new_object;
 }
 
-void Dispatcher::RegisterSchemaGeneratedBindings(
-    ModuleSystem* module_system,
-    ChromeV8Context* context) {
+void Dispatcher::AddOrRemoveBindings(ChromeV8Context* context) {
+  v8::HandleScope handle_scope;
+  v8::Context::Scope context_scope(context->v8_context());
+
   std::set<std::string> apis =
       ExtensionAPI::GetSharedInstance()->GetAllAPINames();
   for (std::set<std::string>::iterator it = apis.begin();
        it != apis.end(); ++it) {
     const std::string& api_name = *it;
-    if (!context->IsAnyFeatureAvailableToContext(api_name))
+    if (!context->IsAnyFeatureAvailableToContext(api_name)) {
+      DeregisterBinding(api_name, context);
       continue;
+    }
 
     Feature* feature =
         BaseFeatureProvider::GetByName("api")->GetFeature(api_name);
     if (feature && feature->IsInternal())
       continue;
 
-    std::vector<std::string> split;
-    base::SplitString(api_name, '.', &split);
-
-    v8::Handle<v8::Object> bind_object =
-        GetOrCreateChrome(context->v8_context());
-
-    // Check if this API has an ancestor. If the API's ancestor is available and
-    // the API is not available, don't install the bindings for this API. If
-    // the API is available and its ancestor is not, delete the ancestor and
-    // install the bindings for the API. This is to prevent loading the ancestor
-    // API schema if it will not be needed.
-    //
-    // For example:
-    //  If app is available and app.window is not, just install app.
-    //  If app.window is available and app is not, delete app and install
-    //  app.window on a new object so app does not have to be loaded.
-    std::string ancestor_name;
-    bool only_ancestor_available = false;
-    for (size_t i = 0; i < split.size() - 1; ++i) {
-      ancestor_name += (i ? ".": "") + split[i];
-      if (!ancestor_name.empty() &&
-          context->GetAvailability(ancestor_name).is_available() &&
-          !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);
-    } 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");
-    }
+    RegisterBinding(api_name, context);
   }
 }
 
+void Dispatcher::DeregisterBinding(const std::string& api_name,
+                                   ChromeV8Context* context) {
+  std::string bind_name;
+  v8::Handle<v8::Object> bind_object =
+      GetOrCreateBindObjectIfAvailable(api_name, &bind_name, context);
+  v8::Handle<v8::String> v8_bind_name = v8::String::New(bind_name.c_str());
+  if (!bind_object.IsEmpty() && bind_object->HasRealNamedProperty(v8_bind_name))
+    bind_object->Delete(v8_bind_name);
+}
+
+v8::Handle<v8::Object> Dispatcher::GetOrCreateBindObjectIfAvailable(
+    const std::string& api_name,
+    std::string* bind_name,
+    ChromeV8Context* context) {
+  std::vector<std::string> split;
+  base::SplitString(api_name, '.', &split);
+
+  v8::Handle<v8::Object> bind_object;
+
+  // Check if this API has an ancestor. If the API's ancestor is available and
+  // the API is not available, don't install the bindings for this API. If
+  // the API is available and its ancestor is not, delete the ancestor and
+  // install the bindings for the API. This is to prevent loading the ancestor
+  // API schema if it will not be needed.
+  //
+  // For example:
+  //  If app is available and app.window is not, just install app.
+  //  If app.window is available and app is not, delete app and install
+  //  app.window on a new object so app does not have to be loaded.
+  std::string ancestor_name;
+  bool only_ancestor_available = false;
+  for (size_t i = 0; i < split.size() - 1; ++i) {
+    ancestor_name += (i ? ".": "") + split[i];
+    if (!ancestor_name.empty() &&
+        context->GetAvailability(ancestor_name).is_available() &&
+        !context->GetAvailability(api_name).is_available()) {
+      only_ancestor_available = true;
+      break;
+    }
+    if (bind_object.IsEmpty())
+      bind_object = GetOrCreateChrome(context->v8_context());
+    bind_object = GetOrCreateObject(bind_object, split[i]);
+  }
+  if (only_ancestor_available)
+    return v8::Handle<v8::Object>();
+  if (bind_name)
+    *bind_name = split.back();
+
+  return bind_object.IsEmpty() ?
+      GetOrCreateChrome(context->v8_context()) : bind_object;
+}
+
+void Dispatcher::RegisterBinding(const std::string& api_name,
+                                 ChromeV8Context* context) {
+  std::string bind_name;
+  v8::Handle<v8::Object> bind_object =
+      GetOrCreateBindObjectIfAvailable(api_name, &bind_name, context);
+  if (bind_object.IsEmpty())
+    return;
+
+  ModuleSystem* module_system = context->module_system();
+  if (lazy_bindings_map_.find(api_name) != lazy_bindings_map_.end()) {
+    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,
+                                      bind_name,
+                                      api_name,
+                                      "binding");
+  } else {
+    module_system->SetLazyField(bind_object,
+                                bind_name,
+                                api_name,
+                                "binding");
+  }
+}
+
 // NOTE: please use the naming convention "foo_natives" for these.
 void Dispatcher::RegisterNativeHandlers(ModuleSystem* module_system,
                                         ChromeV8Context* context) {
   module_system->RegisterNativeHandler("event_natives",
       scoped_ptr<NativeHandler>(EventBindings::Create(this, context)));
   module_system->RegisterNativeHandler("miscellaneous_bindings_natives",
       scoped_ptr<NativeHandler>(MiscellaneousBindings::Get(this, context)));
   module_system->RegisterNativeHandler("apiDefinitions",
       scoped_ptr<NativeHandler>(new ApiDefinitionsNatives(this, context)));
   module_system->RegisterNativeHandler("sendRequest",
@@ skipping 173 matching lines @@
         global->Get(v8::String::New("chrome"))->ToObject();
     (*lazy_binding->second)(module_system, chrome);
   } else {
     module_system->Require(api);
   }
 }
 
 void Dispatcher::DidCreateScriptContext(
     WebFrame* frame, v8::Handle<v8::Context> v8_context, int extension_group,
     int world_id) {
-// Extensions are not supported on Android, so don't register any bindings.
-#if defined(OS_ANDROID)
+#if !defined(ENABLE_EXTENSIONS)
   return;
 #endif
 
   // 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 13 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(context,
-                                                          &source_map_));
+  {
+    scoped_ptr<ModuleSystem> module_system(new ModuleSystem(context,
+                                                            &source_map_));
+    context->set_module_system(module_system.Pass());
+  }
+  ModuleSystem* module_system = context->module_system();
+
   // Enable natives in startup.
-  ModuleSystem::NativesEnabledScope natives_enabled_scope(module_system.get());
+  ModuleSystem::NativesEnabledScope natives_enabled_scope(
+      module_system);
 
-  RegisterNativeHandlers(module_system.get(), context);
+  RegisterNativeHandlers(module_system, context);
 
   module_system->RegisterNativeHandler("chrome",
       scoped_ptr<NativeHandler>(new ChromeNativeHandler(context)));
   module_system->RegisterNativeHandler("print",
       scoped_ptr<NativeHandler>(new PrintNativeHandler(context)));
   module_system->RegisterNativeHandler("lazy_background_page",
       scoped_ptr<NativeHandler>(
           new LazyBackgroundPageNativeHandler(this, context)));
   module_system->RegisterNativeHandler("logging",
       scoped_ptr<NativeHandler>(new LoggingNativeHandler(context)));
@@ skipping 20 matching lines @@
   // chrome.Event is part of the public API (although undocumented). Make it
   // lazily evalulate to Event from event_bindings.js.
   module_system->SetLazyField(chrome, "Event", kEventModule, "Event");
 
   // 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.
-      InstallBindings(module_system.get(), v8_context, "app");
-      InstallBindings(module_system.get(), v8_context, "webstore");
+      InstallBindings(module_system, v8_context, "app");
+      InstallBindings(module_system, v8_context, "webstore");
       break;
     case Feature::BLESSED_EXTENSION_CONTEXT:
     case Feature::UNBLESSED_EXTENSION_CONTEXT:
     case Feature::CONTENT_SCRIPT_CONTEXT:
       module_system->Require("json");  // see paranoid comment in json.js
 
       // 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.
-      RegisterSchemaGeneratedBindings(module_system.get(), context);
+      AddOrRemoveBindings(context);
       break;
   }
 
   bool is_within_platform_app = IsWithinPlatformApp(frame);
   // Inject custom JS into the platform app context.
   if (is_within_platform_app)
     module_system->Require("platformApp");
 
   // Only platform apps support the <webview> tag, because the "webView" and
   // "denyWebView" modules will affect the performance of DOM modifications
@@ skipping 20 matching lines @@
                 switches::kEnableAdviewSrcAttribute)) {
           module_system->Require("adViewCustom");
         }
         module_system->Require("adView");
       } else {
         module_system->Require("denyAdView");
       }
     }
   }
 
-  context->set_module_system(module_system.Pass());
-
   VLOG(1) << "Num tracked contexts: " << v8_context_set_.size();
 }
 
 std::string Dispatcher::GetExtensionID(const WebFrame* frame, int world_id) {
   if (world_id != 0) {
     // Isolated worlds (content script).
     return user_script_slave_->GetExtensionIdForIsolatedWorld(world_id);
   }
 
   // Extension pages (chrome-extension:// URLs).
@@ skipping 142 matching lines @@
       new_active = PermissionSet::CreateUnion(old_active.get(), delta.get());
       break;
     case UpdatedExtensionPermissionsInfo::REMOVED:
       new_active =
           PermissionSet::CreateDifference(old_active.get(), delta.get());
       break;
   }
 
   PermissionsData::SetActivePermissions(extension, new_active);
   AddOrRemoveOriginPermissions(reason, extension, explicit_hosts);
+  v8_context_set().ForEach(
+      extension_id,
+      NULL,
+      base::Bind(&Dispatcher::AddOrRemoveBindings, base::Unretained(this)));
 }
 
 void Dispatcher::OnUpdateTabSpecificPermissions(
     int page_id,
     int tab_id,
     const std::string& extension_id,
     const URLPatternSet& origin_set) {
   RenderView* view = TabFinder::Find(tab_id);
 
   // For now, the message should only be sent to the render view that contains
@@ skipping 207 matching lines @@
     RenderView* background_view =
         ExtensionHelper::GetBackgroundPage(extension_id);
     if (background_view) {
       background_view->Send(new ExtensionHostMsg_EventAck(
           background_view->GetRoutingID()));
     }
   }
 }
 
 }  // namespace extensions