1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
// Copyright 2013 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.
#ifndef EXTENSIONS_COMMON_EXTENSION_API_H_
#define EXTENSIONS_COMMON_EXTENSION_API_H_
#include <map>
#include <string>
#include "base/basictypes.h"
#include "base/gtest_prod_util.h"
#include "base/memory/linked_ptr.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/singleton.h"
#include "base/strings/string_piece.h"
#include "base/values.h"
#include "extensions/common/features/feature.h"
#include "extensions/common/features/feature_provider.h"
#include "extensions/common/url_pattern_set.h"
namespace base {
class DictionaryValue;
class Value;
}
class GURL;
namespace extensions {
class Extension;
class Feature;
// C++ Wrapper for the JSON API definitions in chrome/common/extensions/api/.
//
// WARNING: This class is accessed on multiple threads in the browser process
// (see ExtensionFunctionDispatcher). No state should be modified after
// construction.
class ExtensionAPI {
public:
// Returns a single shared instance of this class. This is the typical use
// case in Chrome.
//
// TODO(aa): Make this const to enforce thread-safe usage.
static ExtensionAPI* GetSharedInstance();
// Creates a new instance configured the way ExtensionAPI typically is in
// Chrome. Use the default constructor to get a clean instance.
static ExtensionAPI* CreateWithDefaultConfiguration();
// Splits a name like "permission:bookmark" into ("permission", "bookmark").
// The first part refers to a type of feature, for example "manifest",
// "permission", or "api". The second part is the full name of the feature.
static void SplitDependencyName(const std::string& full_name,
std::string* feature_type,
std::string* feature_name);
// Creates a completely clean instance. Configure using RegisterSchema() and
// RegisterDependencyProvider before use.
ExtensionAPI();
virtual ~ExtensionAPI();
void RegisterSchemaResource(const std::string& api_name, int resource_id);
void RegisterDependencyProvider(const std::string& name,
FeatureProvider* provider);
// Returns true if the specified API is available. Returns true if the feature
// and all of its dependencies are available to the specified context.
Feature::Availability IsAvailable(const Feature& api,
const Extension* extension,
Feature::Context context,
const GURL& url);
// Same as the previous overload, but takes a feature name instead of an
// object. |api_full_name| can be either a namespace name (like "bookmarks")
// or a member name (like "bookmarks.create").
Feature::Availability IsAvailable(const std::string& api_full_name,
const Extension* extension,
Feature::Context context,
const GURL& url);
// Determines whether an API, or any parts of that API, are available in
// |context|.
bool IsAnyFeatureAvailableToContext(const Feature& api,
const Extension* extension,
Feature::Context context,
const GURL& url);
// Returns true if |name| is a privileged API path. Privileged paths can only
// be called from extension code which is running in its own designated
// extension process. They cannot be called from extension code running in
// content scripts, or other low-privileged contexts.
bool IsPrivileged(const std::string& name);
// Gets the schema for the extension API with namespace |full_name|.
// Ownership remains with this object.
const base::DictionaryValue* GetSchema(const std::string& full_name);
// Splits a full name from the extension API into its API and child name
// parts. Some examples:
//
// "bookmarks.create" -> ("bookmarks", "create")
// "experimental.input.ui.cursorUp" -> ("experimental.input.ui", "cursorUp")
// "storage.sync.set" -> ("storage", "sync.get")
// "<unknown-api>.monkey" -> ("", "")
//
// The |child_name| parameter can be be NULL if you don't need that part.
std::string GetAPINameFromFullName(const std::string& full_name,
std::string* child_name);
private:
FRIEND_TEST_ALL_PREFIXES(ExtensionAPITest, DefaultConfigurationFeatures);
FRIEND_TEST_ALL_PREFIXES(ExtensionAPITest, TypesHaveNamespace);
friend struct DefaultSingletonTraits<ExtensionAPI>;
void InitDefaultConfiguration();
bool default_configuration_initialized_;
// Gets a feature from any dependency provider registered with ExtensionAPI.
// Returns NULL if the feature could not be found.
Feature* GetFeatureDependency(const std::string& dependency_name);
// Loads a schema.
void LoadSchema(const std::string& name, const base::StringPiece& schema);
// Map from each API that hasn't been loaded yet to the schema which defines
// it. Note that there may be multiple APIs per schema.
typedef std::map<std::string, int> UnloadedSchemaMap;
UnloadedSchemaMap unloaded_schemas_;
// Schemas for each namespace.
typedef std::map<std::string, linked_ptr<const base::DictionaryValue> >
SchemaMap;
SchemaMap schemas_;
// FeatureProviders used for resolving dependencies.
typedef std::map<std::string, FeatureProvider*> FeatureProviderMap;
FeatureProviderMap dependency_providers_;
DISALLOW_COPY_AND_ASSIGN(ExtensionAPI);
};
} // namespace extensions
#endif // EXTENSIONS_COMMON_EXTENSION_API_H_
|
