netwerk/cache2/nsICacheStorage.idl
author Gregor Wagner <gwagner@mozilla.com>
Fri, 12 Feb 2016 19:21:30 +0100
changeset 388242 b65c9eaa99ab0d00ebaca3ac81f66260c63a78c5
parent 328437 40a7c388a4b5714116243730672e1d4067f349df
child 553209 bd3e4d01a1668ab0547482e36f13726cd33fce23
permissions -rw-r--r--
merge mc -> pine

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "nsISupports.idl"

interface nsIURI;
interface nsICacheEntry;
interface nsICacheEntryOpenCallback;
interface nsICacheEntryDoomCallback;
interface nsICacheStorageVisitor;

/**
 * Representation of a cache storage. There can be just-in-mem,
 * in-mem+on-disk, in-mem+on-disk+app-cache or just a specific
 * app-cache storage.
 */
[scriptable, uuid(35d104a6-d252-4fd4-8a56-3c14657cad3b)]
interface nsICacheStorage : nsISupports
{
  /**
   * Placeholder for specifying "no special flags" during open.
   */
  const uint32_t OPEN_NORMALLY = 0;

  /**
   * Rewrite any existing data when opening a URL.
   */
  const uint32_t OPEN_TRUNCATE = 1 << 0;

  /**
   * Only open an existing entry.  Don't create a new one.
   */
  const uint32_t OPEN_READONLY = 1 << 1;

  /**
   * Use for first-paint blocking loads.
   */
  const uint32_t OPEN_PRIORITY = 1 << 2;

  /**
   * Bypass the cache load when write is still in progress.
   */
  const uint32_t OPEN_BYPASS_IF_BUSY = 1 << 3;

  /**
   * Perform the cache entry check (onCacheEntryCheck invocation) on any thread 
   * for optimal perfomance optimization.  If this flag is not specified it is
   * ensured that onCacheEntryCheck is called on the same thread as respective 
   * asyncOpen has been called.
   */
  const uint32_t CHECK_MULTITHREADED = 1 << 4;

  /**
   * Don't automatically update any 'last used' metadata of the entry.
   */
  const uint32_t OPEN_SECRETLY = 1 << 5;

  /**
   * Entry is being opened as part of a service worker interception.  Do not
   * allow the cache to be disabled in this case.
   */
  const uint32_t OPEN_INTERCEPTED = 1 << 6;

  /**
   * Asynchronously opens a cache entry for the specified URI.
   * Result is fetched asynchronously via the callback.
   *
   * @param aURI
   *    The URI to search in cache or to open for writting.
   * @param aIdExtension
   *    Any string that will extend (distinguish) the entry.  Two entries
   *    with the same aURI but different aIdExtension will be comletely
   *    different entries.  If you don't know what aIdExtension should be
   *    leave it empty.
   * @param aFlags
   *    OPEN_NORMALLY - open cache entry normally for read and write
   *    OPEN_TRUNCATE - delete any existing entry before opening it
   *    OPEN_READONLY - don't create an entry if there is none
   *    OPEN_PRIORITY - give this request a priority over others
   *    OPEN_BYPASS_IF_BUSY - backward compatibility only, LOAD_BYPASS_LOCAL_CACHE_IF_BUSY
   *    CHECK_MULTITHREADED - onCacheEntryCheck may be called on any thread, consumer 
   *                          implementation is thread-safe
   * @param aCallback
   *    The consumer that receives the result.
   *    IMPORTANT: The callback may be called sooner the method returns.
   */
  void asyncOpenURI(in nsIURI aURI, in ACString aIdExtension,
                    in uint32_t aFlags,
                    in nsICacheEntryOpenCallback aCallback);

  /**
   * Immediately opens a new and empty cache entry in the storage, any existing
   * entries are immediately doomed.  This is similar to the recreate() method
   * on nsICacheEntry.
   *
   * Storage may not implement this method and throw NS_ERROR_NOT_IMPLEMENTED.
   * In that case consumer must use asyncOpen with OPEN_TRUNCATE flag and get
   * the new entry via a callback.
   *
   * @param aURI @see asyncOpenURI
   * @param aIdExtension @see asyncOpenURI
   */
  nsICacheEntry openTruncate(in nsIURI aURI,
                             in ACString aIdExtension);

  /**
   * Synchronously check on existance of an entry.  In case of disk entries
   * this uses information from the cache index.  When the index data are not
   * up to date or index is still building, NS_ERROR_NOT_AVAILABLE is thrown.
   * The same error may throw any storage implementation that cannot determine
   * entry state without blocking the caller.
   */
  boolean exists(in nsIURI aURI, in ACString aIdExtension);

  /**
   * Asynchronously removes an entry belonging to the URI from the cache.
   */
  void asyncDoomURI(in nsIURI aURI, in ACString aIdExtension,
                    in nsICacheEntryDoomCallback aCallback);

  /**
   * Asynchronously removes all cached entries under this storage.
   * NOTE: Disk storage also evicts memory storage.
   */
  void asyncEvictStorage(in nsICacheEntryDoomCallback aCallback);

  /**
   * Visits the storage and its entries.
   * NOTE: Disk storage also visits memory storage.
   */
  void asyncVisitStorage(in nsICacheStorageVisitor aVisitor,
                         in boolean aVisitEntries);
};