goog.net.FileDownloader

Invokes a callback function when this object is disposed. Callbacks are invoked in the order in which they were added. If a callback is added to an already disposed Disposable, it will be called immediately.

Disposes of the object and its resources.

Performs appropriate cleanup. See description of goog.disposable.IDisposable for examples. Classes that extend goog.Disposable should override this method. Not reentrant. To avoid calling it twice, it must only be called from the subclass' disposeInternal method. Everywhere else the public dispose method must be used. For example:

 mypackage.MyClass = function() {
 mypackage.MyClass.base(this, 'constructor');
     // Constructor logic specific to MyClass.
     ...
   };
   goog.inherits(mypackage.MyClass, goog.Disposable);

   mypackage.MyClass.prototype.disposeInternal = function() {
     // Dispose logic specific to MyClass.
     ...
     // Call superclass's disposeInternal at the end of the subclass's, like
     // in C++, to avoid hard-to-catch issues.
     mypackage.MyClass.base(this, 'disposeInternal');
   };
 

Download a remote file and save its contents to the filesystem. A given file is uniquely identified by its URL string; this means that the relative and absolute URLs for a single file are considered different for the purposes of the FileDownloader.

Returns a Deferred that will contain the downloaded blob. If there's an error while downloading the URL, this Deferred will be passed the goog.net.FileDownloader.Error object as an errback.

If a download is already in progress for the given URL, this will return the deferred blob for that download. If the URL has already been downloaded, this will fail once it tries to save the downloaded blob.

When a download is in progress, all Deferreds returned for that download will be branches of a single parent. If all such branches are cancelled, or if one is cancelled with opt_deepCancel set, then the download will be cancelled as well.

Load a downloaded blob from the filesystem. Will fire a deferred error if the given URL has not yet been downloaded.

Get the local filesystem: URL for a downloaded file. This is different from the blob: URL that's available from getDownloadedBlob(). If the end user accesses the filesystem: URL, the resulting file's name will be determined by the download filename as opposed to an arbitrary GUID. In addition, the filesystem: URL is connected to a filesystem location, so if the download is removed then that URL will become invalid.

Warning: in Chrome 12, some filesystem: URLs are opened inline. This means that e.g. HTML pages given to the user via filesystem: URLs will be opened and processed by the browser.

Return (deferred) whether or not a URL has been downloaded. Will fire a deferred error if something goes wrong when determining this.

Returns whether or not there is an active download for a given URL.

Associates a disposable object with this object so that they will be disposed together.

Remove a URL from the FileDownloader.

This returns a Deferred. If the removal is completed successfully, its callback will be called without any value. If the removal fails, its errback will be called with the goog.fs.Error.

Save a blob for a given URL. This works just as through the blob were downloaded form that URL, except you specify the blob and no HTTP request is made.

If the URL is currently being downloaded, it's indeterminate whether the blob being set or the blob being downloaded will end up in the filesystem. Whichever one doesn't get saved will have an error. To ensure that one or the other takes precedence, use #waitForDownload to allow the download to complete before setting the blob.

Return a Deferred that will fire once no download is active for a given URL. If there's no download active for that URL when this is called, the deferred will fire immediately; otherwise, it will fire once the download is complete, whether or not it succeeds.

If monitoring the goog.Disposable instances is enabled, stores the creation stack trace of the Disposable instance.