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.
5 #include "extensions/common/extension_api.h"
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"
30 namespace extensions {
32 using api::GeneratedSchemas;
36 const char* kChildKinds[] = {
41 base::StringPiece ReadFromResource(int resource_id) {
42 return ResourceBundle::GetSharedInstance().GetRawDataResource(
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(
52 base::JSON_PARSE_RFC | base::JSON_DETACHABLE_CHILDREN, // options
56 // Tracking down http://crbug.com/121424
58 base::snprintf(buf, arraysize(buf), "%s: (%d) '%s'",
60 result.get() ? result->GetType() : -1,
61 error_message.c_str());
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*>(
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;
77 if (item->GetString(property_name, &value) && value == property_value)
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))
92 child_node = FindListItem(list_node, "name", child_name);
102 : api(ExtensionAPI::CreateWithDefaultConfiguration()) {
104 scoped_ptr<ExtensionAPI> api;
107 base::LazyInstance<Static> g_lazy_instance = LAZY_INSTANCE_INITIALIZER;
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| + "." +
112 void MaybePrefixFieldWithNamespace(const std::string& schema_namespace,
113 base::DictionaryValue* schema,
114 const std::string& key) {
115 if (!schema->HasKey(key))
119 CHECK(schema->GetString(key, &old_id));
120 if (old_id.find(".") == std::string::npos)
121 schema->SetString(key, schema_namespace + "." + old_id);
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);
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);
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"))
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");
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);
172 ExtensionAPI* ExtensionAPI::GetSharedInstance() {
173 return g_lazy_instance.Get().api.get();
177 ExtensionAPI* ExtensionAPI::CreateWithDefaultConfiguration() {
178 ExtensionAPI* api = new ExtensionAPI();
179 api->InitDefaultConfiguration();
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;
195 *feature_type = full_name.substr(0, colon_index);
196 *feature_name = full_name.substr(colon_index + 1);
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;
204 while (!schema_list->empty()) {
205 base::DictionaryValue* schema = NULL;
207 scoped_ptr<base::Value> value;
208 schema_list->Remove(schema_list->GetSize() - 1, &value);
209 CHECK(value.release()->GetAsDictionary(&schema));
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));
220 ExtensionAPI::ExtensionAPI() : default_configuration_initialized_(false) {
223 ExtensionAPI::~ExtensionAPI() {
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]));
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("inputMethodPrivate",
245 IDR_EXTENSION_API_JSON_INPUTMETHODPRIVATE);
246 RegisterSchemaResource("pageAction", IDR_EXTENSION_API_JSON_PAGEACTION);
247 RegisterSchemaResource("pageActions", IDR_EXTENSION_API_JSON_PAGEACTIONS);
248 RegisterSchemaResource("privacy", IDR_EXTENSION_API_JSON_PRIVACY);
249 RegisterSchemaResource("processes", IDR_EXTENSION_API_JSON_PROCESSES);
250 RegisterSchemaResource("proxy", IDR_EXTENSION_API_JSON_PROXY);
251 RegisterSchemaResource("scriptBadge", IDR_EXTENSION_API_JSON_SCRIPTBADGE);
252 RegisterSchemaResource("ttsEngine", IDR_EXTENSION_API_JSON_TTSENGINE);
253 RegisterSchemaResource("tts", IDR_EXTENSION_API_JSON_TTS);
254 RegisterSchemaResource("types", IDR_EXTENSION_API_JSON_TYPES);
255 RegisterSchemaResource("types.private", IDR_EXTENSION_API_JSON_TYPES_PRIVATE);
256 RegisterSchemaResource("webRequestInternal",
257 IDR_EXTENSION_API_JSON_WEBREQUESTINTERNAL);
258 RegisterSchemaResource("webstore", IDR_EXTENSION_API_JSON_WEBSTORE);
259 RegisterSchemaResource("webstorePrivate",
260 IDR_EXTENSION_API_JSON_WEBSTOREPRIVATE);
261 RegisterSchemaResource("webViewRequest",
262 IDR_EXTENSION_API_JSON_WEBVIEW_REQUEST);
264 default_configuration_initialized_ = true;
267 void ExtensionAPI::RegisterSchemaResource(const std::string& name,
269 unloaded_schemas_[name] = resource_id;
272 void ExtensionAPI::RegisterDependencyProvider(const std::string& name,
273 FeatureProvider* provider) {
274 dependency_providers_[name] = provider;
277 bool ExtensionAPI::IsAnyFeatureAvailableToContext(const Feature& api,
278 const Extension* extension,
279 Feature::Context context,
281 FeatureProviderMap::iterator provider = dependency_providers_.find("api");
282 CHECK(provider != dependency_providers_.end());
283 if (IsAvailable(api, extension, context, url).is_available())
286 // Check to see if there are any parts of this API that are allowed in this
288 const std::vector<Feature*> features = provider->second->GetChildren(api);
289 for (std::vector<Feature*>::const_iterator feature = features.begin();
290 feature != features.end();
292 if (IsAvailable(**feature, extension, context, url).is_available())
298 Feature::Availability ExtensionAPI::IsAvailable(const std::string& full_name,
299 const Extension* extension,
300 Feature::Context context,
302 Feature* feature = GetFeatureDependency(full_name);
303 CHECK(feature) << full_name;
304 return IsAvailable(*feature, extension, context, url);
307 Feature::Availability ExtensionAPI::IsAvailable(const Feature& feature,
308 const Extension* extension,
309 Feature::Context context,
311 Feature::Availability availability =
312 feature.IsAvailableToContext(extension, context, url);
313 if (!availability.is_available())
316 for (std::set<std::string>::iterator iter = feature.dependencies().begin();
317 iter != feature.dependencies().end(); ++iter) {
318 Feature::Availability dependency_availability =
319 IsAvailable(*iter, extension, context, url);
320 if (!dependency_availability.is_available())
321 return dependency_availability;
324 return Feature::CreateAvailability(Feature::IS_AVAILABLE, std::string());
327 bool ExtensionAPI::IsPrivileged(const std::string& full_name) {
328 Feature* feature = GetFeatureDependency(full_name);
330 DCHECK(!feature->GetContexts()->empty());
331 // An API is 'privileged' if it can only be run in a blessed context.
332 return feature->GetContexts()->size() ==
333 feature->GetContexts()->count(Feature::BLESSED_EXTENSION_CONTEXT);
336 const base::DictionaryValue* ExtensionAPI::GetSchema(
337 const std::string& full_name) {
338 std::string child_name;
339 std::string api_name = GetAPINameFromFullName(full_name, &child_name);
341 const base::DictionaryValue* result = NULL;
342 SchemaMap::iterator maybe_schema = schemas_.find(api_name);
343 if (maybe_schema != schemas_.end()) {
344 result = maybe_schema->second.get();
346 // Might not have loaded yet; or might just not exist.
347 UnloadedSchemaMap::iterator maybe_schema_resource =
348 unloaded_schemas_.find(api_name);
349 if (maybe_schema_resource != unloaded_schemas_.end()) {
350 LoadSchema(maybe_schema_resource->first,
351 ReadFromResource(maybe_schema_resource->second));
352 } else if (default_configuration_initialized_ &&
353 GeneratedSchemas::IsGenerated(api_name)) {
354 LoadSchema(api_name, GeneratedSchemas::Get(api_name));
359 maybe_schema = schemas_.find(api_name);
360 CHECK(schemas_.end() != maybe_schema);
361 result = maybe_schema->second.get();
364 if (!child_name.empty())
365 result = GetSchemaChild(result, child_name);
370 Feature* ExtensionAPI::GetFeatureDependency(const std::string& full_name) {
371 std::string feature_type;
372 std::string feature_name;
373 SplitDependencyName(full_name, &feature_type, &feature_name);
375 FeatureProviderMap::iterator provider =
376 dependency_providers_.find(feature_type);
377 if (provider == dependency_providers_.end())
380 Feature* feature = provider->second->GetFeature(feature_name);
381 // Try getting the feature for the parent API, if this was a child.
383 std::string child_name;
384 feature = provider->second->GetFeature(
385 GetAPINameFromFullName(feature_name, &child_name));
390 std::string ExtensionAPI::GetAPINameFromFullName(const std::string& full_name,
391 std::string* child_name) {
392 std::string api_name_candidate = full_name;
394 if (schemas_.find(api_name_candidate) != schemas_.end() ||
395 GeneratedSchemas::IsGenerated(api_name_candidate) ||
396 unloaded_schemas_.find(api_name_candidate) != unloaded_schemas_.end()) {
397 std::string result = api_name_candidate;
400 if (result.length() < full_name.length())
401 *child_name = full_name.substr(result.length() + 1);
409 size_t last_dot_index = api_name_candidate.rfind('.');
410 if (last_dot_index == std::string::npos)
413 api_name_candidate = api_name_candidate.substr(0, last_dot_index);
417 return std::string();
420 } // namespace extensions