Home | History | Annotate | Download | only in browser 
      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   // Keep track of the signin process, so we can restrict extension access to
    100   // it.
    101   void SetSigninProcess(int process_id);
    102   bool IsSigninProcess(int process_id) const;
    103 
    104   // Notifications can be enabled/disabled in real time by the user.
    105   void SetNotificationsDisabled(const std::string& extension_id,
    106                                 bool notifications_disabled);
    107   bool AreNotificationsDisabled(const std::string& extension_id) const;
    108 
    109   void SetContentVerifier(ContentVerifier* verifier);
    110   ContentVerifier* content_verifier() { return content_verifier_.get(); }
    111 
    112  private:
    113   friend class base::RefCountedThreadSafe<InfoMap>;
    114 
    115   // Extra dynamic data related to an extension.
    116   struct ExtraData;
    117   // Map of extension_id to ExtraData.
    118   typedef std::map<std::string, ExtraData> ExtraDataMap;
    119 
    120   ~InfoMap();
    121 
    122   ExtensionSet extensions_;
    123   ExtensionSet disabled_extensions_;
    124 
    125   // Extra data associated with enabled extensions.
    126   ExtraDataMap extra_data_;
    127 
    128   // Used by dispatchers to limit API quota for individual extensions.
    129   // The QuotaService is not thread safe. We need to create and destroy it on
    130   // the IO thread.
    131   scoped_ptr<QuotaService> quota_service_;
    132 
    133   // Assignment of extensions to renderer processes.
    134   extensions::ProcessMap process_map_;
    135 
    136   int signin_process_id_;
    137 
    138   scoped_refptr<ContentVerifier> content_verifier_;
    139 };
    140 
    141 }  // namespace extensions
    142 
    143 #endif  // EXTENSIONS_BROWSER_INFO_MAP_H_
    144