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 700 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();
+  std::vector<std::string> apis =
+      BaseFeatureProvider::GetByName("api")->GetAllTopLevelFeatureNames();
+  for (std::vector<std::string>::iterator it = apis.begin();
        it != apis.end(); ++it) {
     const std::string& api_name = *it;
+
     if (!context->IsAnyFeatureAvailableToContext(api_name))
       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() &&
+      if (ancestor_name == "app" && // !ancestor_name.empty() &&

[not at google - send to devlin, 2013/05/23 00:09:40]

commented out?

[not at google - send to devlin, 2013/05/23 00:09:40]

commented out?

[cduvall, 2013/05/24 03:13:49]

I changed this to just checking when the ancestor is "app", because the
experimental.* APIs would CHECK here because there is no experimental feature.
Should I just automatically return false for is_available if the name is not a
feature?

[not at google - send to devlin, 2013/05/24 19:09:18]

what check? yeah it seems like if there's no feature then we shouldn't be making
this check, so the check should include "HasFeature(ancestor_name)" or something
like that?

should avoid referring explicitly to 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 662 matching lines @@
         "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) {
+  Feature* feature =
+      BaseFeatureProvider::GetByName("api")->GetFeature(function_name);
+  if (feature->GetContexts()->count(context->context_type()) == 0) {
     static const char kMessage[] =
         "%s can only be used in an extension process.";

[not at google - send to devlin, 2013/05/23 00:09:40]

this error message will need to change

[cduvall, 2013/05/24 03:13:49]

Switched this to just using the features and getting the error message from
there.

     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;
 }
 
 }  // namespace extensions