extensions/browser/info_map.h

   1 // Copyright 2013 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_INFO_MAP_H_
   6 #define EXTENSIONS_BROWSER_INFO_MAP_H_
   7
   8 #include <string>
   9
  10 #include "base/basictypes.h"
  11 #include "base/memory/ref_counted.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/time/time.h"
  14 #include "extensions/browser/process_map.h"
  15 #include "extensions/browser/quota_service.h"
  16 #include "extensions/common/extension_set.h"
  17 #include "extensions/common/permissions/api_permission.h"
  18
  19 namespace base {
  20 class FilePath;
  21 }
  22
  23 namespace extensions {
  24 class ContentVerifier;
  25 class Extension;
  26
  27 // Contains extension data that needs to be accessed on the IO thread. It can
  28 // be created/destroyed on any thread, but all other methods must be called on
  29 // the IO thread.
  30 class InfoMap : public base::RefCountedThreadSafe<InfoMap> {
  31  public:
  32   InfoMap();
  33
  34   const ExtensionSet& extensions() const { return extensions_; }
  35   const ExtensionSet& disabled_extensions() const {
  36     return disabled_extensions_;
  37   }
  38
  39   // Information about which extensions are assigned to which render processes.
  40   const ProcessMap& process_map() const { return process_map_; }
  41
  42   // Callback for when new extensions are loaded.
  43   void AddExtension(const extensions::Extension* extension,
  44                     base::Time install_time,
  45                     bool incognito_enabled,
  46                     bool notifications_disabled);
  47
  48   // Callback for when an extension is unloaded.
  49   void RemoveExtension(const std::string& extension_id,
  50                        const extensions::UnloadedExtensionInfo::Reason reason);
  51
  52   // Returns the time the extension was installed, or base::Time() if not found.
  53   base::Time GetInstallTime(const std::string& extension_id) const;
  54
  55   // Returns true if the user has allowed this extension to run in incognito
  56   // mode.
  57   bool IsIncognitoEnabled(const std::string& extension_id) const;
  58
  59   // Returns true if the given extension can see events and data from another
  60   // sub-profile (incognito to original profile, or vice versa).
  61   bool CanCrossIncognito(const extensions::Extension* extension) const;
  62
  63   // Adds an entry to process_map_.
  64   void RegisterExtensionProcess(const std::string& extension_id,
  65                                 int process_id,
  66                                 int site_instance_id);
  67
  68   // Removes an entry from process_map_.
  69   void UnregisterExtensionProcess(const std::string& extension_id,
  70                                   int process_id,
  71                                   int site_instance_id);
  72   void UnregisterAllExtensionsInProcess(int process_id);
  73
  74   // Returns the subset of extensions which has the same |origin| in
  75   // |process_id| with the specified |permission|.
  76   void GetExtensionsWithAPIPermissionForSecurityOrigin(
  77       const GURL& origin,
  78       int process_id,
  79       extensions::APIPermission::ID permission,
  80       ExtensionSet* extensions) const;
  81
  82   // Returns true if there is exists an extension with the same origin as
  83   // |origin| in |process_id| with |permission|.
  84   bool SecurityOriginHasAPIPermission(const GURL& origin,
  85                                       int process_id,
  86                                       extensions::APIPermission::ID permission)
  87       const;
  88
  89   // Maps a |file_url| to a |file_path| on the local filesystem, including
  90   // resources in extensions. Returns true on success. See NaClBrowserDelegate
  91   // for full details.
  92   bool MapUrlToLocalFilePath(const GURL& file_url,
  93                              bool use_blocking_api,
  94                              base::FilePath* file_path);
  95
  96   // Returns the IO thread QuotaService. Creates the instance on first call.
  97   QuotaService* GetQuotaService();
  98
  99   // Notifications can be enabled/disabled in real time by the user.
 100   void SetNotificationsDisabled(const std::string& extension_id,
 101                                 bool notifications_disabled);
 102   bool AreNotificationsDisabled(const std::string& extension_id) const;
 103
 104   void SetContentVerifier(ContentVerifier* verifier);
 105   ContentVerifier* content_verifier() { return content_verifier_.get(); }
 106
 107  private:
 108   friend class base::RefCountedThreadSafe<InfoMap>;
 109
 110   // Extra dynamic data related to an extension.
 111   struct ExtraData;
 112   // Map of extension_id to ExtraData.
 113   typedef std::map<std::string, ExtraData> ExtraDataMap;
 114
 115   ~InfoMap();
 116
 117   ExtensionSet extensions_;
 118   ExtensionSet disabled_extensions_;
 119
 120   // Extra data associated with enabled extensions.
 121   ExtraDataMap extra_data_;
 122
 123   // Used by dispatchers to limit API quota for individual extensions.
 124   // The QuotaService is not thread safe. We need to create and destroy it on
 125   // the IO thread.
 126   scoped_ptr<QuotaService> quota_service_;
 127
 128   // Assignment of extensions to renderer processes.
 129   extensions::ProcessMap process_map_;
 130
 131   scoped_refptr<ContentVerifier> content_verifier_;
 132 };
 133
 134 }  // namespace extensions
 135
 136 #endif  // EXTENSIONS_BROWSER_INFO_MAP_H_