This section is non-normative.
...
An application cache is a set of cached resources consisting of:
One of more resources (including their out-of-band metadata, such as HTTP headers, if any), identified by URLs, each falling into one (or more) of the following categories:
manifest
attribute.
html
element's manifest
attribute. The
manifest is fetched and processed during the application
cache update process. All the master entries have
the same origin as the manifest.
manifest
attribute but that it doesn't point at this cache's manifest.
A URL in the list can be flagged with multiple different types, and thus an entry can end up being categorized as multiple entries. For example, an entry can be a manifest entry and an explicit entry at the same time, if the manifest is listed within the manifest.
Each application cache has a completeness flag, which is either complete or incomplete.
An application cache group is a group of application caches, identified by the absolute URL of a resource manifest which is used to populate the caches in the group.
An application cache is newer than another if it was created after the other (in other words, application caches in an application cache group have a chronological order).
Only the newest application cache in an application cache group can have its completeness flag set to incomplete, the others are always all complete.
Each application cache group has an update status, which is one of the following: idle, checking, downloading.
A relevant application cache is an application cache that is the newest in its group to be complete.
Each application cache group has a list of pending master
entries. Each entry in this list consists of a resource and a
corresponding Document
object. It is used during the
update process to ensure that new master entries are cached.
An application cache group can be marked as obsolete, meaning that it must be ignored when looking at what application cache groups exist.
A cache host is a Document
or a
SharedWorkerGlobalScope
object. A cache
host can be associated with an application
cache.
A Document
initially is not associated with an
application cache, but can become associated with one
early during the page load process, when steps in the parser and in the navigation sections that cause cache selection to occur.
A SharedWorkerGlobalScope
is can be associated with
an application cache when it is created.
Each cache host has an associated
ApplicationCache
object.
Multiple application caches in different application cache groups can contain the same resource, e.g. if the manifests all reference that resource. If the user agent is to select an application cache from a list of relevant application caches that contain a resource, that the user agent must use the application cache that the user most likely wants to see the resource from, taking into account the following:
This section is non-normative.
This example manifest requires two images and a style sheet to be cached and whitelists a CGI script.
CACHE MANIFEST # the above line is required # this is a comment # there can be as many of these anywhere in the file # they are all ignored # comments can have spaces before them # but must be alone on the line # blank lines are ignored too # these are files that need to be cached they can either be listed # first, or a "CACHE:" header could be put before them, as is done # lower down. images/sound-icon.png images/background.png # note that each file has to be put on its own line # here is a file for the online whitelist -- it isn't cached, and # references to this file will bypass the cache, always hitting the # network (or trying to, if the user is offline). NETWORK: comm.cgi # here is another set of files to cache, this time just the CSS file. CACHE: style/default.css
Manifests must be served using the text/cache-manifest
MIME type. All resources served
using the text/cache-manifest
MIME type must
follow the syntax of application cache manifests, as described in
this section.
An application cache manifest is a text file, whose text is encoded using UTF-8. Data in application cache manifests is line-based. Newlines must be represented by U+000A LINE FEED (LF) characters, U+000D CARRIAGE RETURN (CR) characters, or U+000D CARRIAGE RETURN (CR) U+000A LINE FEED (LF) pairs.
This is a willful double violation of RFC2046. [RFC2046]
The first line of an application cache manifest must consist of the string "CACHE", a single U+0020 SPACE character, the string "MANIFEST", and either a U+0020 SPACE character, a U+0009 CHARACTER TABULATION (tab) character, a U+000A LINE FEED (LF) character, or a U+000D CARRIAGE RETURN (CR) character. The first line may optionally be preceded by a U+FEFF BYTE ORDER MARK (BOM) character. If any other text is found on the first line, it is ignored.
Subsequent lines, if any, must all be one of the following:
Blank lines must consist of zero or more U+0020 SPACE and U+0009 CHARACTER TABULATION (tab) characters only.
Comment lines must consist of zero or more U+0020 SPACE and U+0009 CHARACTER TABULATION (tab) characters, followed by a single U+0023 NUMBER SIGN (#) character, followed by zero or more characters other than U+000A LINE FEED (LF) and U+000D CARRIAGE RETURN (CR) characters.
Comments must be on a line on their own. If they were to be included on a line with a URL, the "#" would be mistaken for part of a fragment identifier.
Section headers change the current section. There are three possible section headers:
CACHE:
FALLBACK:
NETWORK:
Section header lines must consist of zero or more U+0020 SPACE and U+0009 CHARACTER TABULATION (tab) characters, followed by one of the names above (including the U+003A COLON (:) character) followed by zero or more U+0020 SPACE and U+0009 CHARACTER TABULATION (tab) characters.
Ironically, by default, the current section is the explicit section.
The format that data lines must take depends on the current section.
When the current section is the explicit section or the online whitelist section, data lines must consist of zero or more U+0020 SPACE and U+0009 CHARACTER TABULATION (tab) characters, a valid URL identifying a resource other than the manifest itself, and then zero or more U+0020 SPACE and U+0009 CHARACTER TABULATION (tab) characters.
When the current section is the fallback section, data lines must consist of zero or more U+0020 SPACE and U+0009 CHARACTER TABULATION (tab) characters, a valid URL identifying a resource other than the manifest itself, one or more U+0020 SPACE and U+0009 CHARACTER TABULATION (tab) characters, another valid URL identifying a resource other than the manifest itself, and then zero or more U+0020 SPACE and U+0009 CHARACTER TABULATION (tab) characters.
The URLs in data lines can't be empty strings, since those would be relative URLs to the manifest itself. Such lines would be confused with blank or invalid lines, anyway.
Manifests may contain sections more than once. Sections may be empty.
URLs that are to be fallback pages associated with fallback namespaces, and those namespaces themselves, must be given in fallback sections, with the namespace being the first URL of the data line, and the corresponding fallback page being the second URL. All the other pages to be cached must be listed in explicit sections.
Fallback namespaces and fallback entries must have the same origin as the manifest itself.
A fallback namespace must not be listed more than once.
URLs that the user agent is to put into the online whitelist must all be specified in online whitelist sections. (This is needed for any URL that the page is intending to use to communicate back to the server.)
Relative URLs must be given relative to the manifest's own URL.
URLs in manifests must not have fragment identifiers (i.e. the U+0023 NUMBER SIGN character isn't allowed in URLs in manifests).
When a user agent is to parse a manifest, it means that the user agent must run the following steps:
The user agent must decode the byte stream corresponding with the manifest to be parsed, treating it as UTF-8. Bytes or sequences of bytes that are not valid UTF-8 sequences must be interpreted as a U+FFFD REPLACEMENT CHARACTER.
Let base URL be the absolute URL representing the manifest.
Let explicit URLs be an initially empty list of explicit entries.
Let fallback URLs be an initially empty mapping of fallback namespaces to fallback entries.
Let online whitelist URLs be an initially empty list of URLs for a online whitelist.
Let input be the decoded text of the manifest's byte stream.
Let position be a pointer into input, initially pointing at the first character.
If position is pointing at a U+FEFF BYTE ORDER MARK (BOM) character, then advance position to the next character.
If the characters starting from position are "CACHE", followed by a U+0020 SPACE character, followed by "MANIFEST", then advance position to the next character after those. Otherwise, this isn't a cache manifest; abort this algorithm with a failure while checking for the magic signature.
If the character at position is neither a U+0020 SPACE character, a U+0009 CHARACTER TABULATION (tab) character, U+000A LINE FEED (LF) character, nor a U+000D CARRIAGE RETURN (CR) character, then this isn't a cache manifest; abort this algorithm with a failure while checking for the magic signature.
This is a cache manifest. The algorithm cannot fail beyond this point (though bogus lines can get ignored).
Collect a sequence of characters that are not U+000A LINE FEED (LF) or U+000D CARRIAGE RETURN (CR) characters, and ignore those characters. (Extra text on the first line, after the signature, is ignored.)
Let mode be "explicit".
Start of line: If position is past the end of input, then jump to the last step. Otherwise, collect a sequence of characters that are U+000A LINE FEED (LF), U+000D CARRIAGE RETURN (CR), U+0020 SPACE, or U+0009 CHARACTER TABULATION (tab) characters.
Now, collect a sequence of characters that are not U+000A LINE FEED (LF) or U+000D CARRIAGE RETURN (CR) characters, and let the result be line.
Drop any trailing U+0020 SPACE and U+0009 CHARACTER TABULATION (tab) characters at the end of line.
If line is the empty string, then jump back to the step labeled "start of line".
If the first character in line is a U+0023 NUMBER SIGN (#) character, then jump back to the step labeled "start of line".
If line equals "CACHE:" (the word "CACHE" followed by a U+003A COLON (:) character), then set mode to "explicit" and jump back to the step labeled "start of line".
If line equals "FALLBACK:" (the word "FALLBACK" followed by a U+003A COLON (:) character), then set mode to "fallback" and jump back to the step labeled "start of line".
If line equals "NETWORK:" (the word "NETWORK" followed by a U+003A COLON (:) character), then set mode to "online whitelist" and jump back to the step labeled "start of line".
If line ends with a U+003A COLON (:) character, then set mode to "unknown" and jump back to the step labeled "start of line".
This is either a data line or it is syntactically incorrect.
Let position be a pointer into line, initially pointing at the start of the string.
Let tokens be a list of strings, initially empty.
While position doesn't point past the end of line:
Let current token be an empty string.
While position doesn't point past the end of line and the character at position is neither a U+0020 SPACE nor a U+0009 CHARACTER TABULATION (tab) character, add the character at position to current token and advance position to the next character in input.
Add current token to the tokens list.
While position doesn't point past the end of line and the character at position is either a U+0020 SPACE or a U+0009 CHARACTER TABULATION (tab) character, advance position to the next character in input.
Process tokens as follows:
Resolve the first item in tokens, relative to base URL; ignore the rest.
If this fails, then jump back to the step labeled "start of line".
If the resulting absolute URL has a different <scheme> component than the manifest's URL (compared in an ASCII case-insensitive manner), then jump back to the step labeled "start of line".
Drop the <fragment> component of the resulting absolute URL, if it has one.
Add the resulting absolute URL to the explicit URLs.
Let part one be the first token in tokens, and let part two be the second token in tokens.
Resolve part one and part two, relative to base URL.
If either fails, then jump back to the step labeled "start of line".
If the absolute URL corresponding to either part one or part two does not have the same origin as the manifest's URL, then jump back to the step labeled "start of line".
Drop any the <fragment> components of the resulting absolute URLs.
If the absolute URL corresponding to part one is already in the fallback URLs mapping as a fallback namespace, then jump back to the step labeled "start of line".
Otherwise, add the absolute URL corresponding to part one to the fallback URLs mapping as a fallback namespace, mapped to the absolute URL corresponding to part two as the fallback entry.
Resolve the first item in tokens, relative to base URL; ignore the rest.
If this fails, then jump back to the step labeled "start of line".
If the resulting absolute URL has a different <scheme> component than the manifest's URL (compared in an ASCII case-insensitive manner), then jump back to the step labeled "start of line".
Drop the <fragment> component of the resulting absolute URL, if it has one.
Add the resulting absolute URL to the online whitelist URLs.
Do nothing. The line is ignored.
Jump back to the step labeled "start of line". (That step jumps to the next, and last, step when the end of the file is reached.)
Return the explicit URLs list, the fallback URLs mapping, and the online whitelist URLs.
If a resource is listed in the explicit section and matches an entry in the online whitelist, or if a resource matches both an entry in the fallback section and the online whitelist, the resource will taken from the cache, and the online whitelist entry will be ignored.
When the user agent is required (by other parts of this specification) to start the application cache update process for an absolute URL purported to identify a manifest, or for an application cache group, potentially given a particular cache host, and potentially given a new master resource, the user agent must run the following steps:
Atomically, so as to avoid race conditions, perform the following substeps:
Pick the appropriate substeps:
Let manifest URL be that absolute URL.
If there is no application cache group identified by manifest URL, then create a new application cache group identified by manifest URL. Initially, it has no application caches. One will be created later in this algorithm.
Let manifest URL be the absolute URL of the manifest used to identify the application cache group to be updated.
Let cache group be the application cache group identified by manifest URL.
If these steps were invoked with a new master resource, then add
the resource, along with the resource's Document
, to
cache group's list of pending master
entries.
If these steps were invoked with a cache
host, and the status of cache group is checking or
downloading, then queue a task to fire
a simple event called checking
at the
ApplicationCache
singleton of that cache
host.
If these steps were invoked with a cache
host, and the status of cache group is downloading, then also
queue a task to fire a simple event
called downloading
at the
ApplicationCache
singleton of that cache
host.
If the status of the cache group is either checking or downloading, then abort this instance of the update process, as an update is already in progress for them.
Set the status of cache group to checking.
For each cache host associated with an
application cache in cache
group, queue a task to fire a simple
event called checking
at the ApplicationCache
singleton of the cache
host. The default action of these events should be the
display of some sort of user interface indicating to the user
that the user agent is checking for the availability of
updates.
The remainder of the steps run asynchronously.
If cache group already has an application cache in it, then this is an upgrade attempt. Otherwise, this is a cache attempt.
If this is a cache
attempt, then this algorithm was invoked with a cache
host; queue a task to fire a simple
event called checking
at
the ApplicationCache
singleton of that cache
host.
Fetching the manifest: Fetch the resource from manifest URL, and let manifest be that resource.
If the resource is labeled with the MIME type text/cache-manifest
, parse manifest according to the rules for parsing manifests, obtaining a list of
explicit entries,
fallback entries
and the fallback
namespaces that map to them, and entries for the online
whitelist.
If fetching the manifest fails due to a 404 or 410 response or equivalent, then run these substeps:
Mark cache group as obsolete. This cache group no longer exists for any purpose other
than the processing of Document
objects already
associated with an application cache in the cache group.
For each cache host associated with an
application cache in cache
group, queue a task to fire a simple
event called obsolete
at the ApplicationCache
singleton of the cache
host. The default action of these events should be the
display of some sort of user interface indicating to the user
that the application is no longer available for offline
use.
For each entry in cache group's list of pending master
entries, queue a task to fire a simple
event called error
(not
obsolete
!) at the
ApplicationCache
singleton of the cache
host the Document
for this entry, if there
still is one. The default action of this event should be the
display of some sort of user interface indicating to the user
that the user agent failed to save the application for offline
use.
If cache group has an application cache whose completeness flag is incomplete, then discard that application cache.
If appropriate, remove any user interface indicating that an update for this cache is in progress.
Let the status of cache group be idle.
Abort the update process.
Otherwise, if fetching the manifest fails in some other
way (e.g. the server returns another 4xx or 5xx response or equivalent, or
there is a DNS error, or the connection times out, or the user
cancels the download, or the parser for manifests fails when
checking the magic signature), or if the server returned a
redirect, or if the resource is labeled with a MIME type other
than text/cache-manifest
, then run the
cache failure steps.
If this is an upgrade attempt and the newly downloaded manifest is byte-for-byte identical to the manifest found in the newest application cache in cache group, or the server reported it as "304 Not Modified" or equivalent, then run these substeps:
Let cache be the newest application cache in cache group.
For each entry in cache group's list of pending master entries, wait for the resource for this entry to have either completely downloaded or failed.
If the download failed (e.g. the connection times out, or the
user cancels the download), then queue a task to
fire a simple event called error
at the
ApplicationCache
singleton of the cache
host the Document
for this entry, if there
still is one. The default action of this event should be the
display of some sort of user interface indicating to the user
that the user agent failed to save the application for offline
use.
Otherwise, associate the Document
for this entry
with cache; store the resource for this
entry in cache, if it isn't already there,
and categorize its entry as a master entry.
HTTP caching rules, such as Cache-Control: no-store
, are ignored for the
purposes of the application cache update
process.
For each cache host associated with an
application cache in cache
group, queue a task to fire a simple
event called noupdate
at the ApplicationCache
singleton of the cache
host. The default action of these events should be the
display of some sort of user interface indicating to the user
that the application is up to date.
Empty cache group's list of pending master entries.
If appropriate, remove any user interface indicating that an update for this cache is in progress.
Let the status of cache group be idle.
Abort the update process.
Let new cache be a newly created application cache in cache group. Set its completeness flag to incomplete.
For each entry in cache group's list of pending master
entries, associate the Document
for this entry
with new cache.
Set the status of cache group to downloading.
For each cache host associated with an
application cache in cache group,
queue a task to fire a simple event
called downloading
at the
ApplicationCache
singleton of the cache
host. The default action of these events should be the
display of some sort of user interface indicating to the user that
a new version is being downloaded.
Let file list be an empty list of URLs with flags.
Add all the URLs in the list of explicit entries obtained by parsing manifest to file list, each flagged with "explicit entry".
Add all the URLs in the list of fallback entries obtained by parsing manifest to file list, each flagged with "fallback entry".
If this is an upgrade attempt, then add all the URLs of master entries in the newest application cache in cache group whose completeness flag is complete to file list, each flagged with "master entry".
If any URL is in file list more than once, then merge the entries into one entry for that URL, that entry having all the flags that the original entries had.
For each URL in file list, run the following steps. These steps may be run in parallel for two or more of the URLs at a time.
If the resource URL being processed was flagged as neither an "explicit entry" nor or a "fallback entry", then the user agent may skip this URL.
This is intended to allow user agents to expire resources not listed in the manifest (other than those in the manifest itself) from the cache. Generally, implementors are urged to use an approach that expires lesser-used resources first.
For each cache host associated with an
application cache in cache
group, queue a task to fire a simple
event called progress
at the ApplicationCache
singleton of the cache
host. The default action of these events should be the
display of some sort of user interface indicating to the user
that a file is being downloaded in preparation for updating the
application.
Fetch the resource. If this is an upgrade attempt, then use the newest application cache in cache group as an HTTP cache, and honor HTTP caching semantics (such as expiration, ETags, and so forth) with respect to that cache. User agents may also have other caches in place that are also honored.
If the resource in question is already being downloaded for other reasons then the existing download process can be used for the purposes of this step, as defined by the fetching algorithm.
An example of a resource that might already
be being downloaded is a large image on a Web page that is being
seen for the first time. The image would get downloaded to
satisfy the img
element on the page, as well as
being listed in the cache manifest. According to the rules for
fetching that image only need be
downloaded once, and it can be used both for the cache and for
the rendered Web page.
If the previous step fails (e.g. the server returns a 4xx or 5xx response or equivalent, or there is a DNS error, or the connection times out, or the user cancels the download), or if the server returned a redirect, then run the first appropriate step from the following list:
Run the cache failure steps.
Redirects are fatal because they are either indicative of a network problem (e.g. a captive portal); or would allow resources to be added to the cache under URLs that differ from any URL that the networking model will allow access to, leaving orphan entries; or would allow resources to be stored under URLs different than their true URLs. All of these situations are bad.
Skip this resource. It is dropped from the cache.
Copy the resource and its metadata from the newest application cache in cache group whose completeness flag is complete, and act as if that was the fetched resource, ignoring the resource obtained from the network.
User agents may warn the user of these errors as an aid to development.
These rules make errors for resources listed in the manifest fatal, while making it possible for other resources to be removed from caches when they are removed from the server, without errors, and making non-manifest resources survive server-side errors.
Otherwise, the fetching succeeded. Store the resource in the new cache.
If the URL being processed was flagged as an "explicit entry" in file list, then categorize the entry as an explicit entry.
If the URL being processed was flagged as a "fallback entry" in file list, then categorize the entry as a fallback entry.
If the URL being processed was flagged as an "master entry" in file list, then categorize the entry as a master entry.
As an optimization, if the resource is an HTML or XML file
whose root element is an html
element with a manifest
attribute whose value
doesn't match the manifest URL of the application cache being
processed, then the user agent should mark the entry as being
foreign.
Store the list of fallback namespaces, and the URLs of the fallback entries that they map to, in new cache.
Store the URLs that form the new online whitelist in new cache.
For each entry in cache group's list of pending master entries, wait for the resource for this entry to have either completely downloaded or failed.
If the download failed (e.g. the connection times out, or the user cancels the download), then run these substeps:
Unassociate the Document
for this entry from
new cache.
Queue a task to fire a simple
event called error
at the
ApplicationCache
singleton of the
Document
for this entry, if there still is one. The
default action of this event should be the display of some sort
of user interface indicating to the user that the user agent
failed to save the application for offline use.
If this is a cache attempt and this entry is the last entry in cache group's list of pending master entries, then run these further substeps:
Discard cache group and its only application cache, new cache.
If appropriate, remove any user interface indicating that an update for this cache is in progress.
Abort the update process.
Otherwise, remove this entry from cache group's list of pending master entries.
Otherwise, store the resource for this entry in new cache, if it isn't already there, and categorize its entry as a master entry.
Fetch the resource from manifest URL again, and let second manifest be that resource.
If the previous step failed for any reason, or if the fetching attempt involved a redirect, or if second manifest and manifest are not byte-for-byte identical, then schedule a rerun of the entire algorithm with the same parameters after a short delay, and run the cache failure steps.
Otherwise, store manifest in new cache, if it's not there already, and categorize its entry as the manifest.
Set the completeness flag of new cache to complete.
If this is a cache
attempt, then for each cache host associated
with an application cache in cache
group, queue a task to fire a simple
event called cached
at
the ApplicationCache
singleton of the cache
host. The default action of these events should be the
display of some sort of user interface indicating to the user that
the application has been cached and that they can now use it
offline.
Otherwise, it is an upgrade attempt. For each
cache host associated with an application
cache in cache group, queue a
task to fire a simple event called updateready
at the
ApplicationCache
singleton of the cache
host. The default action of these events should be the
display of some sort of user interface indicating to the user that
a new version is available and that they can activate it by
reloading the page.
If appropriate, remove any user interface indicating that an update for this cache is in progress.
Set the update status of cache group to idle.
The cache failure steps are as follows:
For each entry in cache group's list of pending master entries, run the following further substeps. These steps may be run in parallel for two or more entries at a time.
Wait for the resource for this entry to have either completely downloaded or failed.
Unassociate the Document
for this entry from
its application cache, if it has one.
Queue a task to fire a simple
event called error
at the
ApplicationCache
singleton of the
Document
for this entry, if there still is one. The
default action of these events should be the display of some sort
of user interface indicating to the user that the user agent
failed to save the application for offline use.
For each cache host still associated with an
application cache in cache group,
queue a task to fire a simple event
called error
at the
ApplicationCache
singleton of the cache
host. The default action of these events should be the
display of some sort of user interface indicating to the user that
the user agent failed to save the application for offline
use.
Empty cache group's list of pending master entries.
If cache group has an application cache whose completeness flag is incomplete, then discard that application cache.
If appropriate, remove any user interface indicating that an update for this cache is in progress.
Let the status of cache group be idle.
If this was a cache attempt, discard cache group altogether.
Abort the update process.
Attempts to fetch resources as part of the application cache update process may be done with cache-defeating semantics, to avoid problems with stale or inconsistent intermediary caches.
User agents may invoke the application cache update process, in the background, for any application cache, at any time (with no cache host). This allows user agents to keep caches primed and to update caches even before the user visits a site.
A URL matches a fallback namespace if there exists a relevant application cache whose manifest's URL has the same origin as the URL in question, and that has a fallback namespace that is a prefix match for the URL being examined. If multiple fallback namespaces match the same URL, the longest one is the one that matches. A URL looking for an fallback namespace can match more than one application cache at a time, but only matches one namespace in each cache.
If a manifest http://example.com/app1/manifest
declares that
http://example.com/resources/images
is a
fallback namespace, and the user navigates to HTTP://EXAMPLE.COM:80/resources/images/cat.png
,
then the user agent will decide that the application cache
identified by http://example.com/app1/manifest
contains a
namespace with a match for that URL.
When the application cache
selection algorithm algorithm is invoked with a
Document
document and optionally a
manifest URL manifest URL, the user
agent must run the first applicable set of steps from the following
list:
Mark the entry for the resource from which document was taken in the application cache from which it was loaded as foreign.
Restart the current navigation from the top of the navigation algorithm, undoing any changes that were made as part of the initial load (changes can be avoided by ensuring that the step to update the session history with the new page is only ever completed after this application cache selection algorithm is run, though this is not required).
The navigation will not result in the same resource being loaded, because "foreign" entries are never picked during navigation.
User agents may notify the user of the inconsistency between the cache manifest and the document's own metadata, to aid in application development.
Associate document with the application cache from which it was loaded. Invoke the application cache update process for that cache and with the browsing context being navigated.
Invoke the application cache update process for manifest URL, with the browsing context being navigated, and with document and the resource from which document was loaded as the new master resource.
The Document
is not associated with any
application cache.
If there was a manifest URL, the user agent may report to the user that it was ignored, to aid in application development.
When a cache host is associated with an application cache whose completeness flag is complete, any and all loads for resources related to that cache host other than those for child browsing contexts must go through the following steps instead of immediately invoking the mechanisms appropriate to that resource's scheme:
If the resource is not to be fetched using the HTTP GET
mechanism or
equivalent, or if it has a javascript:
URL, then
fetch the resource normally and abort these
steps.
If the resource's URL is a master entry, the manifest, an explicit entry, or a fallback entry in the application cache, then get the resource from the cache (instead of fetching it), and abort these steps.
If the resource's URL has the same origin as the manifest's URL, and there is a fallback namespace in the application cache that is a prefix match for the resource's URL, then:
Fetch the resource normally. If this results in a redirect to a resource with another origin (indicative of a captive portal), or a 4xx or 5xx status code or equivalent, or if there were network errors (but not if the user canceled the download), then instead get, from the cache, the resource of the fallback entry corresponding to the matched namespace. Abort these steps.
If there is an entry in the application cache's online whitelist that has the same origin as the resource's URL and that is a prefix match for the resource's URL, then fetch the resource normally and abort these steps.
Fail the resource load.
The above algorithm ensures that resources that are not present in the manifest will always fail to load (at least, after the application cache has been primed the first time), making the testing of offline applications simpler.
interface ApplicationCache { // update status const unsigned short UNCACHED = 0; const unsigned short IDLE = 1; const unsigned short CHECKING = 2; const unsigned short DOWNLOADING = 3; const unsigned short UPDATEREADY = 4; const unsigned short OBSOLETE = 5; readonly attribute unsigned short status; // updates void update(); void swapCache(); // events attribute Function onchecking; attribute Function onerror; attribute Function onnoupdate; attribute Function ondownloading; attribute Function onprogress; attribute Function onupdateready; attribute Function oncached; attribute Function onobsolete; };
applicationCache
(In a window.) Returns the ApplicationCache
object that applies to the active document of that Window
.
applicationCache
(In a shared worker.) Returns the ApplicationCache
object that applies to the current shared worker.
status
Returns the current status of the application cache, as given by the constants defined below.
update
()Invokes the application cache update process.
Throws an INVALID_ACCESS_ERR
exception if there is no application cache to update.
swapCache
()Switches to the most recent application cache, if there is a newer one. If there isn't, throws an INVALID_ACCESS_ERR
exception.
Objects implementing the ApplicationCache
interface
must also implement the EventTarget
interface.
There is a one-to-one mapping from cache
hosts to ApplicationCache
objects. The applicationCache
attribute on Window
objects must return the
ApplicationCache
object associated with the
Window
object's active document. The applicationCache
attribute on SharedWorkerGlobalScope
objects must
return the ApplicationCache
object associated with the
worker.
The status
attribute, on getting, must return the current state of the
application cache that the
ApplicationCache
object's cache host is
associated with, if any. This must be the appropriate value from the
following list:
UNCACHED
(numeric value 0)The ApplicationCache
object's cache
host is not associated with an application
cache at this time.
IDLE
(numeric value 1)The ApplicationCache
object's cache
host is associated with an application cache
whose application cache group's update status is
idle, and that application cache is the newest cache in its
application cache group, and the application
cache group is not marked as obsolete.
CHECKING
(numeric value 2)The ApplicationCache
object's cache
host is associated with an application cache
whose application cache group's update status is
checking.
DOWNLOADING
(numeric value 3)The ApplicationCache
object's cache
host is associated with an application cache
whose application cache group's update status is
downloading.
UPDATEREADY
(numeric value 4)The ApplicationCache
object's cache
host is associated with an application cache
whose application cache group's update status is
idle, and whose application cache group is not
marked as obsolete,
but that application cache is not the newest cache in its
group.
OBSOLETE
(numeric value 5)The ApplicationCache
object's cache
host is associated with an application cache
whose application cache group is marked as obsolete.
If the update()
method is
invoked, the user agent must invoke the application cache
update process, in the background, for the application
cache with which the ApplicationCache
object's
cache host is associated, but without giving that
cache host to the algorithm. If there is no such
application cache, or if it is marked as obsolete, then the method
must raise an INVALID_STATE_ERR
exception instead.
If the swapCache()
method
is invoked, the user agent must run the following steps:
Check that ApplicationCache
object's
cache host is associated with an application
cache. If it is not, then raise an
INVALID_STATE_ERR
exception and abort these
steps.
Let cache be the application
cache with which the ApplicationCache
object's
cache host is associated. (By definition, this is the
same as the one that was found in the previous step.)
If cache's application cache
group is marked as obsolete, then unassociate
the ApplicationCache
object's cache host
from cache and abort these steps. (Resources
will now load from the network instead of the cache.)
Check that there is an application cache in the same
application cache group as cache
whose completeness
flag is complete and that is newer than cache. If there is not, then raise an
INVALID_STATE_ERR
exception and abort these
steps.
Let new cache be the newest application cache in the same application cache group as cache whose completeness flag is complete.
Unassociate the ApplicationCache
object's
cache host from cache and instead
associate it with new cache.
The following are the event handler attributes (and
their corresponding event
handler event types) that must be supported, as DOM
attributes, by all objects implementing the
ApplicationCache
interface:
event handler attribute | Event handler event type |
---|---|
onchecking | checking
|
onerror | error
|
onnoupdate | noupdate
|
ondownloading | downloading
|
onprogress | progress
|
onupdateready | updateready
|
oncached | cached
|
onobsolete | obsolete
|
navigator
. onLine
Returns false if the user agent is definitely offline (disconnected from the network). Returns true if the user agent might be online.
The navigator.onLine
attribute must return false if the user agent will not contact the
network when the user follows links or when a script requests a
remote page (or knows that such an attempt would fail), and must
return true otherwise.
When the value that would be returned by the navigator.onLine
attribute of
the Window
changes from true to false, the user agent
must fire a simple event called offline
at the
Window
object.
On the other hand, when the value that would be returned by the
navigator.onLine
attribute
of the Window
changes from false to true, the user
agent must fire a simple event called online
at the
Window
object.
This attribute is inherently unreliable. A computer can be connected to a network without having Internet access.