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.

Mercurial (d96ee8115c5a)

VCS Links

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 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292
/* -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* 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 mozIDOMWindow;
interface nsIURI;
interface nsIDOMNode;
interface nsIDOMDocument;
interface nsIOfflineCacheUpdate;
interface nsIPrincipal;
interface nsIPrefBranch;
interface nsIApplicationCache;
interface nsIFile;
interface nsIObserver;

[scriptable, uuid(47360d57-8ef4-4a5d-8865-1a27a739ad1a)]
interface nsIOfflineCacheUpdateObserver : nsISupports {
  const unsigned long STATE_ERROR = 1;
  const unsigned long STATE_CHECKING = 2;
  const unsigned long STATE_NOUPDATE = 3;
  const unsigned long STATE_OBSOLETE = 4;
  const unsigned long STATE_DOWNLOADING = 5;
  const unsigned long STATE_ITEMSTARTED = 6;
  const unsigned long STATE_ITEMCOMPLETED = 7;
  const unsigned long STATE_ITEMPROGRESS = 8;
  const unsigned long STATE_FINISHED = 10;

  /**
   * aUpdate has changed its state.
   *
   * @param aUpdate
   *        The nsIOfflineCacheUpdate being processed.
   * @param event
   *        See enumeration above
   */
  void updateStateChanged(in nsIOfflineCacheUpdate aUpdate, in uint32_t state);

  /**
   * Informs the observer about an application being available to associate.
   *
   * @param applicationCache
   *        The application cache instance that has been created or found by the 
   *        update to associate with
   */
  void applicationCacheAvailable(in nsIApplicationCache applicationCache);
};

/**
 * An nsIOfflineCacheUpdate is used to update an application's offline
 * resources.
 *
 * It can be used to perform partial or complete updates.
 *
 * One update object will be updating at a time.  The active object will
 * load its items one by one, sending itemCompleted() to any registered
 * observers.
 */
[scriptable, uuid(6e3e26ea-45b2-4db7-9e4a-93b965679298)]
interface nsIOfflineCacheUpdate : nsISupports {
  /**
   * Fetch the status of the running update.  This will return a value
   * defined in nsIDOMOfflineResourceList.
   */
  readonly attribute unsigned short status;

  /**
   * TRUE if the update is being used to add specific resources.
   * FALSE if the complete cache update process is happening.
   */
  readonly attribute boolean partial;

  /**
   * TRUE if this is an upgrade attempt, FALSE if it is a new cache
   * attempt.
   */
  readonly attribute boolean isUpgrade;

  /**
   * The domain being updated, and the domain that will own any URIs added
   * with this update.
   */
  readonly attribute ACString updateDomain;

  /**
   * The manifest for the offline application being updated.
   */
  readonly attribute nsIURI manifestURI;

  /**
   * TRUE if the cache update completed successfully.
   */
  readonly attribute boolean succeeded;

  /**
   * Initialize the update.
   *
   * @param aManifestURI
   *        The manifest URI to be checked.
   * @param aDocumentURI
   *        The page that is requesting the update.
   * @param aLoadingPrincipal
   *        The principal of the page that is requesting the update.
   */
  void init(in nsIURI aManifestURI,
            in nsIURI aDocumentURI,
            in nsIPrincipal aLoadingPrincipal,
            in nsIDOMDocument aDocument,
            [optional] in nsIFile aCustomProfileDir);

  /**
   * Initialize the update for partial processing. 
   *
   * @param aManifestURI
   *        The manifest URI of the related cache.
   * @param aClientID
   *        Client  ID of the cache to store resource to. This ClientID
   *        must be ID of cache in the cache group identified by
   *        the manifest URI passed in the first parameter.
   * @param aDocumentURI
   *        The page that is requesting the update. May be null 
   *        when this information is unknown.
   */
  void initPartial(in nsIURI aManifestURI, in ACString aClientID,
                   in nsIURI aDocumentURI, in nsIPrincipal aPrincipal);

  /**
   * Initialize the update to only check whether there is an update
   * to the manifest available (if it has actually changed on the server).
   *
   * @param aManifestURI
   *        The manifest URI of the related cache.
   * @param aObserver
   *        nsIObserver implementation that receives the result.
   *        When aTopic == "offline-cache-update-available" there is an update to
   *        to download. Update of the app cache will lead to a new version
   *        download.
   *        When aTopic == "offline-cache-update-unavailable" then there is no
   *        update available (the manifest has not changed on the server).
   */
  void initForUpdateCheck(in nsIURI aManifestURI,
                          in nsIPrincipal aLoadingPrincipal,
                          in nsIObserver aObserver);

