Lazily load API schemas from resource files and convert all APIs to features

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 606 matching lines @@
 
   v8::Handle<v8::Object> new_object = v8::Object::New();
   object->Set(key, new_object);
   return new_object;
 }
 
 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();
+  FeatureProvider* feature_provider = BaseFeatureProvider::GetByName("api");
+  const std::vector<std::string>& apis = feature_provider->GetAllFeatureNames();
+  for (std::vector<std::string>::const_iterator it = apis.begin();
        it != apis.end(); ++it) {
     const std::string& api_name = *it;
+    Feature* feature = feature_provider->GetFeature(api_name);
+    DCHECK(feature);
+    if (feature->IsInternal())
+      continue;
+
+    // If this API name has parent features, then this must be a function or
+    // event, so we should not register.
+    Feature* parent_feature = feature;
+    bool parent_feature_available = false;
+    while ((parent_feature = feature_provider->GetParent(parent_feature))) {

[not at google - send to devlin, 2013/06/13 22:23:25]

maybe this should be a for loop i.e. for (Feature* parent_feature = feature;
...)

[cduvall, 2013/06/13 22:43:08]

Done.

+      if (context->IsAnyFeatureAvailableToContext(parent_feature->name())) {
+        parent_feature_available = true;
+        break;
+      }
+    }
+    if (parent_feature_available)
+      continue;
+
     if (!context->IsAnyFeatureAvailableToContext(api_name)) {
       DeregisterBinding(api_name, context);
       continue;
     }
 
-    Feature* feature =
-        BaseFeatureProvider::GetByName("api")->GetFeature(api_name);
-    if (feature && feature->IsInternal())
-      continue;
-
     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());
@@ skipping 13 matching lines @@
   // 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.
+  FeatureProvider* feature_provider = BaseFeatureProvider::GetByName("api");
   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() &&
+    if (feature_provider->GetFeature(ancestor_name) &&
         context->GetAvailability(ancestor_name).is_available() &&
         !context->GetAvailability(api_name).is_available()) {
       only_ancestor_available = true;
       break;
     }
 
     if (bind_object.IsEmpty()) {
       bind_object = AsObjectOrEmpty(GetOrCreateChrome(context));
       if (bind_object.IsEmpty())
         return v8::Handle<v8::Object>();
@@ skipping 665 matching lines @@
     DLOG(ERROR) << "Not in a v8::Context";
     return false;
   }
 
   if (!context->extension()) {
     v8::ThrowException(
         v8::Exception::Error(v8::String::New("Not in an extension.")));
     return false;
   }
 
-  if (!context->extension()->HasAPIPermission(function_name)) {
-    static const char kMessage[] =
-        "You do not have permission to use '%s'. Be sure to declare"
-        " in your manifest what permissions you need.";
-    std::string error_msg = base::StringPrintf(kMessage, function_name.c_str());
-    APIActivityLogger::LogBlockedCall(context->extension()->id(),
-                                      function_name);
-    v8::ThrowException(
-        v8::Exception::Error(v8::String::New(error_msg.c_str())));
-    return false;
-  }
-
-  if (ExtensionAPI::GetSharedInstance()->IsPrivileged(function_name) &&
-      context->context_type() != Feature::BLESSED_EXTENSION_CONTEXT) {
-    static const char kMessage[] =
-        "%s can only be used in an extension process.";
-    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;
-  }
-
   // Theoretically we could end up with bindings being injected into sandboxed
   // frames, for example content scripts. Don't let them execute API functions.
   WebKit::WebFrame* frame = context->web_frame();
   ExtensionURLInfo url_info(frame->document().securityOrigin(),
                             UserScriptSlave::GetDataSourceURLForFrame(frame));
   if (extensions_.IsSandboxedPage(url_info)) {
     static const char kMessage[] =
         "%s cannot be used within a sandboxed frame.";
     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;
+  Feature::Availability availability = context->GetAvailability(function_name);
+  if (!availability.is_available()) {
+    v8::ThrowException(v8::Exception::Error(
+        v8::String::New(availability.message().c_str())));
+  }
+
+  return availability.is_available();
 }
 
 void Dispatcher::DispatchEvent(const std::string& extension_id,
                                const std::string& event_name) const {
   base::ListValue args;
   args.Set(0, new base::StringValue(event_name));
   args.Set(1, new base::ListValue());
   v8_context_set_.ForEach(
       extension_id,
       NULL,  // all render views
@@ skipping 35 matching lines @@
     RenderView* background_view =
         ExtensionHelper::GetBackgroundPage(extension_id);
     if (background_view) {
       background_view->Send(new ExtensionHostMsg_EventAck(
           background_view->GetRoutingID()));
     }
   }
 }
 
 }  // namespace extensions