Home | History | Annotate | Download | only in common 
      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 "extensions/common/extension.h"
     20 #include "extensions/common/extensions_client.h"
     21 #include "extensions/common/features/feature.h"
     22 #include "extensions/common/features/feature_provider.h"
     23 #include "extensions/common/features/simple_feature.h"
     24 #include "extensions/common/permissions/permission_set.h"
     25 #include "extensions/common/permissions/permissions_data.h"
     26 #include "ui/base/resource/resource_bundle.h"
     27 #include "url/gurl.h"
     28 
     29 namespace extensions {
     30 
     31 namespace {
     32 
     33 const char* kChildKinds[] = {
     34   "functions",
     35   "events"
     36 };
     37 
     38 base::StringPiece ReadFromResource(int resource_id) {
     39   return ResourceBundle::GetSharedInstance().GetRawDataResource(
     40       resource_id);
     41 }
     42 
     43 scoped_ptr<base::ListValue> LoadSchemaList(const std::string& name,
     44                                            const base::StringPiece& schema) {
     45   std::string error_message;
     46   scoped_ptr<base::Value> result(
     47       base::JSONReader::ReadAndReturnError(
     48           schema,
     49           base::JSON_PARSE_RFC | base::JSON_DETACHABLE_CHILDREN,  // options
     50           NULL,  // error code
     51           &error_message));
     52 
     53   // Tracking down http://crbug.com/121424
     54   char buf[128];
     55   base::snprintf(buf, arraysize(buf), "%s: (%d) '%s'",
     56       name.c_str(),
     57       result.get() ? result->GetType() : -1,
     58       error_message.c_str());
     59 
     60   CHECK(result.get()) << error_message << " for schema " << schema;
     61   CHECK(result->IsType(base::Value::TYPE_LIST)) << " for schema " << schema;
     62   return scoped_ptr<base::ListValue>(static_cast<base::ListValue*>(
     63       result.release()));
     64 }
     65 
     66 const base::DictionaryValue* FindListItem(const base::ListValue* list,
     67                                           const std::string& property_name,
     68                                           const std::string& property_value) {
     69   for (size_t i = 0; i < list->GetSize(); ++i) {
     70     const base::DictionaryValue* item = NULL;
     71     CHECK(list->GetDictionary(i, &item))
     72         << property_value << "/" << property_name;
     73     std::string value;
     74     if (item->GetString(property_name, &value) && value == property_value)
     75       return item;
     76   }
     77 
     78   return NULL;
     79 }
     80 
     81 const base::DictionaryValue* GetSchemaChild(
     82     const base::DictionaryValue* schema_node,
     83     const std::string& child_name) {
     84   const base::DictionaryValue* child_node = NULL;
     85   for (size_t i = 0; i < arraysize(kChildKinds); ++i) {
     86     const base::ListValue* list_node = NULL;
     87     if (!schema_node->GetList(kChildKinds[i], &list_node))
     88       continue;
     89     child_node = FindListItem(list_node, "name", child_name);
     90     if (child_node)
     91       return child_node;
     92   }
     93 
     94   return NULL;
     95 }
     96 
     97 struct Static {
     98   Static()
     99       : api(ExtensionAPI::CreateWithDefaultConfiguration()) {
    100   }
    101   scoped_ptr<ExtensionAPI> api;
    102 };
    103 
    104 base::LazyInstance<Static> g_lazy_instance = LAZY_INSTANCE_INITIALIZER;
    105 
    106 // May override |g_lazy_instance| for a test.
    107 ExtensionAPI* g_shared_instance_for_test = NULL;
    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_shared_instance_for_test ? g_shared_instance_for_test
    174                                     : g_lazy_instance.Get().api.get();
    175 }
    176 
    177 // static
    178 ExtensionAPI* ExtensionAPI::CreateWithDefaultConfiguration() {
    179   ExtensionAPI* api = new ExtensionAPI();
    180   api->InitDefaultConfiguration();
    181   return api;
    182 }
    183 
    184 // static
    185 void ExtensionAPI::SplitDependencyName(const std::string& full_name,
    186                                        std::string* feature_type,
    187                                        std::string* feature_name) {
    188   size_t colon_index = full_name.find(':');
    189   if (colon_index == std::string::npos) {
    190     // TODO(aa): Remove this code when all API descriptions have been updated.
    191     *feature_type = "api";
    192     *feature_name = full_name;
    193     return;
    194   }
    195 
    196   *feature_type = full_name.substr(0, colon_index);
    197   *feature_name = full_name.substr(colon_index + 1);
    198 }
    199 
    200 ExtensionAPI::OverrideSharedInstanceForTest::OverrideSharedInstanceForTest(
    201     ExtensionAPI* testing_api)
    202     : original_api_(g_shared_instance_for_test) {
    203   g_shared_instance_for_test = testing_api;
    204 }
    205 
    206 ExtensionAPI::OverrideSharedInstanceForTest::~OverrideSharedInstanceForTest() {
    207   g_shared_instance_for_test = original_api_;
    208 }
    209 
    210 void ExtensionAPI::LoadSchema(const std::string& name,
    211                               const base::StringPiece& schema) {
    212   scoped_ptr<base::ListValue> schema_list(LoadSchemaList(name, schema));
    213   std::string schema_namespace;
    214   extensions::ExtensionsClient* extensions_client =
    215       extensions::ExtensionsClient::Get();
    216   DCHECK(extensions_client);
    217   while (!schema_list->empty()) {
    218     base::DictionaryValue* schema = NULL;
    219     {
    220       scoped_ptr<base::Value> value;
    221       schema_list->Remove(schema_list->GetSize() - 1, &value);
    222       CHECK(value.release()->GetAsDictionary(&schema));
    223     }
    224 
    225     CHECK(schema->GetString("namespace", &schema_namespace));
    226     PrefixWithNamespace(schema_namespace, schema);
    227     schemas_[schema_namespace] = make_linked_ptr(schema);
    228     if (!extensions_client->IsAPISchemaGenerated(schema_namespace))
    229       CHECK_EQ(1u, unloaded_schemas_.erase(schema_namespace));
    230   }
    231 }
    232 
    233 ExtensionAPI::ExtensionAPI() : default_configuration_initialized_(false) {
    234 }
    235 
    236 ExtensionAPI::~ExtensionAPI() {
    237 }
    238 
    239 void ExtensionAPI::InitDefaultConfiguration() {
    240   const char* names[] = {"api", "manifest", "permission"};
    241   for (size_t i = 0; i < arraysize(names); ++i)
    242     RegisterDependencyProvider(names[i], FeatureProvider::GetByName(names[i]));
    243 
    244   ExtensionsClient::Get()->RegisterAPISchemaResources(this);
    245 
    246   default_configuration_initialized_ = true;
    247 }
    248 
    249 void ExtensionAPI::RegisterSchemaResource(const std::string& name,
    250                                           int resource_id) {
    251   unloaded_schemas_[name] = resource_id;
    252 }
    253 
    254 void ExtensionAPI::RegisterDependencyProvider(const std::string& name,
    255                                               const FeatureProvider* provider) {
    256   dependency_providers_[name] = provider;
    257 }
    258 
    259 bool ExtensionAPI::IsAnyFeatureAvailableToContext(const Feature& api,
    260                                                   const Extension* extension,
    261                                                   Feature::Context context,
    262                                                   const GURL& url) {
    263   FeatureProviderMap::iterator provider = dependency_providers_.find("api");
    264   CHECK(provider != dependency_providers_.end());
    265 
    266   if (api.IsAvailableToContext(extension, context, url).is_available())
    267     return true;
    268 
    269   // Check to see if there are any parts of this API that are allowed in this
    270   // context.
    271   const std::vector<Feature*> features = provider->second->GetChildren(api);
    272   for (std::vector<Feature*>::const_iterator it = features.begin();
    273        it != features.end();
    274        ++it) {
    275     if ((*it)->IsAvailableToContext(extension, context, url).is_available())
    276       return true;
    277   }
    278   return false;
    279 }
    280 
    281 Feature::Availability ExtensionAPI::IsAvailable(const std::string& full_name,
    282                                                 const Extension* extension,
    283                                                 Feature::Context context,
    284                                                 const GURL& url) {
    285   Feature* feature = GetFeatureDependency(full_name);
    286   if (!feature) {
    287     return Feature::CreateAvailability(Feature::NOT_PRESENT,
    288         std::string("Unknown feature: ") + full_name);
    289   }
    290   return feature->IsAvailableToContext(extension, context, url);
    291 }
    292 
    293 bool ExtensionAPI::IsAvailableInUntrustedContext(const std::string& name,
    294                                                  const Extension* extension) {
    295   return IsAvailable(name, extension, Feature::CONTENT_SCRIPT_CONTEXT, GURL())
    296              .is_available() ||
    297          IsAvailable(
    298              name, extension, Feature::UNBLESSED_EXTENSION_CONTEXT, GURL())
    299              .is_available() ||
    300          IsAvailable(name, extension, Feature::BLESSED_WEB_PAGE_CONTEXT, GURL())
    301              .is_available() ||
    302          IsAvailable(name, extension, Feature::WEB_PAGE_CONTEXT, GURL())
    303              .is_available();
    304 }
    305 
    306 bool ExtensionAPI::IsAvailableToWebUI(const std::string& name,
    307                                       const GURL& url) {
    308   return IsAvailable(name, NULL, Feature::WEBUI_CONTEXT, url).is_available();
    309 }
    310 
    311 const base::DictionaryValue* ExtensionAPI::GetSchema(
    312     const std::string& full_name) {
    313   std::string child_name;
    314   std::string api_name = GetAPINameFromFullName(full_name, &child_name);
    315 
    316   const base::DictionaryValue* result = NULL;
    317   SchemaMap::iterator maybe_schema = schemas_.find(api_name);
    318   if (maybe_schema != schemas_.end()) {
    319     result = maybe_schema->second.get();
    320   } else {
    321     // Might not have loaded yet; or might just not exist.
    322     UnloadedSchemaMap::iterator maybe_schema_resource =
    323         unloaded_schemas_.find(api_name);
    324     extensions::ExtensionsClient* extensions_client =
    325         extensions::ExtensionsClient::Get();
    326     DCHECK(extensions_client);
    327     if (maybe_schema_resource != unloaded_schemas_.end()) {
    328       LoadSchema(maybe_schema_resource->first,
    329                  ReadFromResource(maybe_schema_resource->second));
    330     } else if (default_configuration_initialized_ &&
    331                extensions_client->IsAPISchemaGenerated(api_name)) {
    332       LoadSchema(api_name, extensions_client->GetAPISchema(api_name));
    333     } else {
    334       return NULL;
    335     }
    336 
    337     maybe_schema = schemas_.find(api_name);
    338     CHECK(schemas_.end() != maybe_schema);
    339     result = maybe_schema->second.get();
    340   }
    341 
    342   if (!child_name.empty())
    343     result = GetSchemaChild(result, child_name);
    344 
    345   return result;
    346 }
    347 
    348 Feature* ExtensionAPI::GetFeatureDependency(const std::string& full_name) {
    349   std::string feature_type;
    350   std::string feature_name;
    351   SplitDependencyName(full_name, &feature_type, &feature_name);
    352 
    353   FeatureProviderMap::iterator provider =
    354       dependency_providers_.find(feature_type);
    355   if (provider == dependency_providers_.end())
    356     return NULL;
    357 
    358   Feature* feature = provider->second->GetFeature(feature_name);
    359   // Try getting the feature for the parent API, if this was a child.
    360   if (!feature) {
    361     std::string child_name;
    362     feature = provider->second->GetFeature(
    363         GetAPINameFromFullName(feature_name, &child_name));
    364   }
    365   return feature;
    366 }
    367 
    368 std::string ExtensionAPI::GetAPINameFromFullName(const std::string& full_name,
    369                                                  std::string* child_name) {
    370   std::string api_name_candidate = full_name;
    371   extensions::ExtensionsClient* extensions_client =
    372       extensions::ExtensionsClient::Get();
    373   DCHECK(extensions_client);
    374   while (true) {
    375     if (schemas_.find(api_name_candidate) != schemas_.end() ||
    376         extensions_client->IsAPISchemaGenerated(api_name_candidate) ||
    377         unloaded_schemas_.find(api_name_candidate) != unloaded_schemas_.end()) {
    378       std::string result = api_name_candidate;
    379 
    380       if (child_name) {
    381         if (result.length() < full_name.length())
    382           *child_name = full_name.substr(result.length() + 1);
    383         else
    384           *child_name = "";
    385       }
    386 
    387       return result;
    388     }
    389 
    390     size_t last_dot_index = api_name_candidate.rfind('.');
    391     if (last_dot_index == std::string::npos)
    392       break;
    393 
    394     api_name_candidate = api_name_candidate.substr(0, last_dot_index);
    395   }
    396 
    397   *child_name = "";
    398   return std::string();
    399 }
    400 
    401 }  // namespace extensions
    402