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 =

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

also const&

[cduvall, 2013/05/30 00:50:51]

Done.

+      BaseFeatureProvider::GetByName("api")->GetAllFeatureNames();
+  for (std::vector<std::string>::iterator it = apis.begin();
        it != apis.end(); ++it) {
     const std::string& api_name = *it;
+
+    Feature* feature =
+        BaseFeatureProvider::GetByName("api")->GetFeature(api_name);

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

maybe save a reference to this.

[cduvall, 2013/05/30 00:50:51]

Done.

+    if (feature && (feature->HasParent() || feature->IsInternal()))

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

there should always be a feature here since we're getting them via
GetAllFeatureNames. DCHECK perhaps.

[cduvall, 2013/05/30 00:50:51]

Done.

+      continue;
+
     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" &&
           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())));

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

nice

[cduvall, 2013/05/30 00:50:51]

So a side effect of this is that API methods with optional permissions that
currently don't have those permissions no longer throw exceptions. Instead
runtime.lastError is set.

This is because in PermissionFeature::IsAvailableToContext(), we use
PermissionsData::GetOptionalPermissions()->HasAnyAccessToAPI() to make sure an
API is defined if permissions are granted later.

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

Cool. That's fine, the right thing to do for now - a follow up (probably the
thing to do next) is to reset the API binding on the chrome object when
permissions change. Something to add to the module system.

So if an optional permission is added or removed, reset its binding on chrome,
then next time it's accessed it'll do the right thing.

I need this functionality too, separately, for behaviour where when extensions
are installed or uninstalled we do the same thing for the
runtime.connect/sendMessage bindings (I can explain over IRC why).

+  }
+
+  return availability.is_available();
 }
 
 }  // namespace extensions