blob: e420094ae7726c7a9a2810e28c9716684bfae008 (
plain)
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
|
// 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.
#include "extensions/common/features/feature_provider.h"
#include <map>
#include "base/command_line.h"
#include "base/lazy_instance.h"
#include "base/memory/scoped_ptr.h"
#include "base/metrics/histogram_macros.h"
#include "base/trace_event/trace_event.h"
#include "content/public/common/content_switches.h"
#include "extensions/common/extensions_client.h"
#include "extensions/common/features/feature_util.h"
#include "extensions/common/switches.h"
namespace extensions {
namespace {
class Static {
public:
FeatureProvider* GetFeatures(const std::string& name) const {
auto it = feature_providers_.find(name);
if (it == feature_providers_.end())
CRASH_WITH_MINIDUMP("FeatureProvider \"" + name + "\" not found");
return it->second.get();
}
private:
friend struct base::DefaultLazyInstanceTraits<Static>;
Static() {
TRACE_EVENT0("startup", "extensions::FeatureProvider::Static");
base::Time begin_time = base::Time::Now();
ExtensionsClient* client = ExtensionsClient::Get();
feature_providers_["api"] = client->CreateFeatureProvider("api");
feature_providers_["manifest"] = client->CreateFeatureProvider("manifest");
feature_providers_["permission"] =
client->CreateFeatureProvider("permission");
feature_providers_["behavior"] = client->CreateFeatureProvider("behavior");
base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
std::string process_type =
command_line->GetSwitchValueASCII(::switches::kProcessType);
// Measure time only for browser process. This method gets called by the
// browser process on startup, as well as on renderer and extension
// processes throughout the execution of the browser. We are more
// interested in how long this takes as a startup cost, so we are
// just measuring the time in the browser process.
if (process_type == std::string()) {
UMA_HISTOGRAM_TIMES("Extensions.FeatureProviderStaticInitTime",
base::Time::Now() - begin_time);
}
}
std::map<std::string, scoped_ptr<FeatureProvider>> feature_providers_;
};
base::LazyInstance<Static> g_static = LAZY_INSTANCE_INITIALIZER;
const Feature* GetFeatureFromProviderByName(const std::string& provider_name,
const std::string& feature_name) {
const Feature* feature =
FeatureProvider::GetByName(provider_name)->GetFeature(feature_name);
if (!feature) {
CRASH_WITH_MINIDUMP("Feature \"" + feature_name + "\" not found in " +
"FeatureProvider \"" + provider_name + "\"");
}
return feature;
}
} // namespace
// static
const FeatureProvider* FeatureProvider::GetByName(const std::string& name) {
return g_static.Get().GetFeatures(name);
}
// static
const FeatureProvider* FeatureProvider::GetAPIFeatures() {
return GetByName("api");
}
// static
const FeatureProvider* FeatureProvider::GetManifestFeatures() {
return GetByName("manifest");
}
// static
const FeatureProvider* FeatureProvider::GetPermissionFeatures() {
return GetByName("permission");
}
// static
const FeatureProvider* FeatureProvider::GetBehaviorFeatures() {
return GetByName("behavior");
}
// static
const Feature* FeatureProvider::GetAPIFeature(const std::string& name) {
return GetFeatureFromProviderByName("api", name);
}
// static
const Feature* FeatureProvider::GetManifestFeature(const std::string& name) {
return GetFeatureFromProviderByName("manifest", name);
}
// static
const Feature* FeatureProvider::GetPermissionFeature(const std::string& name) {
return GetFeatureFromProviderByName("permission", name);
}
// static
const Feature* FeatureProvider::GetBehaviorFeature(const std::string& name) {
return GetFeatureFromProviderByName("behavior", name);
}
} // namespace extensions
|
