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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
|
// Copyright 2014 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_FEATURES_SIMPLE_FEATURE_H_
#define EXTENSIONS_COMMON_FEATURES_SIMPLE_FEATURE_H_
#include <set>
#include <string>
#include <vector>
#include "base/callback_forward.h"
#include "base/gtest_prod_util.h"
#include "base/lazy_instance.h"
#include "base/memory/scoped_ptr.h"
#include "base/values.h"
#include "extensions/common/extension.h"
#include "extensions/common/features/feature.h"
#include "extensions/common/features/simple_feature_filter.h"
#include "extensions/common/manifest.h"
namespace extensions {
class BaseFeatureProviderTest;
class ExtensionAPITest;
class ManifestUnitTest;
class SimpleFeatureTest;
class SimpleFeature : public Feature {
public:
// Used by tests to override the cached --whitelisted-extension-id.
class ScopedWhitelistForTest {
public:
explicit ScopedWhitelistForTest(const std::string& id);
~ScopedWhitelistForTest();
private:
std::string* previous_id_;
DISALLOW_COPY_AND_ASSIGN(ScopedWhitelistForTest);
};
SimpleFeature();
~SimpleFeature() override;
// Dependency resolution is a property of Features that is preferrably
// handled internally to avoid temptation, but FeatureFilters may need
// to know if there are any at all.
bool HasDependencies() const;
// Adds a filter to this feature. The feature takes ownership of the filter.
void AddFilter(scoped_ptr<SimpleFeatureFilter> filter);
// Parses the JSON representation of a feature into the fields of this object.
// Unspecified values in the JSON are not modified in the object. This allows
// us to implement inheritance by parsing one value after another. Returns
// the error found, or an empty string on success.
virtual std::string Parse(const base::DictionaryValue* dictionary);
Availability IsAvailableToContext(const Extension* extension,
Context context) const {
return IsAvailableToContext(extension, context, GURL());
}
Availability IsAvailableToContext(const Extension* extension,
Context context,
Platform platform) const {
return IsAvailableToContext(extension, context, GURL(), platform);
}
Availability IsAvailableToContext(const Extension* extension,
Context context,
const GURL& url) const {
return IsAvailableToContext(extension, context, url, GetCurrentPlatform());
}
// extension::Feature:
Availability IsAvailableToManifest(const std::string& extension_id,
Manifest::Type type,
Manifest::Location location,
int manifest_version,
Platform platform) const override;
Availability IsAvailableToContext(const Extension* extension,
Context context,
const GURL& url,
Platform platform) const override;
std::string GetAvailabilityMessage(AvailabilityResult result,
Manifest::Type type,
const GURL& url,
Context context) const override;
bool IsInternal() const override;
bool IsIdInBlacklist(const std::string& extension_id) const override;
bool IsIdInWhitelist(const std::string& extension_id) const override;
static bool IsIdInArray(const std::string& extension_id,
const char* const array[],
size_t array_length);
protected:
// Similar to Manifest::Location, these are the classes of locations
// supported in feature files. Production code should never directly access
// these.
enum Location {
UNSPECIFIED_LOCATION,
COMPONENT_LOCATION,
EXTERNAL_COMPONENT_LOCATION,
POLICY_LOCATION,
};
// Accessors defined for testing.
std::vector<std::string>* blacklist() { return &blacklist_; }
const std::vector<std::string>* blacklist() const { return &blacklist_; }
std::vector<std::string>* whitelist() { return &whitelist_; }
const std::vector<std::string>* whitelist() const { return &whitelist_; }
std::vector<Manifest::Type>* extension_types() { return &extension_types_; }
const std::vector<Manifest::Type>* extension_types() const {
return &extension_types_;
}
std::vector<Context>* contexts() { return &contexts_; }
const std::vector<Context>* contexts() const { return &contexts_; }
std::vector<Platform>* platforms() { return &platforms_; }
Location location() const { return location_; }
void set_location(Location location) { location_ = location; }
int min_manifest_version() const { return min_manifest_version_; }
void set_min_manifest_version(int min_manifest_version) {
min_manifest_version_ = min_manifest_version;
}
int max_manifest_version() const { return max_manifest_version_; }
void set_max_manifest_version(int max_manifest_version) {
max_manifest_version_ = max_manifest_version;
}
const std::string& command_line_switch() const {
return command_line_switch_;
}
void set_command_line_switch(const std::string& command_line_switch) {
command_line_switch_ = command_line_switch;
}
// Handy utilities which construct the correct availability message.
Availability CreateAvailability(AvailabilityResult result) const;
Availability CreateAvailability(AvailabilityResult result,
Manifest::Type type) const;
Availability CreateAvailability(AvailabilityResult result,
const GURL& url) const;
Availability CreateAvailability(AvailabilityResult result,
Context context) const;
private:
friend class SimpleFeatureTest;
FRIEND_TEST_ALL_PREFIXES(BaseFeatureProviderTest, ManifestFeatureTypes);
FRIEND_TEST_ALL_PREFIXES(BaseFeatureProviderTest, PermissionFeatureTypes);
FRIEND_TEST_ALL_PREFIXES(ExtensionAPITest, DefaultConfigurationFeatures);
FRIEND_TEST_ALL_PREFIXES(ManifestUnitTest, Extension);
FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, Blacklist);
FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, CommandLineSwitch);
FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, Context);
FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, HashedIdBlacklist);
FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, HashedIdWhitelist);
FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, Inheritance);
FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, Location);
FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, ManifestVersion);
FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, PackageType);
FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, ParseContexts);
FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, ParseLocation);
FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, ParseManifestVersion);
FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, ParseNull);
FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, ParsePackageTypes);
FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, ParsePlatforms);
FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, ParseWhitelist);
FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, Platform);
FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, Whitelist);
// Holds String to Enum value mappings.
struct Mappings;
static bool IsIdInList(const std::string& extension_id,
const std::vector<std::string>& list);
bool MatchesManifestLocation(Manifest::Location manifest_location) const;
Availability CheckDependencies(
const base::Callback<Availability(const Feature*)>& checker) const;
static bool IsValidExtensionId(const std::string& extension_id);
// For clarity and consistency, we handle the default value of each of these
// members the same way: it matches everything. It is up to the higher level
// code that reads Features out of static data to validate that data and set
// sensible defaults.
std::vector<std::string> blacklist_;
std::vector<std::string> whitelist_;
std::vector<std::string> dependencies_;
std::vector<Manifest::Type> extension_types_;
std::vector<Context> contexts_;
std::vector<Platform> platforms_;
URLPatternSet matches_;
Location location_;
int min_manifest_version_;
int max_manifest_version_;
bool component_extensions_auto_granted_;
std::string command_line_switch_;
std::vector<scoped_ptr<SimpleFeatureFilter>> filters_;
DISALLOW_COPY_AND_ASSIGN(SimpleFeature);
};
} // namespace extensions
#endif // EXTENSIONS_COMMON_FEATURES_SIMPLE_FEATURE_H_
|
