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 704 matching lines @@
   }
 
   v8::Handle<v8::Object> new_object = v8::Object::New();
   object->Set(key, new_object);
   return handle_scope.Close(new_object);
 }
 
 void Dispatcher::RegisterSchemaGeneratedBindings(
     ModuleSystem* module_system,
     ChromeV8Context* 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->HasParent() || feature->IsInternal())
+      continue;
+
     if (!context->IsAnyFeatureAvailableToContext(api_name))
       continue;

[not at google - send to devlin, 2013/05/30 16:38:52]

without the parent this is going to get trickier. oh well. not *that* much
trickier. can do the old startswith trick, and so long as the features are
sorted ahead of time this will be ok. maybe we should DCHECK that here as well,
incidentally:

DCHECK(STLIsSorted(feature_names));

(see
https://code.google.com/p/chromium/codesearch#chromium/src/base/stl_util.h&q=...).

then algorithm can still be both linear and not involve any copying.

[cduvall, 2013/06/12 01:22:19]

I ended up keeping the HasParent(), and just using a SetHasParent() function if
a parent is parsed. I think this simplifies the code in multiple places.

 
-    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() &&
+      if (ancestor_name == "app" &&
           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;
 
@@ skipping 650 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();
 }
 
 }  // namespace extensions