1 files changed, 124 insertions, 0 deletions
diff --git a/chromium/extensions/common/features/feature_provider.cc b/chromium/extensions/common/features/feature_provider.cc
new file mode 100644
index 00000000000..e420094ae77
--- /dev/null
+++ b/chromium/extensions/common/features/feature_provider.cc
@@ -0,0 +1,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