extensions/common/extension_api.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "extensions/common/extension_api.h"
   6
   7 #include <algorithm>
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/json/json_reader.h"
  12 #include "base/json/json_writer.h"
  13 #include "base/lazy_instance.h"
  14 #include "base/logging.h"
  15 #include "base/strings/string_number_conversions.h"
  16 #include "base/strings/string_split.h"
  17 #include "base/strings/string_util.h"
  18 #include "base/values.h"
  19 #include "chrome/common/extensions/api/generated_schemas.h"
  20 #include "extensions/common/extension.h"
  21 #include "extensions/common/features/feature.h"
  22 #include "extensions/common/features/feature_provider.h"
  23 #include "extensions/common/permissions/permission_set.h"
  24 #include "extensions/common/permissions/permissions_data.h"
  25 #include "grit/common_resources.h"
  26 #include "grit/extensions_api_resources.h"
  27 #include "ui/base/resource/resource_bundle.h"
  28 #include "url/gurl.h"
  29
  30 namespace extensions {
  31
  32 using api::GeneratedSchemas;
  33
  34 namespace {
  35
  36 const char* kChildKinds[] = {
  37   "functions",
  38   "events"
  39 };
  40
  41 base::StringPiece ReadFromResource(int resource_id) {
  42   return ResourceBundle::GetSharedInstance().GetRawDataResource(
  43       resource_id);
  44 }
  45
  46 scoped_ptr<base::ListValue> LoadSchemaList(const std::string& name,
  47                                            const base::StringPiece& schema) {
  48   std::string error_message;
  49   scoped_ptr<base::Value> result(
  50       base::JSONReader::ReadAndReturnError(
  51           schema,
  52           base::JSON_PARSE_RFC | base::JSON_DETACHABLE_CHILDREN,  // options
  53           NULL,  // error code
  54           &error_message));
  55
  56   // Tracking down http://crbug.com/121424
  57   char buf[128];
  58   base::snprintf(buf, arraysize(buf), "%s: (%d) '%s'",
  59       name.c_str(),
  60       result.get() ? result->GetType() : -1,
  61       error_message.c_str());
  62
  63   CHECK(result.get()) << error_message << " for schema " << schema;
  64   CHECK(result->IsType(base::Value::TYPE_LIST)) << " for schema " << schema;
  65   return scoped_ptr<base::ListValue>(static_cast<base::ListValue*>(
  66       result.release()));
  67 }
  68
  69 const base::DictionaryValue* FindListItem(const base::ListValue* list,
  70                                           const std::string& property_name,
  71                                           const std::string& property_value) {
  72   for (size_t i = 0; i < list->GetSize(); ++i) {
  73     const base::DictionaryValue* item = NULL;
  74     CHECK(list->GetDictionary(i, &item))
  75         << property_value << "/" << property_name;
  76     std::string value;
  77     if (item->GetString(property_name, &value) && value == property_value)
  78       return item;
  79   }
  80
  81   return NULL;
  82 }
  83
  84 const base::DictionaryValue* GetSchemaChild(
  85     const base::DictionaryValue* schema_node,
  86     const std::string& child_name) {
  87   const base::DictionaryValue* child_node = NULL;
  88   for (size_t i = 0; i < arraysize(kChildKinds); ++i) {
  89     const base::ListValue* list_node = NULL;
  90     if (!schema_node->GetList(kChildKinds[i], &list_node))
  91       continue;
  92     child_node = FindListItem(list_node, "name", child_name);
  93     if (child_node)
  94       return child_node;
  95   }
  96
  97   return NULL;
  98 }
  99
 100 struct Static {
 101   Static()
 102       : api(ExtensionAPI::CreateWithDefaultConfiguration()) {
 103   }
 104   scoped_ptr<ExtensionAPI> api;
 105 };
 106
 107 base::LazyInstance<Static> g_lazy_instance = LAZY_INSTANCE_INITIALIZER;
 108
 109 // If it exists and does not already specify a namespace, then the value stored
 110 // with key |key| in |schema| will be updated to |schema_namespace| + "." +
 111 // |schema[key]|.
 112 void MaybePrefixFieldWithNamespace(const std::string& schema_namespace,
 113                                    base::DictionaryValue* schema,
 114                                    const std::string& key) {
 115   if (!schema->HasKey(key))
 116     return;
 117
 118   std::string old_id;
 119   CHECK(schema->GetString(key, &old_id));
 120   if (old_id.find(".") == std::string::npos)
 121     schema->SetString(key, schema_namespace + "." + old_id);
 122 }
 123
 124 // Modify all "$ref" keys anywhere in |schema| to be prefxied by
 125 // |schema_namespace| if they do not already specify a namespace.
 126 void PrefixRefsWithNamespace(const std::string& schema_namespace,
 127                              base::Value* value) {
 128   base::ListValue* list = NULL;
 129   base::DictionaryValue* dict = NULL;
 130   if (value->GetAsList(&list)) {
 131     for (base::ListValue::iterator i = list->begin(); i != list->end(); ++i) {
 132       PrefixRefsWithNamespace(schema_namespace, *i);
 133     }
 134   } else if (value->GetAsDictionary(&dict)) {
 135     MaybePrefixFieldWithNamespace(schema_namespace, dict, "$ref");
 136     for (base::DictionaryValue::Iterator i(*dict); !i.IsAtEnd(); i.Advance()) {
 137       base::Value* value = NULL;
 138       CHECK(dict->GetWithoutPathExpansion(i.key(), &value));
 139       PrefixRefsWithNamespace(schema_namespace, value);
 140     }
 141   }
 142 }
 143
 144 // Modify all objects in the "types" section of the schema to be prefixed by
 145 // |schema_namespace| if they do not already specify a namespace.
 146 void PrefixTypesWithNamespace(const std::string& schema_namespace,
 147                               base::DictionaryValue* schema) {
 148   if (!schema->HasKey("types"))
 149     return;
 150
 151   // Add the namespace to all of the types defined in this schema
 152   base::ListValue *types = NULL;
 153   CHECK(schema->GetList("types", &types));
 154   for (size_t i = 0; i < types->GetSize(); ++i) {
 155     base::DictionaryValue *type = NULL;
 156     CHECK(types->GetDictionary(i, &type));
 157     MaybePrefixFieldWithNamespace(schema_namespace, type, "id");
 158     MaybePrefixFieldWithNamespace(schema_namespace, type, "customBindings");
 159   }
 160 }
 161
 162 // Modify the schema so that all types are fully qualified.
 163 void PrefixWithNamespace(const std::string& schema_namespace,
 164                          base::DictionaryValue* schema) {
 165   PrefixTypesWithNamespace(schema_namespace, schema);
 166   PrefixRefsWithNamespace(schema_namespace, schema);
 167 }
 168
 169 }  // namespace
 170
 171 // static
 172 ExtensionAPI* ExtensionAPI::GetSharedInstance() {
 173   return g_lazy_instance.Get().api.get();
 174 }
 175
 176 // static
 177 ExtensionAPI* ExtensionAPI::CreateWithDefaultConfiguration() {
 178   ExtensionAPI* api = new ExtensionAPI();
 179   api->InitDefaultConfiguration();
 180   return api;
 181 }
 182
 183 // static
 184 void ExtensionAPI::SplitDependencyName(const std::string& full_name,
 185                                        std::string* feature_type,
 186                                        std::string* feature_name) {
 187   size_t colon_index = full_name.find(':');
 188   if (colon_index == std::string::npos) {
 189     // TODO(aa): Remove this code when all API descriptions have been updated.
 190     *feature_type = "api";
 191     *feature_name = full_name;
 192     return;
 193   }
 194
 195   *feature_type = full_name.substr(0, colon_index);
 196   *feature_name = full_name.substr(colon_index + 1);
 197 }
 198
 199 void ExtensionAPI::LoadSchema(const std::string& name,
 200                               const base::StringPiece& schema) {
 201   scoped_ptr<base::ListValue> schema_list(LoadSchemaList(name, schema));
 202   std::string schema_namespace;
 203
 204   while (!schema_list->empty()) {
 205     base::DictionaryValue* schema = NULL;
 206     {
 207       scoped_ptr<base::Value> value;
 208       schema_list->Remove(schema_list->GetSize() - 1, &value);
 209       CHECK(value.release()->GetAsDictionary(&schema));
 210     }
 211
 212     CHECK(schema->GetString("namespace", &schema_namespace));
 213     PrefixWithNamespace(schema_namespace, schema);
 214     schemas_[schema_namespace] = make_linked_ptr(schema);
 215     if (!GeneratedSchemas::IsGenerated(schema_namespace))
 216       CHECK_EQ(1u, unloaded_schemas_.erase(schema_namespace));
 217   }
 218 }
 219
 220 ExtensionAPI::ExtensionAPI() : default_configuration_initialized_(false) {
 221 }
 222
 223 ExtensionAPI::~ExtensionAPI() {
 224 }
 225
 226 void ExtensionAPI::InitDefaultConfiguration() {
 227   const char* names[] = {"api", "manifest", "permission"};
 228   for (size_t i = 0; i < arraysize(names); ++i)
 229     RegisterDependencyProvider(names[i], FeatureProvider::GetByName(names[i]));
 230
 231   // Schemas to be loaded from resources.
 232   CHECK(unloaded_schemas_.empty());
 233   RegisterSchemaResource("app", IDR_EXTENSION_API_JSON_APP);
 234   RegisterSchemaResource("browserAction", IDR_EXTENSION_API_JSON_BROWSERACTION);
 235   RegisterSchemaResource("browsingData", IDR_EXTENSION_API_JSON_BROWSINGDATA);
 236   RegisterSchemaResource("commands", IDR_EXTENSION_API_JSON_COMMANDS);
 237   RegisterSchemaResource("declarativeContent",
 238       IDR_EXTENSION_API_JSON_DECLARATIVE_CONTENT);
 239   RegisterSchemaResource("declarativeWebRequest",
 240       IDR_EXTENSION_API_JSON_DECLARATIVE_WEBREQUEST);
 241   RegisterSchemaResource("runtime", IDR_EXTENSION_API_JSON_RUNTIME);
 242   RegisterSchemaResource("fileBrowserHandler",
 243       IDR_EXTENSION_API_JSON_FILEBROWSERHANDLER);
 244   RegisterSchemaResource("fileBrowserPrivate",
 245       IDR_EXTENSION_API_JSON_FILEBROWSERPRIVATE);
 246   RegisterSchemaResource("inputMethodPrivate",
 247       IDR_EXTENSION_API_JSON_INPUTMETHODPRIVATE);
 248   RegisterSchemaResource("pageAction", IDR_EXTENSION_API_JSON_PAGEACTION);
 249   RegisterSchemaResource("pageActions", IDR_EXTENSION_API_JSON_PAGEACTIONS);
 250   RegisterSchemaResource("privacy", IDR_EXTENSION_API_JSON_PRIVACY);
 251   RegisterSchemaResource("processes", IDR_EXTENSION_API_JSON_PROCESSES);
 252   RegisterSchemaResource("proxy", IDR_EXTENSION_API_JSON_PROXY);
 253   RegisterSchemaResource("scriptBadge", IDR_EXTENSION_API_JSON_SCRIPTBADGE);
 254   RegisterSchemaResource("streamsPrivate",
 255       IDR_EXTENSION_API_JSON_STREAMSPRIVATE);
 256   RegisterSchemaResource("ttsEngine", IDR_EXTENSION_API_JSON_TTSENGINE);
 257   RegisterSchemaResource("tts", IDR_EXTENSION_API_JSON_TTS);
 258   RegisterSchemaResource("types", IDR_EXTENSION_API_JSON_TYPES);
 259   RegisterSchemaResource("types.private", IDR_EXTENSION_API_JSON_TYPES_PRIVATE);
 260   RegisterSchemaResource("webRequestInternal",
 261       IDR_EXTENSION_API_JSON_WEBREQUESTINTERNAL);
 262   RegisterSchemaResource("webstore", IDR_EXTENSION_API_JSON_WEBSTORE);
 263   RegisterSchemaResource("webstorePrivate",
 264       IDR_EXTENSION_API_JSON_WEBSTOREPRIVATE);
 265   RegisterSchemaResource("webViewRequest",
 266       IDR_EXTENSION_API_JSON_WEBVIEW_REQUEST);
 267
 268   default_configuration_initialized_ = true;
 269 }
 270
 271 void ExtensionAPI::RegisterSchemaResource(const std::string& name,
 272                                           int resource_id) {
 273   unloaded_schemas_[name] = resource_id;
 274 }
 275
 276 void ExtensionAPI::RegisterDependencyProvider(const std::string& name,
 277                                               FeatureProvider* provider) {
 278   dependency_providers_[name] = provider;
 279 }
 280
 281 bool ExtensionAPI::IsAnyFeatureAvailableToContext(const std::string& api_name,
 282                                                   const Extension* extension,
 283                                                   Feature::Context context,
 284                                                   const GURL& url) {
 285   FeatureProviderMap::iterator provider = dependency_providers_.find("api");
 286   CHECK(provider != dependency_providers_.end());
 287   const std::vector<std::string>& features =
 288       provider->second->GetAllFeatureNames();
 289
 290   // Check to see if there are any parts of this API that are allowed in this
 291   // context.
 292   for (std::vector<std::string>::const_iterator i = features.begin();
 293        i != features.end(); ++i) {
 294     const std::string& feature_name = *i;
 295     if (feature_name != api_name && feature_name.find(api_name + ".") == 0) {
 296       if (IsAvailable(feature_name, extension, context, url).is_available())
 297         return true;
 298     }
 299   }
 300   return IsAvailable(api_name, extension, context, url).is_available();
 301 }
 302
 303 Feature::Availability ExtensionAPI::IsAvailable(const std::string& full_name,
 304                                                 const Extension* extension,
 305                                                 Feature::Context context,
 306                                                 const GURL& url) {
 307   Feature* feature = GetFeatureDependency(full_name);
 308   CHECK(feature) << full_name;
 309
 310   Feature::Availability availability =
 311       feature->IsAvailableToContext(extension, context, url);
 312   if (!availability.is_available())
 313     return availability;
 314
 315   for (std::set<std::string>::iterator iter = feature->dependencies().begin();
 316        iter != feature->dependencies().end(); ++iter) {
 317     Feature::Availability dependency_availability =
 318         IsAvailable(*iter, extension, context, url);
 319     if (!dependency_availability.is_available())
 320       return dependency_availability;
 321   }
 322
 323   return Feature::CreateAvailability(Feature::IS_AVAILABLE, std::string());
 324 }
 325
 326 bool ExtensionAPI::IsPrivileged(const std::string& full_name) {
 327   Feature* feature = GetFeatureDependency(full_name);
 328   CHECK(feature);
 329   DCHECK(!feature->GetContexts()->empty());
 330   // An API is 'privileged' if it can only be run in a blessed context.
 331   return feature->GetContexts()->size() ==
 332       feature->GetContexts()->count(Feature::BLESSED_EXTENSION_CONTEXT);
 333 }
 334
 335 const base::DictionaryValue* ExtensionAPI::GetSchema(
 336     const std::string& full_name) {
 337   std::string child_name;
 338   std::string api_name = GetAPINameFromFullName(full_name, &child_name);
 339
 340   const base::DictionaryValue* result = NULL;
 341   SchemaMap::iterator maybe_schema = schemas_.find(api_name);
 342   if (maybe_schema != schemas_.end()) {
 343     result = maybe_schema->second.get();
 344   } else {
 345     // Might not have loaded yet; or might just not exist.
 346    UnloadedSchemaMap::iterator maybe_schema_resource =
 347         unloaded_schemas_.find(api_name);
 348     if (maybe_schema_resource != unloaded_schemas_.end()) {
 349       LoadSchema(maybe_schema_resource->first,
 350                  ReadFromResource(maybe_schema_resource->second));
 351     } else if (default_configuration_initialized_ &&
 352                GeneratedSchemas::IsGenerated(api_name)) {
 353       LoadSchema(api_name, GeneratedSchemas::Get(api_name));
 354     } else {
 355       return NULL;
 356     }
 357
 358     maybe_schema = schemas_.find(api_name);
 359     CHECK(schemas_.end() != maybe_schema);
 360     result = maybe_schema->second.get();
 361   }
 362
 363   if (!child_name.empty())
 364     result = GetSchemaChild(result, child_name);
 365
 366   return result;
 367 }
 368
 369 Feature* ExtensionAPI::GetFeatureDependency(const std::string& full_name) {
 370   std::string feature_type;
 371   std::string feature_name;
 372   SplitDependencyName(full_name, &feature_type, &feature_name);
 373
 374   FeatureProviderMap::iterator provider =
 375       dependency_providers_.find(feature_type);
 376   if (provider == dependency_providers_.end())
 377     return NULL;
 378
 379   Feature* feature = provider->second->GetFeature(feature_name);
 380   // Try getting the feature for the parent API, if this was a child.
 381   if (!feature) {
 382     std::string child_name;
 383     feature = provider->second->GetFeature(
 384         GetAPINameFromFullName(feature_name, &child_name));
 385   }
 386   return feature;
 387 }
 388
 389 std::string ExtensionAPI::GetAPINameFromFullName(const std::string& full_name,
 390                                                  std::string* child_name) {
 391   std::string api_name_candidate = full_name;
 392   while (true) {
 393     if (schemas_.find(api_name_candidate) != schemas_.end() ||
 394         GeneratedSchemas::IsGenerated(api_name_candidate) ||
 395         unloaded_schemas_.find(api_name_candidate) != unloaded_schemas_.end()) {
 396       std::string result = api_name_candidate;
 397
 398       if (child_name) {
 399         if (result.length() < full_name.length())
 400           *child_name = full_name.substr(result.length() + 1);
 401         else
 402           *child_name = "";
 403       }
 404
 405       return result;
 406     }
 407
 408     size_t last_dot_index = api_name_candidate.rfind('.');
 409     if (last_dot_index == std::string::npos)
 410       break;
 411
 412     api_name_candidate = api_name_candidate.substr(0, last_dot_index);
 413   }
 414
 415   *child_name = "";
 416   return std::string();
 417 }
 418
 419 }  // namespace extensions