netwerk/cache2/nsICacheStorage.idl

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #include "nsISupports.idl"
   6
   7 interface nsIURI;
   8 interface nsICacheEntry;
   9 interface nsICacheEntryOpenCallback;
  10 interface nsICacheEntryDoomCallback;
  11 interface nsICacheStorageVisitor;
  12
  13 /**
  14  * Representation of a cache storage. There can be just-in-mem,
  15  * in-mem+on-disk, in-mem+on-disk+app-cache or just a specific
  16  * app-cache storage.
  17  */
  18 [scriptable, uuid(35d104a6-d252-4fd4-8a56-3c14657cad3b)]
  19 interface nsICacheStorage : nsISupports
  20 {
  21   /**
  22    * Placeholder for specifying "no special flags" during open.
  23    */
  24   const uint32_t OPEN_NORMALLY = 0;
  25
  26   /**
  27    * Rewrite any existing data when opening a URL.
  28    */
  29   const uint32_t OPEN_TRUNCATE = 1 << 0;
  30
  31   /**
  32    * Only open an existing entry.  Don't create a new one.
  33    */
  34   const uint32_t OPEN_READONLY = 1 << 1;
  35
  36   /**
  37    * Use for first-paint blocking loads.
  38    */
  39   const uint32_t OPEN_PRIORITY = 1 << 2;
  40
  41   /**
  42    * Bypass the cache load when write is still in progress.
  43    */
  44   const uint32_t OPEN_BYPASS_IF_BUSY = 1 << 3;
  45
  46   /**
  47    * Perform the cache entry check (onCacheEntryCheck invocation) on any thread
  48    * for optimal perfomance optimization.  If this flag is not specified it is
  49    * ensured that onCacheEntryCheck is called on the same thread as respective
  50    * asyncOpen has been called.
  51    */
  52   const uint32_t CHECK_MULTITHREADED = 1 << 4;
  53
  54   /**
  55    * Don't automatically update any 'last used' metadata of the entry.
  56    */
  57   const uint32_t OPEN_SECRETLY = 1 << 5;
  58
  59   /**
  60    * Asynchronously opens a cache entry for the specified URI.
  61    * Result is fetched asynchronously via the callback.
  62    *
  63    * @param aURI
  64    *    The URI to search in cache or to open for writting.
  65    * @param aIdExtension
  66    *    Any string that will extend (distinguish) the entry.  Two entries
  67    *    with the same aURI but different aIdExtension will be comletely
  68    *    different entries.  If you don't know what aIdExtension should be
  69    *    leave it empty.
  70    * @param aFlags
  71    *    OPEN_NORMALLY - open cache entry normally for read and write
  72    *    OPEN_TRUNCATE - delete any existing entry before opening it
  73    *    OPEN_READONLY - don't create an entry if there is none
  74    *    OPEN_PRIORITY - give this request a priority over others
  75    *    OPEN_BYPASS_IF_BUSY - backward compatibility only, LOAD_BYPASS_LOCAL_CACHE_IF_BUSY
  76    *    CHECK_MULTITHREADED - onCacheEntryCheck may be called on any thread, consumer
  77    *                          implementation is thread-safe
  78    * @param aCallback
  79    *    The consumer that receives the result.
  80    *    IMPORTANT: The callback may be called sooner the method returns.
  81    */
  82   void asyncOpenURI(in nsIURI aURI, in ACString aIdExtension,
  83                     in uint32_t aFlags,
  84                     in nsICacheEntryOpenCallback aCallback);
  85
  86   /**
  87    * Immediately opens a new and empty cache entry in the storage, any existing
  88    * entries are immediately doomed.  This is similar to the recreate() method
  89    * on nsICacheEntry.
  90    *
  91    * Storage may not implement this method and throw NS_ERROR_NOT_IMPLEMENTED.
  92    * In that case consumer must use asyncOpen with OPEN_TRUNCATE flag and get
  93    * the new entry via a callback.
  94    *
  95    * @param aURI @see asyncOpenURI
  96    * @param aIdExtension @see asyncOpenURI
  97    */
  98   nsICacheEntry openTruncate(in nsIURI aURI,
  99                              in ACString aIdExtension);
 100
 101   /**
 102    * Synchronously check on existance of an entry.  In case of disk entries
 103    * this uses information from the cache index.  When the index data are not
 104    * up to date or index is still building, NS_ERROR_NOT_AVAILABLE is thrown.
 105    * The same error may throw any storage implementation that cannot determine
 106    * entry state without blocking the caller.
 107    */
 108   boolean exists(in nsIURI aURI, in ACString aIdExtension);
 109
 110   /**
 111    * Asynchronously removes an entry belonging to the URI from the cache.
 112    */
 113   void asyncDoomURI(in nsIURI aURI, in ACString aIdExtension,
 114                     in nsICacheEntryDoomCallback aCallback);
 115
 116   /**
 117    * Asynchronously removes all cached entries under this storage.
 118    * NOTE: Disk storage also evicts memory storage.
 119    */
 120   void asyncEvictStorage(in nsICacheEntryDoomCallback aCallback);
 121
 122   /**
 123    * Visits the storage and its entries.
 124    * NOTE: Disk storage also visits memory storage.
 125    */
 126   void asyncVisitStorage(in nsICacheStorageVisitor aVisitor,
 127                          in boolean aVisitEntries);
 128 };