Remove some Profile-keyed factory boilerplate: management omnibox preference push_messaging.

chrome/browser/extensions/api/management/management_api.cc

 // Copyright (c) 2012 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 "chrome/browser/extensions/api/management/management_api.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/json/json_writer.h"
+#include "base/lazy_instance.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/api/management/management_api_constants.h"
 #include "chrome/browser/extensions/event_names.h"
 #include "chrome/browser/extensions/event_router.h"
 #include "chrome/browser/extensions/extension_service.h"
@@ skipping 18 matching lines @@
 #include "extensions/common/url_pattern.h"
 
 #if !defined(OS_ANDROID)
 #include "chrome/browser/ui/webui/ntp/app_launcher_handler.h"
 #endif
 
 using base::IntToString;
 using content::BrowserThread;
 using content::UtilityProcessHost;
 using content::UtilityProcessHostClient;
-using extensions::api::management::ExtensionInfo;
-using extensions::api::management::IconInfo;
-using extensions::ErrorUtils;
-using extensions::Extension;
-using extensions::ExtensionSystem;
-using extensions::PermissionMessages;
 
-namespace events = extensions::event_names;
 namespace keys = extension_management_api_constants;
-namespace management = extensions::api::management;
+
+namespace extensions {
+
+namespace events = event_names;
+namespace management = api::management;
 
 namespace {
 
 typedef std::vector<linked_ptr<management::ExtensionInfo> > ExtensionInfoList;
 typedef std::vector<linked_ptr<management::IconInfo> > IconInfoList;
 
 enum AutoConfirmForTest {
   DO_NOT_SKIP = 0,
   PROCEED,
   ABORT
@@ skipping 25 matching lines @@
   info->version = extension.VersionString();
   info->description = extension.description();
   info->options_url = extension.options_url().spec();
   info->homepage_url.reset(new std::string(
       extension.GetHomepageURL().spec()));
   info->may_disable = system->management_policy()->
       UserMayModifySettings(&extension, NULL);
   info->is_app = extension.is_app();
   if (info->is_app) {
     if (extension.is_legacy_packaged_app())
-      info->type = ExtensionInfo::TYPE_LEGACY_PACKAGED_APP;
+      info->type = management::ExtensionInfo::TYPE_LEGACY_PACKAGED_APP;
     else if (extension.is_hosted_app())
-      info->type = ExtensionInfo::TYPE_HOSTED_APP;
+      info->type = management::ExtensionInfo::TYPE_HOSTED_APP;
     else
-      info->type = ExtensionInfo::TYPE_PACKAGED_APP;
+      info->type = management::ExtensionInfo::TYPE_PACKAGED_APP;
   } else if (extension.is_theme()) {
-    info->type = ExtensionInfo::TYPE_THEME;
+    info->type = management::ExtensionInfo::TYPE_THEME;
   } else {
-    info->type = ExtensionInfo::TYPE_EXTENSION;
+    info->type = management::ExtensionInfo::TYPE_EXTENSION;
   }
 
   if (info->enabled) {
     info->disabled_reason = management::ExtensionInfo::DISABLED_REASON_NONE;
   } else {
-    extensions::ExtensionPrefs* prefs = service->extension_prefs();
+    ExtensionPrefs* prefs = service->extension_prefs();
     if (prefs->DidExtensionEscalatePermissions(extension.id())) {
       info->disabled_reason =
           management::ExtensionInfo::DISABLED_REASON_PERMISSIONS_INCREASE;
     } else {
       info->disabled_reason =
           management::ExtensionInfo::DISABLED_REASON_UNKNOWN;
     }
   }
 
   if (!extension.update_url().is_empty()) {
@@ skipping 24 matching lines @@
   const std::set<std::string> perms =
       extension.GetActivePermissions()->GetAPIsAsStrings();
   if (!perms.empty()) {
     std::set<std::string>::const_iterator perms_iter;
     for (perms_iter = perms.begin(); perms_iter != perms.end(); ++perms_iter)
       info->permissions.push_back(*perms_iter);
   }
 
   if (!extension.is_hosted_app()) {
     // Skip host permissions for hosted apps.
-    const extensions::URLPatternSet host_perms =
+    const URLPatternSet host_perms =
         extension.GetActivePermissions()->explicit_hosts();
     if (!host_perms.is_empty()) {
-      for (extensions::URLPatternSet::const_iterator iter = host_perms.begin();
+      for (URLPatternSet::const_iterator iter = host_perms.begin();
            iter != host_perms.end(); ++iter) {
         info->host_permissions.push_back(iter->GetAsString());
       }
     }
   }
 
   switch (extension.location()) {
     case Extension::INTERNAL:
       info->install_type = management::ExtensionInfo::INSTALL_TYPE_NORMAL;
       break;
@@ skipping 26 matching lines @@
     if (extension.location() == Extension::COMPONENT)
       continue;  // Skip built-in extensions.
 
     extension_list->push_back(make_linked_ptr<management::ExtensionInfo>(
         CreateExtensionInfo(extension, system).release()));
   }
 }
 
 } // namespace
 
-ExtensionService* ExtensionManagementFunction::service() {
+ExtensionService* ManagementFunction::service() {
   return profile()->GetExtensionService();
 }
 
-ExtensionService* AsyncExtensionManagementFunction::service() {
+ExtensionService* AsyncManagementFunction::service() {
   return profile()->GetExtensionService();
 }
 
 bool GetAllExtensionsFunction::RunImpl() {
   ExtensionInfoList extensions;
   ExtensionSystem* system = ExtensionSystem::Get(profile());
 
   AddExtensionInfo(*service()->extensions(), system, &extensions);
   AddExtensionInfo(*service()->disabled_extensions(), system, &extensions);
   AddExtensionInfo(*service()->terminated_extensions(), system, &extensions);
@@ skipping 189 matching lines @@
     error_ = ErrorUtils::FormatErrorMessage(keys::kNotAnAppError,
                                                      params->id);
     return false;
   }
 
   // Look at prefs to find the right launch container.
   // |default_pref_value| is set to LAUNCH_REGULAR so that if
   // the user has not set a preference, we open the app in a tab.
   extension_misc::LaunchContainer launch_container =
       service()->extension_prefs()->GetLaunchContainer(
-          extension, extensions::ExtensionPrefs::LAUNCH_DEFAULT);
+          extension, ExtensionPrefs::LAUNCH_DEFAULT);
   application_launch::OpenApplication(application_launch::LaunchParams(
           profile(), extension, launch_container, NEW_FOREGROUND_TAB));
 #if !defined(OS_ANDROID)
   AppLauncherHandler::RecordAppLaunchType(
       extension_misc::APP_LAUNCH_EXTENSION_API);
 #endif
 
   return true;
 }
 
@@ skipping 10 matching lines @@
 
   extension_id_ = params->id;
 
   const Extension* extension = service()->GetInstalledExtension(extension_id_);
   if (!extension) {
     error_ = ErrorUtils::FormatErrorMessage(
         keys::kNoExtensionError, extension_id_);
     return false;
   }
 
-  const extensions::ManagementPolicy* policy = extensions::ExtensionSystem::Get(
-      profile())->management_policy();
+  const ManagementPolicy* policy = ExtensionSystem::Get(profile())->
+      management_policy();
   if (!policy->UserMayModifySettings(extension, NULL)) {
     error_ = ErrorUtils::FormatErrorMessage(
         keys::kUserCantModifyError, extension_id_);
     return false;
   }
 
   bool currently_enabled = service()->IsExtensionEnabled(extension_id_);
 
   if (!currently_enabled && params->enabled) {
-    extensions::ExtensionPrefs* prefs = service()->extension_prefs();
+    ExtensionPrefs* prefs = service()->extension_prefs();
     if (prefs->DidExtensionEscalatePermissions(extension_id_)) {
       if (!user_gesture()) {
         error_ = keys::kGestureNeededForEscalationError;
         return false;
       }
       AddRef(); // Matched in InstallUIProceed/InstallUIAbort
       install_prompt_.reset(
           new ExtensionInstallPrompt(GetAssociatedWebContents()));
       install_prompt_->ConfirmReEnable(this, extension);
       return true;
@@ skipping 40 matching lines @@
   if (params->options.get() && params->options->show_confirm_dialog.get())
     show_confirm_dialog = *params->options->show_confirm_dialog;
 
   const Extension* extension = service()->GetExtensionById(extension_id_, true);
   if (!extension) {
     error_ = ErrorUtils::FormatErrorMessage(
         keys::kNoExtensionError, extension_id_);
     return false;
   }
 
-  if (!extensions::ExtensionSystem::Get(
-      profile())->management_policy()->UserMayModifySettings(extension, NULL)) {
+  if (!ExtensionSystem::Get(profile())->management_policy()->
+      UserMayModifySettings(extension, NULL)) {
     error_ = ErrorUtils::FormatErrorMessage(
         keys::kUserCantModifyError, extension_id_);
     return false;
   }
 
   if (auto_confirm_for_test == DO_NOT_SKIP) {
     if (show_confirm_dialog) {
       AddRef(); // Balanced in ExtensionUninstallAccepted/Canceled
       extension_uninstall_dialog_.reset(ExtensionUninstallDialog::Create(
           GetCurrentBrowser(), this));
@@ skipping 33 matching lines @@
 void UninstallFunction::ExtensionUninstallAccepted() {
   Finish(true);
   Release();
 }
 
 void UninstallFunction::ExtensionUninstallCanceled() {
   Finish(false);
   Release();
 }
 
-ExtensionManagementEventRouter::ExtensionManagementEventRouter(Profile* profile)
+ManagementEventRouter::ManagementEventRouter(Profile* profile)
     : profile_(profile) {
   int types[] = {
     chrome::NOTIFICATION_EXTENSION_INSTALLED,
     chrome::NOTIFICATION_EXTENSION_UNINSTALLED,
     chrome::NOTIFICATION_EXTENSION_LOADED,
     chrome::NOTIFICATION_EXTENSION_UNLOADED
   };
 
   CHECK(registrar_.IsEmpty());
   for (size_t i = 0; i < arraysize(types); i++) {
     registrar_.Add(this,
                    types[i],
                    content::Source<Profile>(profile_));
   }
 }
 
-ExtensionManagementEventRouter::~ExtensionManagementEventRouter() {}
+ManagementEventRouter::~ManagementEventRouter() {}
 
-void ExtensionManagementEventRouter::Observe(
+void ManagementEventRouter::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   const char* event_name = NULL;
   Profile* profile = content::Source<Profile>(source).ptr();
   CHECK(profile);
   CHECK(profile_->IsSameProfile(profile));
 
   switch (type) {
     case chrome::NOTIFICATION_EXTENSION_INSTALLED:
@@ skipping 13 matching lines @@
       return;
   }
 
   scoped_ptr<ListValue> args(new ListValue());
   if (event_name == events::kOnExtensionUninstalled) {
     args->Append(Value::CreateStringValue(
         content::Details<const Extension>(details).ptr()->id()));
   } else {
     const Extension* extension = NULL;
     if (event_name == events::kOnExtensionDisabled) {
-      extension = content::Details<extensions::UnloadedExtensionInfo>(
-          details)->extension;
+      extension = content::Details<UnloadedExtensionInfo>(details)->extension;
     } else {
       extension = content::Details<const Extension>(details).ptr();
     }
     CHECK(extension);
     scoped_ptr<management::ExtensionInfo> info = CreateExtensionInfo(
         *extension, ExtensionSystem::Get(profile));
     args->Append(info->ToValue().release());
   }
 
-  scoped_ptr<extensions::Event> event(new extensions::Event(
-      event_name, args.Pass()));
-  extensions::ExtensionSystem::Get(profile)->event_router()->
-      BroadcastEvent(event.Pass());
+  scoped_ptr<Event> event(new Event(event_name, args.Pass()));
+  ExtensionSystem::Get(profile)->event_router()->BroadcastEvent(event.Pass());
 }
 
-ExtensionManagementAPI::ExtensionManagementAPI(Profile* profile)
+ManagementAPI::ManagementAPI(Profile* profile)
     : profile_(profile) {
   ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
       this, events::kOnExtensionInstalled);
   ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
       this, events::kOnExtensionUninstalled);
   ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
       this, events::kOnExtensionEnabled);
   ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
       this, events::kOnExtensionDisabled);
 }
 
-ExtensionManagementAPI::~ExtensionManagementAPI() {
+ManagementAPI::~ManagementAPI() {
 }
 
-void ExtensionManagementAPI::Shutdown() {
+void ManagementAPI::Shutdown() {
   ExtensionSystem::Get(profile_)->event_router()->UnregisterObserver(this);
 }
 
-void ExtensionManagementAPI::OnListenerAdded(
-    const extensions::EventListenerInfo& details) {
-  management_event_router_.reset(new ExtensionManagementEventRouter(profile_));
+static base::LazyInstance<ProfileKeyedAPIFactory<ManagementAPI> >
+g_factory = LAZY_INSTANCE_INITIALIZER;
+
+// static
+ProfileKeyedAPIFactory<ManagementAPI>* ManagementAPI::GetFactoryInstance() {
+  return &g_factory.Get();
+}
+
+void ManagementAPI::OnListenerAdded(const EventListenerInfo& details) {
+  management_event_router_.reset(new ManagementEventRouter(profile_));
   ExtensionSystem::Get(profile_)->event_router()->UnregisterObserver(this);
 }
+
+}  // namespace extensions