Debian Codegraph @

closure-library/closure/goog/net/filedownloader.js

raw
1 // Copyright 2011 The Closure Library Authors. All Rights Reserved.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS-IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 /**
16 * @fileoverview A class for downloading remote files and storing them
17 * locally using the HTML5 FileSystem API.
18 *
19 * The directory structure is of the form /HASH/URL/BASENAME:
20 *
21 * The HASH portion is a three-character slice of the hash of the URL. Since the
22 * filesystem has a limit of about 5000 files per directory, this should divide
23 * the downloads roughly evenly among about 5000 directories, thus allowing for
24 * at most 5000^2 downloads.
25 *
26 * The URL portion is the (sanitized) full URL used for downloading the file.
27 * This is used to ensure that each file ends up in a different location, even
28 * if the HASH and BASENAME are the same.
29 *
30 * The BASENAME portion is the basename of the URL. It's used for the filename
31 * proper so that the local filesystem: URL will be downloaded to a file with a
32 * recognizable name.
33 *
34 */
35
36 goog.provide('goog.net.FileDownloader');
37 goog.provide('goog.net.FileDownloader.Error');
38
39 goog.require('goog.Disposable');
40 goog.require('goog.asserts');
41 goog.require('goog.async.Deferred');
42 goog.require('goog.crypt.hash32');
43 goog.require('goog.debug.Error');
44 goog.require('goog.events');
45 goog.require('goog.events.EventHandler');
46 goog.require('goog.fs');
47 goog.require('goog.fs.DirectoryEntry');
48 goog.require('goog.fs.Error');
49 goog.require('goog.fs.FileSaver');
50 goog.require('goog.net.EventType');
51 goog.require('goog.net.XhrIo');
52 goog.require('goog.net.XhrIoPool');
53 goog.require('goog.object');
54
55
56
57 /**
58 * A class for downloading remote files and storing them locally using the
59 * HTML5 filesystem API.
60 *
61 * @param {!goog.fs.DirectoryEntry} dir The directory in which the downloaded
62 * files are stored. This directory should be solely managed by
63 * FileDownloader.
64 * @param {goog.net.XhrIoPool=} opt_pool The pool of XhrIo objects to use for
65 * downloading files.
66 * @constructor
67 * @extends {goog.Disposable}
68 * @final
69 */
70 goog.net.FileDownloader = function(dir, opt_pool) {
71 goog.net.FileDownloader.base(this, 'constructor');
72
73 /**
74 * The directory in which the downloaded files are stored.
75 * @type {!goog.fs.DirectoryEntry}
76 * @private
77 */
78 this.dir_ = dir;
79
80 /**
81 * The pool of XHRs to use for capturing.
82 * @type {!goog.net.XhrIoPool}
83 * @private
84 */
85 this.pool_ = opt_pool || new goog.net.XhrIoPool();
86
87 /**
88 * A map from URLs to active downloads running for those URLs.
89 * @type {!Object<!goog.net.FileDownloader.Download_>}
90 * @private
91 */
92 this.downloads_ = {};
93
94 /**
95 * The handler for URL capturing events.
96 * @type {!goog.events.EventHandler<!goog.net.FileDownloader>}
97 * @private
98 */
99 this.eventHandler_ = new goog.events.EventHandler(this);
100 };
101 goog.inherits(goog.net.FileDownloader, goog.Disposable);
102
103
104 /**
105 * Download a remote file and save its contents to the filesystem. A given file
106 * is uniquely identified by its URL string; this means that the relative and
107 * absolute URLs for a single file are considered different for the purposes of
108 * the FileDownloader.
109 *
110 * Returns a Deferred that will contain the downloaded blob. If there's an error
111 * while downloading the URL, this Deferred will be passed the
112 * {@link goog.net.FileDownloader.Error} object as an errback.
113 *
114 * If a download is already in progress for the given URL, this will return the
115 * deferred blob for that download. If the URL has already been downloaded, this
116 * will fail once it tries to save the downloaded blob.
117 *
118 * When a download is in progress, all Deferreds returned for that download will
119 * be branches of a single parent. If all such branches are cancelled, or if one
120 * is cancelled with opt_deepCancel set, then the download will be cancelled as
121 * well.
122 *
123 * @param {string} url The URL of the file to download.
124 * @return {!goog.async.Deferred} The deferred result blob.
125 */
126 goog.net.FileDownloader.prototype.download = function(url) {
127 if (this.isDownloading(url)) {
128 return this.downloads_[url].deferred.branch(true /* opt_propagateCancel */);
129 }
130
131 var download = new goog.net.FileDownloader.Download_(url, this);
132 this.downloads_[url] = download;
133 this.pool_.getObject(goog.bind(this.gotXhr_, this, download));
134 return download.deferred.branch(true /* opt_propagateCancel */);
135 };
136
137
138 /**
139 * Return a Deferred that will fire once no download is active for a given URL.
140 * If there's no download active for that URL when this is called, the deferred
141 * will fire immediately; otherwise, it will fire once the download is complete,
142 * whether or not it succeeds.
143 *
144 * @param {string} url The URL of the download to wait for.
145 * @return {!goog.async.Deferred} The Deferred that will fire when the download
146 * is complete.
147 */
148 goog.net.FileDownloader.prototype.waitForDownload = function(url) {
149 var deferred = new goog.async.Deferred();
150 if (this.isDownloading(url)) {
151 this.downloads_[url].deferred.addBoth(function() {
152 deferred.callback(null);
153 }, this);
154 } else {
155 deferred.callback(null);
156 }
157 return deferred;
158 };
159
160
161 /**
162 * Returns whether or not there is an active download for a given URL.
163 *
164 * @param {string} url The URL of the download to check.
165 * @return {boolean} Whether or not there is an active download for the URL.
166 */
167 goog.net.FileDownloader.prototype.isDownloading = function(url) {
168 return url in this.downloads_;
169 };
170
171
172 /**
173 * Load a downloaded blob from the filesystem. Will fire a deferred error if the
174 * given URL has not yet been downloaded.
175 *
176 * @param {string} url The URL of the blob to load.
177 * @return {!goog.async.Deferred} The deferred Blob object. The callback will be
178 * passed the blob. If a file API error occurs while loading the blob, that
179 * error will be passed to the errback.
180 */
181 goog.net.FileDownloader.prototype.getDownloadedBlob = function(url) {
182 return this.getFile_(url).addCallback(function(fileEntry) {
183 return fileEntry.file();
184 });
185 };
186
187
188 /**
189 * Get the local filesystem: URL for a downloaded file. This is different from
190 * the blob: URL that's available from getDownloadedBlob(). If the end user
191 * accesses the filesystem: URL, the resulting file's name will be determined by
192 * the download filename as opposed to an arbitrary GUID. In addition, the
193 * filesystem: URL is connected to a filesystem location, so if the download is
194 * removed then that URL will become invalid.
195 *
196 * Warning: in Chrome 12, some filesystem: URLs are opened inline. This means
197 * that e.g. HTML pages given to the user via filesystem: URLs will be opened
198 * and processed by the browser.
199 *
200 * @param {string} url The URL of the file to get the URL of.
201 * @return {!goog.async.Deferred} The deferred filesystem: URL. The callback
202 * will be passed the URL. If a file API error occurs while loading the
203 * blob, that error will be passed to the errback.
204 */
205 goog.net.FileDownloader.prototype.getLocalUrl = function(url) {
206 return this.getFile_(url).addCallback(function(fileEntry) {
207 return fileEntry.toUrl();
208 });
209 };
210
211
212 /**
213 * Return (deferred) whether or not a URL has been downloaded. Will fire a
214 * deferred error if something goes wrong when determining this.
215 *
216 * @param {string} url The URL to check.
217 * @return {!goog.async.Deferred} The deferred boolean. The callback will be
218 * passed the boolean. If a file API error occurs while checking the
219 * existence of the downloaded URL, that error will be passed to the
220 * errback.
221 */
222 goog.net.FileDownloader.prototype.isDownloaded = function(url) {
223 var deferred = new goog.async.Deferred();
224 var blobDeferred = this.getDownloadedBlob(url);
225 blobDeferred.addCallback(function() { deferred.callback(true); });
226 blobDeferred.addErrback(function(err) {
227 if (err.name == goog.fs.Error.ErrorName.NOT_FOUND) {
228 deferred.callback(false);
229 } else {
230 deferred.errback(err);
231 }
232 });
233 return deferred;
234 };
235
236
237 /**
238 * Remove a URL from the FileDownloader.
239 *
240 * This returns a Deferred. If the removal is completed successfully, its
241 * callback will be called without any value. If the removal fails, its errback
242 * will be called with the {@link goog.fs.Error}.
243 *
244 * @param {string} url The URL to remove.
245 * @return {!goog.async.Deferred} The deferred used for registering callbacks on
246 * success or on error.
247 */
248 goog.net.FileDownloader.prototype.remove = function(url) {
249 return this.getDir_(url, goog.fs.DirectoryEntry.Behavior.DEFAULT)
250 .addCallback(function(dir) { return dir.removeRecursively(); });
251 };
252
253
254 /**
255 * Save a blob for a given URL. This works just as through the blob were
256 * downloaded form that URL, except you specify the blob and no HTTP request is
257 * made.
258 *
259 * If the URL is currently being downloaded, it's indeterminate whether the blob
260 * being set or the blob being downloaded will end up in the filesystem.
261 * Whichever one doesn't get saved will have an error. To ensure that one or the
262 * other takes precedence, use {@link #waitForDownload} to allow the download to
263 * complete before setting the blob.
264 *
265 * @param {string} url The URL at which to set the blob.
266 * @param {!Blob} blob The blob to set.
267 * @param {string=} opt_name The name of the file. If this isn't given, it's
268 * determined from the URL.
269 * @return {!goog.async.Deferred} The deferred used for registering callbacks on
270 * success or on error. This can be cancelled just like a {@link #download}
271 * Deferred. The objects passed to the errback will be
272 * {@link goog.net.FileDownloader.Error}s.
273 */
274 goog.net.FileDownloader.prototype.setBlob = function(url, blob, opt_name) {
275 var name = this.sanitize_(opt_name || this.urlToName_(url));
276 var download = new goog.net.FileDownloader.Download_(url, this);
277 this.downloads_[url] = download;
278 download.blob = blob;
279 this.getDir_(download.url, goog.fs.DirectoryEntry.Behavior.CREATE_EXCLUSIVE)
280 .addCallback(function(dir) {
281 return dir.getFile(
282 name, goog.fs.DirectoryEntry.Behavior.CREATE_EXCLUSIVE);
283 })
284 .addCallback(goog.bind(this.fileSuccess_, this, download))
285 .addErrback(goog.bind(this.error_, this, download));
286 return download.deferred.branch(true /* opt_propagateCancel */);
287 };
288
289
290 /**
291 * The callback called when an XHR becomes available from the XHR pool.
292 *
293 * @param {!goog.net.FileDownloader.Download_} download The download object for
294 * this download.
295 * @param {!goog.net.XhrIo} xhr The XhrIo object for downloading the page.
296 * @private
297 */
298 goog.net.FileDownloader.prototype.gotXhr_ = function(download, xhr) {
299 if (download.cancelled) {
300 this.freeXhr_(xhr);
301 return;
302 }
303
304 this.eventHandler_.listen(
305 xhr, goog.net.EventType.SUCCESS,
306 goog.bind(this.xhrSuccess_, this, download));
307 this.eventHandler_.listen(
308 xhr, [goog.net.EventType.ERROR, goog.net.EventType.ABORT],
309 goog.bind(this.error_, this, download));
310 this.eventHandler_.listen(
311 xhr, goog.net.EventType.READY, goog.bind(this.freeXhr_, this, xhr));
312
313 download.xhr = xhr;
314 xhr.setResponseType(goog.net.XhrIo.ResponseType.ARRAY_BUFFER);
315 xhr.send(download.url);
316 };
317
318
319 /**
320 * The callback called when an XHR succeeds in downloading a remote file.
321 *
322 * @param {!goog.net.FileDownloader.Download_} download The download object for
323 * this download.
324 * @private
325 */
326 goog.net.FileDownloader.prototype.xhrSuccess_ = function(download) {
327 if (download.cancelled) {
328 return;
329 }
330
331 var name = this.sanitize_(
332 this.getName_(
333 /** @type {!goog.net.XhrIo} */ (download.xhr)));
334 var resp = /** @type {ArrayBuffer} */ (download.xhr.getResponse());
335 if (!resp) {
336 // This should never happen - it indicates the XHR hasn't completed, has
337 // failed or has been cleaned up. If it does happen (eg. due to a bug
338 // somewhere) we don't want to pass null to getBlob - it's not valid and
339 // triggers a bug in some versions of WebKit causing it to crash.
340 this.error_(download);
341 return;
342 }
343
344 download.blob = goog.fs.getBlob(resp);
345 delete download.xhr;
346
347 this.getDir_(download.url, goog.fs.DirectoryEntry.Behavior.CREATE_EXCLUSIVE)
348 .addCallback(function(dir) {
349 return dir.getFile(
350 name, goog.fs.DirectoryEntry.Behavior.CREATE_EXCLUSIVE);
351 })
352 .addCallback(goog.bind(this.fileSuccess_, this, download))
353 .addErrback(goog.bind(this.error_, this, download));
354 };
355
356
357 /**
358 * The callback called when a file that will be used for saving a file is
359 * successfully opened.
360 *
361 * @param {!goog.net.FileDownloader.Download_} download The download object for
362 * this download.
363 * @param {!goog.fs.FileEntry} file The newly-opened file object.
364 * @private
365 */
366 goog.net.FileDownloader.prototype.fileSuccess_ = function(download, file) {
367 if (download.cancelled) {
368 file.remove();
369 return;
370 }
371
372 download.file = file;
373 file.createWriter()
374 .addCallback(goog.bind(this.fileWriterSuccess_, this, download))
375 .addErrback(goog.bind(this.error_, this, download));
376 };
377
378
379 /**
380 * The callback called when a file writer is successfully created for writing a
381 * file to the filesystem.
382 *
383 * @param {!goog.net.FileDownloader.Download_} download The download object for
384 * this download.
385 * @param {!goog.fs.FileWriter} writer The newly-created file writer object.
386 * @private
387 */
388 goog.net.FileDownloader.prototype.fileWriterSuccess_ = function(
389 download, writer) {
390 if (download.cancelled) {
391 download.file.remove();
392 return;
393 }
394
395 download.writer = writer;
396 writer.write(/** @type {!Blob} */ (download.blob));
397 this.eventHandler_.listenOnce(
398 writer, goog.fs.FileSaver.EventType.WRITE_END,
399 goog.bind(this.writeEnd_, this, download));
400 };
401
402
403 /**
404 * The callback called when file writing ends, whether or not it's successful.
405 *
406 * @param {!goog.net.FileDownloader.Download_} download The download object for
407 * this download.
408 * @private
409 */
410 goog.net.FileDownloader.prototype.writeEnd_ = function(download) {
411 if (download.cancelled || download.writer.getError()) {
412 this.error_(download, download.writer.getError());
413 return;
414 }
415
416 delete this.downloads_[download.url];
417 download.deferred.callback(download.blob);
418 };
419
420
421 /**
422 * The error callback for all asynchronous operations. Ensures that all stages
423 * of a given download are cleaned up, and emits the error event.
424 *
425 * @param {!goog.net.FileDownloader.Download_} download The download object for
426 * this download.
427 * @param {goog.fs.Error=} opt_err The file error object. Only defined if the
428 * error was raised by the file API.
429 * @private
430 */
431 goog.net.FileDownloader.prototype.error_ = function(download, opt_err) {
432 if (download.file) {
433 download.file.remove();
434 }
435
436 if (download.cancelled) {
437 return;
438 }
439
440 delete this.downloads_[download.url];
441 download.deferred.errback(
442 new goog.net.FileDownloader.Error(download, opt_err));
443 };
444
445
446 /**
447 * Abort the download of the given URL.
448 *
449 * @param {!goog.net.FileDownloader.Download_} download The download to abort.
450 * @private
451 */
452 goog.net.FileDownloader.prototype.cancel_ = function(download) {
453 goog.dispose(download);
454 delete this.downloads_[download.url];
455 };
456
457
458 /**
459 * Get the directory for a given URL. If the directory already exists when this
460 * is called, it will contain exactly one file: the downloaded file.
461 *
462 * This not only calls the FileSystem API's getFile method, but attempts to
463 * distribute the files so that they don't overload the filesystem. The spec
464 * says directories can't contain more than 5000 files
465 * (http://www.w3.org/TR/file-system-api/#directories), so this ensures that
466 * each file is put into a subdirectory based on its SHA1 hash.
467 *
468 * All parameters are the same as in the FileSystem API's Entry#getFile method.
469 *
470 * @param {string} url The URL corresponding to the directory to get.
471 * @param {goog.fs.DirectoryEntry.Behavior} behavior The behavior to pass to the
472 * underlying method.
473 * @return {!goog.async.Deferred} The deferred DirectoryEntry object.
474 * @private
475 */
476 goog.net.FileDownloader.prototype.getDir_ = function(url, behavior) {
477 // 3 hex digits provide 16**3 = 4096 different possible dirnames, which is
478 // less than the maximum of 5000 entries. Downloaded files should be
479 // distributed roughly evenly throughout the directories due to the hash
480 // function, allowing many more than 5000 files to be downloaded.
481 //
482 // The leading ` ensures that no illegal dirnames are accidentally used. % was
483 // previously used, but Chrome has a bug (as of 12.0.725.0 dev) where
484 // filenames are URL-decoded before checking their validity, so filenames
485 // containing e.g. '%3f' (the URL-encoding of :, an invalid character) are
486 // rejected.
487 var dirname = '`' +
488 Math.abs(goog.crypt.hash32.encodeString(url))
489 .toString(16)
490 .substring(0, 3);
491
492 return this.dir_.getDirectory(dirname, goog.fs.DirectoryEntry.Behavior.CREATE)
493 .addCallback(function(dir) {
494 return dir.getDirectory(this.sanitize_(url), behavior);
495 }, this);
496 };
497
498
499 /**
500 * Get the file for a given URL. This will only retrieve files that have already
501 * been saved; it shouldn't be used for creating the file in the first place.
502 * This is because the filename isn't necessarily determined by the URL, but by
503 * the headers of the XHR response.
504 *
505 * @param {string} url The URL corresponding to the file to get.
506 * @return {!goog.async.Deferred} The deferred FileEntry object.
507 * @private
508 */
509 goog.net.FileDownloader.prototype.getFile_ = function(url) {
510 return this.getDir_(url, goog.fs.DirectoryEntry.Behavior.DEFAULT)
511 .addCallback(function(dir) {
512 return dir.listDirectory().addCallback(function(files) {
513 goog.asserts.assert(files.length == 1);
514 // If the filesystem somehow gets corrupted and we end up with an
515 // empty directory here, it makes sense to just return the normal
516 // file-not-found error.
517 return files[0] || dir.getFile('file');
518 });
519 });
520 };
521
522
523 /**
524 * Sanitize a string so it can be safely used as a file or directory name for
525 * the FileSystem API.
526 *
527 * @param {string} str The string to sanitize.
528 * @return {string} The sanitized string.
529 * @private
530 */
531 goog.net.FileDownloader.prototype.sanitize_ = function(str) {
532 // Add a prefix, since certain prefixes are disallowed for paths. None of the
533 // disallowed prefixes start with '`'. We use ` rather than % for escaping the
534 // filename due to a Chrome bug (as of 12.0.725.0 dev) where filenames are
535 // URL-decoded before checking their validity, so filenames containing e.g.
536 // '%3f' (the URL-encoding of :, an invalid character) are rejected.
537 return '`' +
538 str.replace(/[\/\\<>:?*"|%`]/g, encodeURIComponent).replace(/%/g, '`');
539 };
540
541
542 /**
543 * Gets the filename specified by the XHR. This first attempts to parse the
544 * Content-Disposition header for a filename and, failing that, falls back on
545 * deriving the filename from the URL.
546 *
547 * @param {!goog.net.XhrIo} xhr The XHR containing the response headers.
548 * @return {string} The filename.
549 * @private
550 */
551 goog.net.FileDownloader.prototype.getName_ = function(xhr) {
552 var disposition = xhr.getResponseHeader('Content-Disposition');
553 var match =
554 disposition && disposition.match(/^attachment *; *filename="(.*)"$/i);
555 if (match) {
556 // The Content-Disposition header allows for arbitrary backslash-escaped
557 // characters (usually " and \). We want to unescape them before using them
558 // in the filename.
559 return match[1].replace(/\\(.)/g, '$1');
560 }
561
562 return this.urlToName_(xhr.getLastUri());
563 };
564
565
566 /**
567 * Extracts the basename from a URL.
568 *
569 * @param {string} url The URL.
570 * @return {string} The basename.
571 * @private
572 */
573 goog.net.FileDownloader.prototype.urlToName_ = function(url) {
574 var segments = url.split('/');
575 return segments[segments.length - 1];
576 };
577
578
579 /**
580 * Remove all event listeners for an XHR and release it back into the pool.
581 *
582 * @param {!goog.net.XhrIo} xhr The XHR to free.
583 * @private
584 */
585 goog.net.FileDownloader.prototype.freeXhr_ = function(xhr) {
586 goog.events.removeAll(xhr);
587 this.pool_.addFreeObject(xhr);
588 };
589
590
591 /** @override */
592 goog.net.FileDownloader.prototype.disposeInternal = function() {
593 delete this.dir_;
594 goog.dispose(this.eventHandler_);
595 delete this.eventHandler_;
596 goog.object.forEach(this.downloads_, function(download) {
597 download.deferred.cancel();
598 }, this);
599 delete this.downloads_;
600 goog.dispose(this.pool_);
601 delete this.pool_;
602
603 goog.net.FileDownloader.base(this, 'disposeInternal');
604 };
605
606
607
608 /**
609 * The error object for FileDownloader download errors.
610 *
611 * @param {!goog.net.FileDownloader.Download_} download The download object for
612 * the download in question.
613 * @param {goog.fs.Error=} opt_fsErr The file error object, if this was a file
614 * error.
615 *
616 * @constructor
617 * @extends {goog.debug.Error}
618 * @final
619 */
620 goog.net.FileDownloader.Error = function(download, opt_fsErr) {
621 goog.net.FileDownloader.Error.base(
622 this, 'constructor', 'Error capturing URL ' + download.url);
623
624 /**
625 * The URL the event relates to.
626 * @type {string}
627 */
628 this.url = download.url;
629
630 if (download.xhr) {
631 this.xhrStatus = download.xhr.getStatus();
632 this.xhrErrorCode = download.xhr.getLastErrorCode();
633 this.message += ': XHR failed with status ' + this.xhrStatus +
634 ' (error code ' + this.xhrErrorCode + ')';
635 } else if (opt_fsErr) {
636 this.fileError = opt_fsErr;
637 this.message += ': file API failed (' + opt_fsErr.message + ')';
638 }
639 };
640 goog.inherits(goog.net.FileDownloader.Error, goog.debug.Error);
641
642
643 /**
644 * The status of the XHR. Only set if the error was caused by an XHR failure.
645 * @type {number|undefined}
646 */
647 goog.net.FileDownloader.Error.prototype.xhrStatus;
648
649
650 /**
651 * The error code of the XHR. Only set if the error was caused by an XHR
652 * failure.
653 * @type {goog.net.ErrorCode|undefined}
654 */
655 goog.net.FileDownloader.Error.prototype.xhrErrorCode;
656
657
658 /**
659 * The file API error. Only set if the error was caused by the file API.
660 * @type {goog.fs.Error|undefined}
661 */
662 goog.net.FileDownloader.Error.prototype.fileError;
663
664
665
666 /**
667 * A struct containing the data for a single download.
668 *
669 * @param {string} url The URL for the file being downloaded.
670 * @param {!goog.net.FileDownloader} downloader The parent FileDownloader.
671 * @extends {goog.Disposable}
672 * @constructor
673 * @private
674 */
675 goog.net.FileDownloader.Download_ = function(url, downloader) {
676 goog.net.FileDownloader.Download_.base(this, 'constructor');
677
678 /**
679 * The URL for the file being downloaded.
680 * @type {string}
681 */
682 this.url = url;
683
684 /**
685 * The Deferred that will be fired when the download is complete.
686 * @type {!goog.async.Deferred}
687 */
688 this.deferred =
689 new goog.async.Deferred(goog.bind(downloader.cancel_, downloader, this));
690
691 /**
692 * Whether this download has been cancelled by the user.
693 * @type {boolean}
694 */
695 this.cancelled = false;
696
697 /**
698 * The XhrIo object for downloading the file. Only set once it's been
699 * retrieved from the pool.
700 * @type {goog.net.XhrIo}
701 */
702 this.xhr = null;
703
704 /**
705 * The name of the blob being downloaded. Only sey once the XHR has completed,
706 * if it completed successfully.
707 * @type {?string}
708 */
709 this.name = null;
710
711 /**
712 * The downloaded blob. Only set once the XHR has completed, if it completed
713 * successfully.
714 * @type {Blob}
715 */
716 this.blob = null;
717
718 /**
719 * The file entry where the blob is to be stored. Only set once it's been
720 * loaded from the filesystem.
721 * @type {goog.fs.FileEntry}
722 */
723 this.file = null;
724
725 /**
726 * The file writer for writing the blob to the filesystem. Only set once it's
727 * been loaded from the filesystem.
728 * @type {goog.fs.FileWriter}
729 */
730 this.writer = null;
731 };
732 goog.inherits(goog.net.FileDownloader.Download_, goog.Disposable);
733
734
735 /** @override */
736 goog.net.FileDownloader.Download_.prototype.disposeInternal = function() {
737 this.cancelled = true;
738 if (this.xhr) {
739 this.xhr.abort();
740 } else if (
741 this.writer &&
742 this.writer.getReadyState() == goog.fs.FileSaver.ReadyState.WRITING) {
743 this.writer.abort();
744 }
745
746 goog.net.FileDownloader.Download_.base(this, 'disposeInternal');
747 };