Home | History | Annotate | Download | only in browser 
      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 CONTENT_PUBLIC_BROWSER_BROWSER_CONTEXT_H_
      6 #define CONTENT_PUBLIC_BROWSER_BROWSER_CONTEXT_H_
      7 
      8 #include "base/callback_forward.h"
      9 #include "base/containers/hash_tables.h"
     10 #include "base/memory/scoped_ptr.h"
     11 #include "base/supports_user_data.h"
     12 #include "content/common/content_export.h"
     13 #include "content/public/common/push_messaging_status.h"
     14 
     15 class GURL;
     16 
     17 namespace base {
     18 class FilePath;
     19 }
     20 
     21 namespace storage {
     22 class ExternalMountPoints;
     23 }
     24 
     25 namespace net {
     26 class URLRequestContextGetter;
     27 }
     28 
     29 namespace storage {
     30 class SpecialStoragePolicy;
     31 }
     32 
     33 namespace content {
     34 
     35 class BlobHandle;
     36 class BrowserPluginGuestManager;
     37 class DownloadManager;
     38 class DownloadManagerDelegate;
     39 class IndexedDBContext;
     40 class PushMessagingService;
     41 class ResourceContext;
     42 class SiteInstance;
     43 class StoragePartition;
     44 class SSLHostStateDelegate;
     45 
     46 // This class holds the context needed for a browsing session.
     47 // It lives on the UI thread. All these methods must only be called on the UI
     48 // thread.
     49 class CONTENT_EXPORT BrowserContext : public base::SupportsUserData {
     50  public:
     51   static DownloadManager* GetDownloadManager(BrowserContext* browser_context);
     52 
     53   // Returns BrowserContext specific external mount points. It may return NULL
     54   // if the context doesn't have any BrowserContext specific external mount
     55   // points. Currenty, non-NULL value is returned only on ChromeOS.
     56   static storage::ExternalMountPoints* GetMountPoints(BrowserContext* context);
     57 
     58   static content::StoragePartition* GetStoragePartition(
     59       BrowserContext* browser_context, SiteInstance* site_instance);
     60   static content::StoragePartition* GetStoragePartitionForSite(
     61       BrowserContext* browser_context, const GURL& site);
     62   typedef base::Callback<void(StoragePartition*)> StoragePartitionCallback;
     63   static void ForEachStoragePartition(
     64       BrowserContext* browser_context,
     65       const StoragePartitionCallback& callback);
     66   static void AsyncObliterateStoragePartition(
     67       BrowserContext* browser_context,
     68       const GURL& site,
     69       const base::Closure& on_gc_required);
     70 
     71   // This function clears the contents of |active_paths| but does not take
     72   // ownership of the pointer.
     73   static void GarbageCollectStoragePartitions(
     74       BrowserContext* browser_context,
     75       scoped_ptr<base::hash_set<base::FilePath> > active_paths,
     76       const base::Closure& done);
     77 
     78   // DON'T USE THIS. GetDefaultStoragePartition() is going away.
     79   // Use GetStoragePartition() instead. Ask ajwong@ if you have problems.
     80   static content::StoragePartition* GetDefaultStoragePartition(
     81       BrowserContext* browser_context);
     82 
     83   typedef base::Callback<void(scoped_ptr<BlobHandle>)> BlobCallback;
     84 
     85   // |callback| returns a NULL scoped_ptr on failure.
     86   static void CreateMemoryBackedBlob(BrowserContext* browser_context,
     87                                      const char* data, size_t length,
     88                                      const BlobCallback& callback);
     89 
     90   // Delivers a push message with |data| to the Service Worker identified by
     91   // |origin| and |service_worker_registration_id|.
     92   static void DeliverPushMessage(
     93       BrowserContext* browser_context,
     94       const GURL& origin,
     95       int64 service_worker_registration_id,
     96       const std::string& data,
     97       const base::Callback<void(PushMessagingStatus)>& callback);
     98 
     99   // Ensures that the corresponding ResourceContext is initialized. Normally the
    100   // BrowserContext initializs the corresponding getters when its objects are
    101   // created, but if the embedder wants to pass the ResourceContext to another
    102   // thread before they use BrowserContext, they should call this to make sure
    103   // that the ResourceContext is ready.
    104   static void EnsureResourceContextInitialized(BrowserContext* browser_context);
    105 
    106   // Tells the HTML5 objects on this context to persist their session state
    107   // across the next restart.
    108   static void SaveSessionState(BrowserContext* browser_context);
    109 
    110   virtual ~BrowserContext();
    111 
    112   // Returns the path of the directory where this context's data is stored.
    113   virtual base::FilePath GetPath() const = 0;
    114 
    115   // Return whether this context is incognito. Default is false.
    116   virtual bool IsOffTheRecord() const = 0;
    117 
    118   // Returns the request context information associated with this context.  Call
    119   // this only on the UI thread, since it can send notifications that should
    120   // happen on the UI thread.
    121   // TODO(creis): Remove this version in favor of the one below.
    122   virtual net::URLRequestContextGetter* GetRequestContext() = 0;
    123 
    124   // Returns the request context appropriate for the given renderer. If the
    125   // renderer process doesn't have an associated installed app, or if the
    126   // installed app doesn't have isolated storage, this is equivalent to calling
    127   // GetRequestContext().
    128   virtual net::URLRequestContextGetter* GetRequestContextForRenderProcess(
    129       int renderer_child_id) = 0;
    130 
    131   // Returns the default request context for media resources associated with
    132   // this context.
    133   // TODO(creis): Remove this version in favor of the one below.
    134   virtual net::URLRequestContextGetter* GetMediaRequestContext() = 0;
    135 
    136   // Returns the request context for media resources associated with this
    137   // context and renderer process.
    138   virtual net::URLRequestContextGetter* GetMediaRequestContextForRenderProcess(
    139       int renderer_child_id) = 0;
    140   virtual net::URLRequestContextGetter*
    141       GetMediaRequestContextForStoragePartition(
    142           const base::FilePath& partition_path,
    143           bool in_memory) = 0;
    144 
    145   // Returns the resource context.
    146   virtual ResourceContext* GetResourceContext() = 0;
    147 
    148   // Returns the DownloadManagerDelegate for this context. This will be called
    149   // once per context. The embedder owns the delegate and is responsible for
    150   // ensuring that it outlives DownloadManager. It's valid to return NULL.
    151   virtual DownloadManagerDelegate* GetDownloadManagerDelegate() = 0;
    152 
    153   // Returns the guest manager for this context.
    154   virtual BrowserPluginGuestManager* GetGuestManager() = 0;
    155 
    156   // Returns a special storage policy implementation, or NULL.
    157   virtual storage::SpecialStoragePolicy* GetSpecialStoragePolicy() = 0;
    158 
    159   // Returns a push messaging service. The embedder owns the service, and is
    160   // responsible for ensuring that it outlives RenderProcessHost. It's valid to
    161   // return NULL.
    162   virtual PushMessagingService* GetPushMessagingService() = 0;
    163 
    164   // Returns the SSL host state decisions for this context. The context may
    165   // return NULL, implementing the default exception storage strategy.
    166   virtual SSLHostStateDelegate* GetSSLHostStateDelegate() = 0;
    167 };
    168 
    169 }  // namespace content
    170 
    171 #if defined(COMPILER_GCC)
    172 namespace BASE_HASH_NAMESPACE {
    173 
    174 template<>
    175 struct hash<content::BrowserContext*> {
    176   std::size_t operator()(content::BrowserContext* const& p) const {
    177     return reinterpret_cast<std::size_t>(p);
    178   }
    179 };
    180 
    181 }  // namespace BASE_HASH_NAMESPACE
    182 #endif
    183 
    184 #endif  // CONTENT_PUBLIC_BROWSER_BROWSER_CONTEXT_H_
    185