mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-22 01:35:35 +00:00
1efe8b8b26
Whenever a cache entry is accessed during a document load, eTLD+1 of the top level document is added to the entry's metadata. Number of accessing sites is also stored in cache index. So we know how many copies of each entry would we have if we did a first party isolation without data deduplication. The telemetry is sent every time we write 2GB to the cache and then the data is reset. Telemetry report ID is an identifier of the telemetry cycle and it's used to invalidate eTLD+1 hashes in all cache entries. Differential Revision: https://phabricator.services.mozilla.com/D26425 --HG-- extra : moz-landing-system : lando
371 lines
13 KiB
Plaintext
371 lines
13 KiB
Plaintext
/* 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"
|
|
#include "nsICache.idl"
|
|
|
|
interface nsIInputStream;
|
|
interface nsIOutputStream;
|
|
interface nsIAsyncOutputStream;
|
|
interface nsICacheEntryDoomCallback;
|
|
|
|
interface nsICacheListener;
|
|
interface nsIFile;
|
|
interface nsICacheEntryMetaDataVisitor;
|
|
interface nsILoadContextInfo;
|
|
|
|
[scriptable, uuid(607c2a2c-0a48-40b9-a956-8cf2bb9857cf)]
|
|
interface nsICacheEntry : nsISupports
|
|
{
|
|
const unsigned long CONTENT_TYPE_UNKNOWN = 0;
|
|
const unsigned long CONTENT_TYPE_OTHER = 1;
|
|
const unsigned long CONTENT_TYPE_JAVASCRIPT = 2;
|
|
const unsigned long CONTENT_TYPE_IMAGE = 3;
|
|
const unsigned long CONTENT_TYPE_MEDIA = 4;
|
|
const unsigned long CONTENT_TYPE_STYLESHEET = 5;
|
|
const unsigned long CONTENT_TYPE_WASM = 6;
|
|
/**
|
|
* Content type that is used internally to check whether the value parsed
|
|
* from disk is within allowed limits. Don't pass CONTENT_TYPE_LAST to
|
|
* setContentType method.
|
|
*/
|
|
const unsigned long CONTENT_TYPE_LAST = 7;
|
|
|
|
/**
|
|
* 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;
|
|
|
|
/**
|
|
* The unique ID for every nsICacheEntry instance, which can be used to check
|
|
* whether two pieces of information are from the same nsICacheEntry instance.
|
|
*/
|
|
readonly attribute uint64_t cacheEntryId;
|
|
|
|
/**
|
|
* 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);
|
|
|
|
/**
|
|
* Get the last network response times for onStartReqeust/onStopRequest (in ms).
|
|
* @throws
|
|
* - NS_ERROR_NOT_AVAILABLE if onStartTime/onStopTime does not exist.
|
|
*/
|
|
readonly attribute uint64_t onStartTime;
|
|
readonly attribute uint64_t onStopTime;
|
|
|
|
/**
|
|
* Set the network response times for onStartReqeust/onStopRequest (in ms).
|
|
*/
|
|
void setNetworkTimes(in uint64_t onStartTime, in uint64_t onStopTime);
|
|
|
|
/**
|
|
* Set content type. Available types are defined at the begining of this file.
|
|
* The content type is used internally for cache partitioning and telemetry
|
|
* purposes so there is no getter.
|
|
*/
|
|
void setContentType(in uint8_t contentType);
|
|
|
|
/**
|
|
* Stores information about an access from site identified by unique siteID.
|
|
* It's used for first party cache isolation telemetry.
|
|
*/
|
|
void addBaseDomainAccess(in uint32_t siteID);
|
|
|
|
/**
|
|
* This method is intended to override the per-spec cache validation
|
|
* decisions for a duration specified in seconds. The current state can
|
|
* be examined with isForcedValid (see below). This value is not persisted,
|
|
* so it will not survive session restart. Cache entries that are forced valid
|
|
* will not be evicted from the cache for the duration of forced validity.
|
|
* This means that there is a potential problem if the number of forced valid
|
|
* entries grows to take up more space than the cache size allows.
|
|
*
|
|
* NOTE: entries that have been forced valid will STILL be ignored by HTTP
|
|
* channels if they have expired AND the resource in question requires
|
|
* validation after expiring. This is to avoid using known-stale content.
|
|
*
|
|
* @param aSecondsToTheFuture
|
|
* the number of seconds the default cache validation behavior will be
|
|
* overridden before it returns to normal
|
|
*/
|
|
void forceValidFor(in unsigned long aSecondsToTheFuture);
|
|
|
|
/**
|
|
* The state variable for whether this entry is currently forced valid.
|
|
* Defaults to false for normal cache validation behavior, and will return
|
|
* true if the number of seconds set by forceValidFor() has yet to be reached.
|
|
*/
|
|
readonly attribute boolean isForcedValid;
|
|
|
|
/**
|
|
* 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.
|
|
* @param predictedSize
|
|
* Predicted size of the data that will be written. It's used to decide
|
|
* whether the resulting entry would exceed size limit, in which case
|
|
* an error is thrown. If the size isn't known in advance, -1 should be
|
|
* passed.
|
|
*
|
|
* @return blocking, buffered output stream.
|
|
*/
|
|
nsIOutputStream openOutputStream(in long long offset, in long long predictedSize);
|
|
|
|
/**
|
|
* 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);
|
|
|
|
/**
|
|
* Obtain the list of metadata keys this entry keeps.
|
|
*
|
|
* NOTE: The callback is invoked under the CacheFile's lock. It means
|
|
* there should not be made any calls to the entry from the visitor and
|
|
* if the values need to be processed somehow, it's better to cache them
|
|
* and process outside the callback.
|
|
*/
|
|
void visitMetaData(in nsICacheEntryMetaDataVisitor visitor);
|
|
|
|
/**
|
|
* 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();
|
|
|
|
/**
|
|
* Explicitly tell the cache backend this consumer is no longer going to modify
|
|
* this cache entry data or metadata. In case the consumer was responsible to
|
|
* either of writing the cache entry or revalidating it, calling this method
|
|
* reverts the state to initial (as never written) or as not-validated and
|
|
* immediately notifies the next consumer in line waiting for this entry.
|
|
* This is the way to prevent deadlocks when someone else than the responsible
|
|
* channel references the cache entry being in a non-written or revalidating
|
|
* state.
|
|
*/
|
|
void dismiss();
|
|
|
|
/**
|
|
* Returns the size in kilobytes used to store the cache entry on disk.
|
|
*/
|
|
readonly attribute uint32_t diskStorageSizeInKB;
|
|
|
|
/**
|
|
* 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;
|
|
|
|
/**
|
|
* Returns the length of data this entry holds.
|
|
* @throws
|
|
* - NS_ERROR_IN_PROGRESS when a write is still in progress (either real
|
|
content or alt data).
|
|
* - NS_ERROR_NOT_AVAILABLE if alt data does not exist.
|
|
*/
|
|
readonly attribute long long altDataSize;
|
|
|
|
/**
|
|
* Returns the type of the saved alt data.
|
|
* @throws
|
|
* - NS_ERROR_NOT_AVAILABLE if alt data does not exist.
|
|
*/
|
|
readonly attribute ACString altDataType;
|
|
|
|
/**
|
|
* Opens and returns an output stream that a consumer may use to save an
|
|
* alternate representation of the data.
|
|
*
|
|
* @param type
|
|
* type of the alternative data representation
|
|
* @param predictedSize
|
|
* Predicted size of the data that will be written. It's used to decide
|
|
* whether the resulting entry would exceed size limit, in which case
|
|
* an error is thrown. If the size isn't known in advance, -1 should be
|
|
* passed.
|
|
*
|
|
* @throws
|
|
* - NS_ERROR_NOT_AVAILABLE if the real data hasn't been written.
|
|
* - NS_ERROR_IN_PROGRESS when the writing regular content or alt-data to
|
|
* the cache entry is still in progress.
|
|
*
|
|
* If there is alt-data already saved, it will be overwritten.
|
|
*/
|
|
nsIAsyncOutputStream openAlternativeOutputStream(in ACString type, in long long predictedSize);
|
|
|
|
/**
|
|
* Opens and returns an input stream that can be used to read the alternative
|
|
* representation previously saved in the cache.
|
|
* If this call is made while writing alt-data is still in progress, it is
|
|
* still possible to read content from the input stream as it's being written.
|
|
* @throws
|
|
* - NS_ERROR_NOT_AVAILABLE if the alt-data representation doesn't exist at
|
|
* all or if alt-data of the given type doesn't exist.
|
|
*/
|
|
nsIInputStream openAlternativeInputStream(in ACString type);
|
|
|
|
/**
|
|
* Get the nsILoadContextInfo of the cache entry
|
|
*/
|
|
readonly attribute nsILoadContextInfo loadContextInfo;
|
|
|
|
/****************************************************************************
|
|
* 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);
|
|
};
|
|
|
|
/**
|
|
* Argument for nsICacheEntry.visitMetaData, provides access to all metadata
|
|
* keys and values stored on the entry.
|
|
*/
|
|
[scriptable, uuid(fea3e276-6ba5-4ceb-a581-807d1f43f6d0)]
|
|
interface nsICacheEntryMetaDataVisitor : nsISupports
|
|
{
|
|
/**
|
|
* Called over each key / value pair.
|
|
*/
|
|
void onMetaDataElement(in string key, in string value);
|
|
};
|