  /**
   * Add a dynamic URI to the offline cache as part of the update.
   *
   * @param aURI
   *        The URI to add.
   */
  void addDynamicURI(in nsIURI aURI);

  /**
   * Add the update to the offline update queue.  An offline-cache-update-added
   * event will be sent to the observer service.
   */
  void schedule();

  /**
   * Observe loads that are added to the update.
   *
   * @param aObserver
   *        object that notifications will be sent to.
   * @param aHoldWeak
   *        TRUE if you want the update to hold a weak reference to the
   *        observer, FALSE for a strong reference.
   */
  void addObserver(in nsIOfflineCacheUpdateObserver aObserver,
                   [optional] in boolean aHoldWeak);

  /**
   * Remove an observer from the update.
   *
   * @param aObserver
   *        the observer to remove.
   */
  void removeObserver(in nsIOfflineCacheUpdateObserver aObserver);

  /**
   * Cancel the update when still in progress. This stops all running resource
   * downloads and discards the downloaded cache version. Throws when update
   * has already finished and made the new cache version active.
   */
  void cancel();

  /**
   * Return the number of bytes downloaded so far
   */
  readonly attribute uint64_t byteProgress;
};

[scriptable, uuid(44971e74-37e4-4140-8677-a4cf213a3f4b)]
interface nsIOfflineCacheUpdateService : nsISupports {
    /**
     * Constants for the offline-app permission.
     *
     * XXX: This isn't a great place for this, but it's really the only
     * private offline-app-related interface
     */

    /**
     * Allow the domain to use offline APIs, and don't warn about excessive
     * usage.
     */
    const unsigned long ALLOW_NO_WARN = 3;

    /**
     * Access to the list of cache updates that have been scheduled.
     */
    readonly attribute unsigned long numUpdates;
    nsIOfflineCacheUpdate getUpdate(in unsigned long index);

    /**
     * Schedule a cache update for a given offline manifest.  If an
     * existing update is scheduled or running, that update will be returned.
     * Otherwise a new update will be scheduled.
     */
    nsIOfflineCacheUpdate scheduleUpdate(in nsIURI aManifestURI,
                                         in nsIURI aDocumentURI,
                                         in nsIPrincipal aLoadingPrincipal,
                                         in mozIDOMWindow aWindow);

    /**
     * Schedule a cache update for a given offline manifest using app cache
     * bound to the given appID+inIsolatedMozBrowser flag.  If an existing update
     * is scheduled or running, that update will be returned. Otherwise a new
     * update will be scheduled.
     */
    nsIOfflineCacheUpdate scheduleAppUpdate(in nsIURI aManifestURI,
                                            in nsIURI aDocumentURI,
                                            in nsIPrincipal aLoadingPrincipal,
                                            in nsIFile aProfileDir);

    /**
     * Schedule a cache update for a manifest when the document finishes
     * loading.
     */
    void scheduleOnDocumentStop(in nsIURI aManifestURI,
                                in nsIURI aDocumentURI,
                                in nsIPrincipal aLoadingPrincipal,
                                in nsIDOMDocument aDocument);

    /**
     * Schedule a check to see if an update is available.
     *
     * This will not update or make any changes to the appcache.
     * It only notifies the observer to indicate whether the manifest has
     * changed on the server (or not): a changed manifest means that an
     * update is available.
     *
     * For arguments see nsIOfflineCacheUpdate.initForUpdateCheck() method
     * description.
     */
    void checkForUpdate(in nsIURI aManifestURI,
                        in nsIPrincipal aLoadingPrincipal,
                        in nsIObserver aObserver);

    /**
     * Checks whether a principal should have access to the offline
     * cache.
     * @param aPrincipal
     *        The principal to check.
     * @param aPrefBranch
     *        The pref branch to use to check the
     *        offline-apps.allow_by_default pref.  If not specified,
     *        the pref service will be used.
     */
    boolean offlineAppAllowed(in nsIPrincipal aPrincipal,
                              in nsIPrefBranch aPrefBranch);

    /**
     * Checks whether a document at the given URI should have access
     * to the offline cache.
     * @param aURI
     *        The URI to check
     * @param aPrefBranch
     *        The pref branch to use to check the
     *        offline-apps.allow_by_default pref.  If not specified,
     *        the pref service will be used.
     */
    boolean offlineAppAllowedForURI(in nsIURI aURI,
                                    in nsIPrefBranch aPrefBranch);

    /**
     * Sets the "offline-app" permission for the principal.
     * In the single process model calls directly on permission manager.
     * In the multi process model dispatches to the parent process.
     */
    void allowOfflineApp(in nsIPrincipal aPrincipal);
};