DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209
/* 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 nsIInputStream;
interface nsIOutputStream;
interface nsICacheEntryDoomCallback;

// ************************ REMOVE **********************
typedef long nsCacheAccessMode;
typedef long nsCacheStoragePolicy;

interface nsICacheListener;
interface nsIFile;
interface nsICacheMetaDataVisitor;

[scriptable, uuid(3058bf1e-5116-41cf-826b-e6981308d414)]
interface nsICacheEntry : nsISupports
{
  /**
   * Placeholder for the initial value of expiration time.
   */
  const unsigned long NO_EXPIRATION_TIME = 0xFFFFFFFF;

  /**
   * Get the key identifying the cache entry.
   */
  readonly attribute ACString key;

  /**
   * Whether the entry is memory/only or persisted to disk.
   * Note: private browsing entries are reported as persistent for consistency
   * while are not actually persisted to disk.
   */
  readonly attribute boolean persistent;

  /**
   * Get the number of times the cache entry has been opened.
   */
  readonly attribute long  fetchCount;

  /**
   * Get the last time the cache entry was opened (in seconds since the Epoch).
   */
  readonly attribute uint32_t  lastFetched;

  /**
   * Get the last time the cache entry was modified (in seconds since the Epoch).
   */
  readonly attribute uint32_t  lastModified;

  /**
   * Get the expiration time of the cache entry (in seconds since the Epoch).
   */
  readonly attribute uint32_t  expirationTime;

  /**
   * Set the time at which the cache entry should be considered invalid (in
   * seconds since the Epoch).
   */
  void setExpirationTime(in uint32_t expirationTime);

  /**
   * Open blocking input stream to cache data.  Use the stream transport
   * service to asynchronously read this stream on a background thread.
   * The returned stream MAY implement nsISeekableStream.
   *
   * @param offset
   *        read starting from this offset into the cached data.  an offset
   *        beyond the end of the stream has undefined consequences.
   *
   * @return non-blocking, buffered input stream.
   */
  nsIInputStream openInputStream(in long long offset);

  /**
   * Open non-blocking output stream to cache data.  The returned stream
   * MAY implement nsISeekableStream.
   *
   * If opening an output stream to existing cached data, the data will be
   * truncated to the specified offset.
   *
   * @param offset
   *        write starting from this offset into the cached data.  an offset
   *        beyond the end of the stream has undefined consequences.
   *
   * @return blocking, buffered output stream.
   */
  nsIOutputStream openOutputStream(in long long offset);

  /**
    * Stores the Content-Length specified in the HTTP header for this
    * entry. Checked before we write to the cache entry, to prevent ever
    * taking up space in the cache for an entry that we know up front
    * is going to have to be evicted anyway. See bug 588507.
    */
  attribute int64_t predictedDataSize;

  /**
   * Get/set security info on the cache entry for this descriptor.
   */
  attribute nsISupports securityInfo;

  /**
   * Get the size of the cache entry data, as stored. This may differ
   * from the entry's dataSize, if the entry is compressed.
   */
  readonly attribute unsigned long storageDataSize;

  /**
   * Asynchronously doom an entry. Listener will be notified about the status
   * of the operation. Null may be passed if caller doesn't care about the
   * result.
   */
  void asyncDoom(in nsICacheEntryDoomCallback listener);

  /**
   * Methods for accessing meta data.  Meta data is a table of key/value
   * string pairs.  The strings do not have to conform to any particular
   * charset, but they must be null terminated.
   */
  string getMetaDataElement(in string key);
  void   setMetaDataElement(in string key, in string value);

  /**
   * Claims that all metadata on this entry are up-to-date and this entry
   * now can be delivered to other waiting consumers.
   *
   * We need such method since metadata must be delivered synchronously.
   */
  void metaDataReady();

  /**
   * Called by consumer upon 304/206 response from the server.  This marks
   * the entry content as positively revalidated.
   * Consumer uses this method after the consumer has returned ENTRY_NEEDS_REVALIDATION
   * result from onCacheEntryCheck and after successfull revalidation with the server.
   */
  void setValid();

  /**
   * Doom this entry and open a new, empty, entry for write.  Consumer has
   * to exchange the entry this method is called on for the newly created.
   * Used on 200 responses to conditional requests.
   *
   * @param aMemoryOnly
   *    - whether the entry is to be created as memory/only regardless how
   *      the entry being recreated persistence is set
   * @returns
   *    - an entry that can be used to write to
   * @throws
   *    - NS_ERROR_NOT_AVAILABLE when the entry cannot be from some reason
   *      recreated for write
   */
  nsICacheEntry recreate([optional] in boolean aMemoryOnly);

  /**
   * Returns the length of data this entry holds.
   * @throws
   *    NS_ERROR_IN_PROGRESS when the write is still in progress.
   */
  readonly attribute long long dataSize;

  /****************************************************************************
   * The following methods might be added to some nsICacheEntryInternal
   * interface since we want to remove them as soon as the old cache backend is
   * completely removed.
   */

  /**
   * @deprecated
   * FOR BACKWARD COMPATIBILITY ONLY
   * When the old cache backend is eventually removed, this method
   * can be removed too.
   *
   * In the new backend: this method is no-op
   * In the old backend: this method delegates to nsICacheEntryDescriptor.close()
   */
  void close();

  /**
   * @deprecated
   * FOR BACKWARD COMPATIBILITY ONLY
   * Marks the entry as valid so that others can use it and get only readonly
   * access when the entry is held by the 1st writer.
   */
  void markValid();

  /**
   * @deprecated
   * FOR BACKWARD COMPATIBILITY ONLY
   * Marks the entry as valid when write access is acquired.
   */
  void maybeMarkValid();

  /**
   * @deprecated
   * FOR BACKWARD COMPATIBILITY ONLY / KINDA HACK
   * @param aWriteAllowed
   *    Consumer indicates whether write to the entry is allowed for it.
   *    Depends on implementation how the flag is handled.
   * @returns
   *    true when write access is acquired for this entry,
   *    false otherwise
   */
  boolean hasWriteAccess(in boolean aWriteAllowed);
};