src/extensions/browser/api/declarative/rules_registry_service.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef EXTENSIONS_BROWSER_API_DECLARATIVE_RULES_REGISTRY_SERVICE_H__
   6 #define EXTENSIONS_BROWSER_API_DECLARATIVE_RULES_REGISTRY_SERVICE_H__
   7
   8 #include <map>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/callback_forward.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "base/memory/scoped_vector.h"
  15 #include "base/scoped_observer.h"
  16 #include "content/public/browser/notification_observer.h"
  17 #include "content/public/browser/notification_registrar.h"
  18 #include "extensions/browser/api/declarative/rules_registry.h"
  19 #include "extensions/browser/browser_context_keyed_api_factory.h"
  20 #include "extensions/browser/extension_registry_observer.h"
  21
  22 namespace content {
  23 class BrowserContext;
  24 class NotificationSource;
  25 }
  26
  27 namespace extensions {
  28 class ContentRulesRegistry;
  29 class ExtensionRegistry;
  30 class RulesRegistryStorageDelegate;
  31 }
  32
  33 namespace extensions {
  34
  35 // This class owns all RulesRegistries implementations of an ExtensionService.
  36 // This class lives on the UI thread.
  37 class RulesRegistryService : public BrowserContextKeyedAPI,
  38                              public content::NotificationObserver,
  39                              public ExtensionRegistryObserver {
  40  public:
  41   typedef RulesRegistry::WebViewKey WebViewKey;
  42   struct RulesRegistryKey {
  43     std::string event_name;
  44     WebViewKey webview_key;
  45     RulesRegistryKey(const std::string event_name,
  46                      const WebViewKey& webview_key)
  47         : event_name(event_name),
  48           webview_key(webview_key) {}
  49     bool operator<(const RulesRegistryKey& other) const {
  50       return (event_name < other.event_name) ||
  51           ((event_name == other.event_name) &&
  52           (webview_key < other.webview_key));
  53     }
  54   };
  55
  56   explicit RulesRegistryService(content::BrowserContext* context);
  57   virtual ~RulesRegistryService();
  58
  59   // Unregisters refptrs to concrete RulesRegistries at other objects that were
  60   // created by us so that the RulesRegistries can be released.
  61   virtual void Shutdown() OVERRIDE;
  62
  63   // BrowserContextKeyedAPI implementation.
  64   static BrowserContextKeyedAPIFactory<RulesRegistryService>*
  65       GetFactoryInstance();
  66
  67   // Convenience method to get the RulesRegistryService for a context.
  68   static RulesRegistryService* Get(content::BrowserContext* context);
  69
  70   // Registers the default RulesRegistries used in Chromium.
  71   void EnsureDefaultRulesRegistriesRegistered(const WebViewKey& webview_key);
  72
  73   // Registers a RulesRegistry and wraps it in an InitializingRulesRegistry.
  74   void RegisterRulesRegistry(scoped_refptr<RulesRegistry> rule_registry);
  75
  76   // Returns the RulesRegistry for |event_name| and |webview_key| or NULL if no
  77   // such registry has been registered. Default rules registries (such as the
  78   // WebRequest rules registry) will be created on first access.
  79   scoped_refptr<RulesRegistry> GetRulesRegistry(const WebViewKey& webview_key,
  80                                                 const std::string& event_name);
  81
  82   // Accessors for each type of rules registry.
  83   ContentRulesRegistry* content_rules_registry() const {
  84     CHECK(content_rules_registry_);
  85     return content_rules_registry_;
  86   }
  87
  88   // Removes all rules registries of a given webview embedder process ID.
  89   void RemoveWebViewRulesRegistries(int process_id);
  90
  91   // For testing.
  92   void SimulateExtensionUninstalled(const std::string& extension_id);
  93
  94  private:
  95   friend class BrowserContextKeyedAPIFactory<RulesRegistryService>;
  96
  97   // Maps <event name, webview key> to RuleRegistries that handle these
  98   // events.
  99   typedef std::map<RulesRegistryKey, scoped_refptr<RulesRegistry> >
 100       RulesRegistryMap;
 101
 102   // Implementation of content::NotificationObserver.
 103   virtual void Observe(int type,
 104                        const content::NotificationSource& source,
 105                        const content::NotificationDetails& details) OVERRIDE;
 106
 107   // ExtensionRegistryObserver implementation.
 108   virtual void OnExtensionLoaded(content::BrowserContext* browser_context,
 109                                  const Extension* extension) OVERRIDE;
 110   virtual void OnExtensionUnloaded(
 111       content::BrowserContext* browser_context,
 112       const Extension* extension,
 113       UnloadedExtensionInfo::Reason reason) OVERRIDE;
 114   virtual void OnExtensionUninstalled(
 115       content::BrowserContext* browser_context,
 116       const Extension* extension,
 117       extensions::UninstallReason reason) OVERRIDE;
 118
 119   // Iterates over all registries, and calls |notification_callback| on them
 120   // with |extension_id| as the argument. If a registry lives on a different
 121   // thread, the call is posted to that thread, so no guarantee of synchronous
 122   // processing.
 123   void NotifyRegistriesHelper(
 124       void (RulesRegistry::*notification_callback)(const std::string&),
 125       const std::string& extension_id);
 126
 127   // BrowserContextKeyedAPI implementation.
 128   static const char* service_name() {
 129     return "RulesRegistryService";
 130   }
 131   static const bool kServiceHasOwnInstanceInIncognito = true;
 132   static const bool kServiceIsNULLWhileTesting = true;
 133
 134   RulesRegistryMap rule_registries_;
 135
 136   // We own the parts of the registries which need to run on the UI thread.
 137   ScopedVector<RulesCacheDelegate> cache_delegates_;
 138
 139   // Weak pointer into rule_registries_ to make it easier to handle content rule
 140   // conditions.
 141   ContentRulesRegistry* content_rules_registry_;
 142
 143   content::NotificationRegistrar registrar_;
 144
 145   // Listen to extension load, unloaded notification.
 146   ScopedObserver<ExtensionRegistry, ExtensionRegistryObserver>
 147       extension_registry_observer_;
 148
 149   content::BrowserContext* browser_context_;
 150
 151   DISALLOW_COPY_AND_ASSIGN(RulesRegistryService);
 152 };
 153
 154 }  // namespace extensions
 155
 156 #endif  // EXTENSIONS_BROWSER_API_DECLARATIVE_RULES_REGISTRY_SERVICE_H__