The Tor Browser: toolkit/mozapps/downloads/nsHelperAppDlg.js@6474c204b198 (annotated)

toolkit/mozapps/downloads/nsHelperAppDlg.js@6474c204b198 (annotated)

toolkit/mozapps/downloads/nsHelperAppDlg.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- Mode: javascript; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2; js-indent-level: 2; -*- */
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /*
 # 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/.
 */
 Components.utils.import("resource://gre/modules/Services.jsm");
 ///////////////////////////////////////////////////////////////////////////////
 //// Helper Functions
 /**
  * Determines if a given directory is able to be used to download to.
  *
  * @param aDirectory
  *        The directory to check.
  * @return true if we can use the directory, false otherwise.
  */
 function isUsableDirectory(aDirectory)
 {
   return aDirectory.exists() && aDirectory.isDirectory() &&
          aDirectory.isWritable();
 }
 // Web progress listener so we can detect errors while mLauncher is
 // streaming the data to a temporary file.
 function nsUnknownContentTypeDialogProgressListener(aHelperAppDialog) {
   this.helperAppDlg = aHelperAppDialog;
 }
 nsUnknownContentTypeDialogProgressListener.prototype = {
   // nsIWebProgressListener methods.
   // Look for error notifications and display alert to user.
   onStatusChange: function( aWebProgress, aRequest, aStatus, aMessage ) {
     if ( aStatus != Components.results.NS_OK ) {
       // Display error alert (using text supplied by back-end).
       // FIXME this.dialog is undefined?
       Services.prompt.alert( this.dialog, this.helperAppDlg.mTitle, aMessage );
       // Close the dialog.
       this.helperAppDlg.onCancel();
       if ( this.helperAppDlg.mDialog ) {
         this.helperAppDlg.mDialog.close();
       }
     }
   },
   // Ignore onProgressChange, onProgressChange64, onStateChange, onLocationChange, onSecurityChange, and onRefreshAttempted notifications.
   onProgressChange: function( aWebProgress,
                               aRequest,
                               aCurSelfProgress,
                               aMaxSelfProgress,
                               aCurTotalProgress,
                               aMaxTotalProgress ) {
   },
   onProgressChange64: function( aWebProgress,
                                 aRequest,
                                 aCurSelfProgress,
                                 aMaxSelfProgress,
                                 aCurTotalProgress,
                                 aMaxTotalProgress ) {
   },
   onStateChange: function( aWebProgress, aRequest, aStateFlags, aStatus ) {
   },
   onLocationChange: function( aWebProgress, aRequest, aLocation, aFlags ) {
   },
   onSecurityChange: function( aWebProgress, aRequest, state ) {
   },
   onRefreshAttempted: function( aWebProgress, aURI, aDelay, aSameURI ) {
     return true;
   }
 };
 ///////////////////////////////////////////////////////////////////////////////
 //// nsUnknownContentTypeDialog
 /* This file implements the nsIHelperAppLauncherDialog interface.
  *
  * The implementation consists of a JavaScript "class" named nsUnknownContentTypeDialog,
  * comprised of:
  *   - a JS constructor function
  *   - a prototype providing all the interface methods and implementation stuff
  *
  * In addition, this file implements an nsIModule object that registers the
  * nsUnknownContentTypeDialog component.
  */
 const PREF_BD_USEDOWNLOADDIR = "browser.download.useDownloadDir";
 const nsITimer = Components.interfaces.nsITimer;
 let downloadModule = {};
 Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
 Components.utils.import("resource://gre/modules/DownloadLastDir.jsm", downloadModule);
 Components.utils.import("resource://gre/modules/DownloadPaths.jsm");
 Components.utils.import("resource://gre/modules/DownloadUtils.jsm");
 Components.utils.import("resource://gre/modules/Downloads.jsm");
 Components.utils.import("resource://gre/modules/FileUtils.jsm");
 Components.utils.import("resource://gre/modules/Task.jsm");
 /* ctor
  */
 function nsUnknownContentTypeDialog() {
   // Initialize data properties.
   this.mLauncher = null;
   this.mContext  = null;
   this.chosenApp = null;
   this.givenDefaultApp = false;
   this.updateSelf = true;
   this.mTitle    = "";
 }
 nsUnknownContentTypeDialog.prototype = {
   classID: Components.ID("{F68578EB-6EC2-4169-AE19-8C6243F0ABE1}"),
   nsIMIMEInfo  : Components.interfaces.nsIMIMEInfo,
   QueryInterface: function (iid) {
     if (!iid.equals(Components.interfaces.nsIHelperAppLauncherDialog) &&
         !iid.equals(Components.interfaces.nsITimerCallback) &&
         !iid.equals(Components.interfaces.nsISupports)) {
       throw Components.results.NS_ERROR_NO_INTERFACE;
     }
     return this;
   },
   // ---------- nsIHelperAppLauncherDialog methods ----------
   // show: Open XUL dialog using window watcher.  Since the dialog is not
   //       modal, it needs to be a top level window and the way to open
   //       one of those is via that route).
   show: function(aLauncher, aContext, aReason)  {
     this.mLauncher = aLauncher;
     this.mContext  = aContext;
     const nsITimer = Components.interfaces.nsITimer;
     this._showTimer = Components.classes["@mozilla.org/timer;1"]
                                 .createInstance(nsITimer);
     this._showTimer.initWithCallback(this, 0, nsITimer.TYPE_ONE_SHOT);
   },
   // When opening from new tab, if tab closes while dialog is opening,
   // (which is a race condition on the XUL file being cached and the timer
   // in nsExternalHelperAppService), the dialog gets a blur and doesn't
   // activate the OK button.  So we wait a bit before doing opening it.
   reallyShow: function() {
     try {
       var ir = this.mContext.QueryInterface(Components.interfaces.nsIInterfaceRequestor);
       var dwi = ir.getInterface(Components.interfaces.nsIDOMWindow);
       var ww = Components.classes["@mozilla.org/embedcomp/window-watcher;1"]
                          .getService(Components.interfaces.nsIWindowWatcher);
       this.mDialog = ww.openWindow(dwi,
                                    "chrome://mozapps/content/downloads/unknownContentType.xul",
                                    null,
                                    "chrome,centerscreen,titlebar,dialog=yes,dependent",
                                    null);
     } catch (ex) {
       // The containing window may have gone away.  Break reference
       // cycles and stop doing the download.
       this.mLauncher.cancel(Components.results.NS_BINDING_ABORTED);
       return;
     }
     // Hook this object to the dialog.
     this.mDialog.dialog = this;
     // Hook up utility functions.
     this.getSpecialFolderKey = this.mDialog.getSpecialFolderKey;
     // Watch for error notifications.
     var progressListener = new nsUnknownContentTypeDialogProgressListener(this);
     this.mLauncher.setWebProgressListener(progressListener);
   },
   //
   // displayBadPermissionAlert()
   //
   // Diplay an alert panel about the bad permission of folder/directory.
   //
   displayBadPermissionAlert: function () {
     let bundle =
       Services.strings.createBundle("chrome://mozapps/locale/downloads/unknownContentType.properties");
     Services.prompt.alert(this.dialog,
                    bundle.GetStringFromName("badPermissions.title"),
                    bundle.GetStringFromName("badPermissions"));
   },
   // promptForSaveToFile:  Display file picker dialog and return selected file.
   //                       This is called by the External Helper App Service
   //                       after the ucth dialog calls |saveToDisk| with a null
   //                       target filename (no target, therefore user must pick).
   //
   //                       Alternatively, if the user has selected to have all
   //                       files download to a specific location, return that
   //                       location and don't ask via the dialog.
   //
   // Note - this function is called without a dialog, so it cannot access any part
   // of the dialog XUL as other functions on this object do.
   promptForSaveToFile: function(aLauncher, aContext, aDefaultFile, aSuggestedFileExtension, aForcePrompt) {
     throw new Components.Exception("Async version must be used", Components.results.NS_ERROR_NOT_AVAILABLE);
   },
   promptForSaveToFileAsync: function(aLauncher, aContext, aDefaultFile, aSuggestedFileExtension, aForcePrompt) {
     var result = null;
     this.mLauncher = aLauncher;
     let prefs = Components.classes["@mozilla.org/preferences-service;1"]
                           .getService(Components.interfaces.nsIPrefBranch);
     let bundle =
       Services.strings
               .createBundle("chrome://mozapps/locale/downloads/unknownContentType.properties");
     Task.spawn(function() {
       if (!aForcePrompt) {
         // Check to see if the user wishes to auto save to the default download
         // folder without prompting. Note that preference might not be set.
         let autodownload = false;
         try {
           autodownload = prefs.getBoolPref(PREF_BD_USEDOWNLOADDIR);
         } catch (e) { }
         if (autodownload) {
           // Retrieve the user's default download directory
           let preferredDir = yield Downloads.getPreferredDownloadsDirectory();
           let defaultFolder = new FileUtils.File(preferredDir);
           try {
             result = this.validateLeafName(defaultFolder, aDefaultFile, aSuggestedFileExtension);
           }
           catch (ex) {
             // When the default download directory is write-protected,
             // prompt the user for a different target file.
           }
           // Check to make sure we have a valid directory, otherwise, prompt
           if (result) {
             // This path is taken when we have a writable default download directory.
             aLauncher.saveDestinationAvailable(result);
             return;
           }
         }
       }
       // Use file picker to show dialog.
       var nsIFilePicker = Components.interfaces.nsIFilePicker;
       var picker = Components.classes["@mozilla.org/filepicker;1"].createInstance(nsIFilePicker);
       var windowTitle = bundle.GetStringFromName("saveDialogTitle");
       var parent = aContext.QueryInterface(Components.interfaces.nsIInterfaceRequestor).getInterface(Components.interfaces.nsIDOMWindow);
       picker.init(parent, windowTitle, nsIFilePicker.modeSave);
       picker.defaultString = aDefaultFile;
       let gDownloadLastDir = new downloadModule.DownloadLastDir(parent);
       if (aSuggestedFileExtension) {
         // aSuggestedFileExtension includes the period, so strip it
         picker.defaultExtension = aSuggestedFileExtension.substring(1);
       }
       else {
         try {
           picker.defaultExtension = this.mLauncher.MIMEInfo.primaryExtension;
         }
         catch (ex) { }
       }
       var wildCardExtension = "*";
       if (aSuggestedFileExtension) {
         wildCardExtension += aSuggestedFileExtension;
         picker.appendFilter(this.mLauncher.MIMEInfo.description, wildCardExtension);
       }
       picker.appendFilters( nsIFilePicker.filterAll );
       // Default to lastDir if it is valid, otherwise use the user's default
       // downloads directory.  getPreferredDownloadsDirectory should always
       // return a valid directory path, so we can safely default to it.
       let preferredDir = yield Downloads.getPreferredDownloadsDirectory();
       picker.displayDirectory = new FileUtils.File(preferredDir);
       gDownloadLastDir.getFileAsync(aLauncher.source, function LastDirCallback(lastDir) {
         if (lastDir && isUsableDirectory(lastDir))
           picker.displayDirectory = lastDir;
         if (picker.show() == nsIFilePicker.returnCancel) {
           // null result means user cancelled.
           aLauncher.saveDestinationAvailable(null);
           return;
         }
         // Be sure to save the directory the user chose through the Save As...
         // dialog  as the new browser.download.dir since the old one
         // didn't exist.
         result = picker.file;
         if (result) {
           try {
             // Remove the file so that it's not there when we ensure non-existence later;
             // this is safe because for the file to exist, the user would have had to
             // confirm that he wanted the file overwritten.
             if (result.exists())
               result.remove(false);
           }
           catch (ex) {
             // As it turns out, the failure to remove the file, for example due to
             // permission error, will be handled below eventually somehow.
           }
           var newDir = result.parent.QueryInterface(Components.interfaces.nsILocalFile);
           // Do not store the last save directory as a pref inside the private browsing mode
           gDownloadLastDir.setFile(aLauncher.source, newDir);
           try {
             result = this.validateLeafName(newDir, result.leafName, null);
           }
           catch (ex) {
             // When the chosen download directory is write-protected,
             // display an informative error message.
             // In all cases, download will be stopped.
             if (ex.result == Components.results.NS_ERROR_FILE_ACCESS_DENIED) {
               this.displayBadPermissionAlert();
               aLauncher.saveDestinationAvailable(null);
               return;
             }
           }
         }
         aLauncher.saveDestinationAvailable(result);
       }.bind(this));
     }.bind(this)).then(null, Components.utils.reportError);
   },
   /**
    * Ensures that a local folder/file combination does not already exist in
    * the file system (or finds such a combination with a reasonably similar
    * leaf name), creates the corresponding file, and returns it.
    *
    * @param   aLocalFolder
    *          the folder where the file resides
    * @param   aLeafName
    *          the string name of the file (may be empty if no name is known,
    *          in which case a name will be chosen)
    * @param   aFileExt
    *          the extension of the file, if one is known; this will be ignored
    *          if aLeafName is non-empty
    * @return  nsILocalFile
    *          the created file
    * @throw   an error such as permission doesn't allow creation of
    *          file, etc.
    */
   validateLeafName: function (aLocalFolder, aLeafName, aFileExt)
   {
     if (!(aLocalFolder && isUsableDirectory(aLocalFolder))) {
       throw new Components.Exception("Destination directory non-existing or permission error",
                                      Components.results.NS_ERROR_FILE_ACCESS_DENIED);
     }
     // Remove any leading periods, since we don't want to save hidden files
     // automatically.
     aLeafName = aLeafName.replace(/^\.+/, "");
     if (aLeafName == "")
       aLeafName = "unnamed" + (aFileExt ? "." + aFileExt : "");
     aLocalFolder.append(aLeafName);
     // The following assignment can throw an exception, but
     // is now caught properly in the caller of validateLeafName.
     var createdFile = DownloadPaths.createNiceUniqueFile(aLocalFolder);
 #ifdef XP_WIN
     let ext;
     try {
       // We can fail here if there's no primary extension set
       ext = "." + this.mLauncher.MIMEInfo.primaryExtension;
     } catch (e) { }
     // Append a file extension if it's an executable that doesn't have one
     // but make sure we actually have an extension to add
     let leaf = createdFile.leafName;
     if (ext && leaf.slice(-ext.length) != ext && createdFile.isExecutable()) {
       createdFile.remove(false);
       aLocalFolder.leafName = leaf + ext;
       createdFile = DownloadPaths.createNiceUniqueFile(aLocalFolder);
     }
 #endif
     return createdFile;
   },
   // ---------- implementation methods ----------
   // initDialog:  Fill various dialog fields with initial content.
   initDialog : function() {
     // Put file name in window title.
     var suggestedFileName = this.mLauncher.suggestedFileName;
     // Some URIs do not implement nsIURL, so we can't just QI.
     var url = this.mLauncher.source;
     if (url instanceof Components.interfaces.nsINestedURI)
       url = url.innermostURI;
     var fname = "";
     var iconPath = "goat";
     this.mSourcePath = url.prePath;
     if (url instanceof Components.interfaces.nsIURL) {
       // A url, use file name from it.
       fname = iconPath = url.fileName;
       this.mSourcePath += url.directory;
     } else {
       // A generic uri, use path.
       fname = url.path;
       this.mSourcePath += url.path;
     }
     if (suggestedFileName)
       fname = iconPath = suggestedFileName;
     var displayName = fname.replace(/ +/g, " ");
     this.mTitle = this.dialogElement("strings").getFormattedString("title", [displayName]);
     this.mDialog.document.title = this.mTitle;
     // Put content type, filename and location into intro.
     this.initIntro(url, fname, displayName);
     var iconString = "moz-icon://" + iconPath + "?size=16&contentType=" + this.mLauncher.MIMEInfo.MIMEType;
     this.dialogElement("contentTypeImage").setAttribute("src", iconString);
     // if always-save and is-executable and no-handler
     // then set up simple ui
     var mimeType = this.mLauncher.MIMEInfo.MIMEType;
     var shouldntRememberChoice = (mimeType == "application/octet-stream" ||
                                   mimeType == "application/x-msdownload" ||
                                   this.mLauncher.targetFileIsExecutable);
     if (shouldntRememberChoice && !this.openWithDefaultOK()) {
       // hide featured choice
       this.dialogElement("normalBox").collapsed = true;
       // show basic choice
       this.dialogElement("basicBox").collapsed = false;
       // change button labels and icons; use "save" icon for the accept
       // button since it's the only action possible
       let acceptButton = this.mDialog.document.documentElement
                                               .getButton("accept");
       acceptButton.label = this.dialogElement("strings")
                                .getString("unknownAccept.label");
       acceptButton.setAttribute("icon", "save");
       this.mDialog.document.documentElement.getButton("cancel").label = this.dialogElement("strings").getString("unknownCancel.label");
       // hide other handler
       this.dialogElement("openHandler").collapsed = true;
       // set save as the selected option
       this.dialogElement("mode").selectedItem = this.dialogElement("save");
     }
     else {
       this.initAppAndSaveToDiskValues();
       // Initialize "always ask me" box. This should always be disabled
       // and set to true for the ambiguous type application/octet-stream.
       // We don't also check for application/x-msdownload here since we
       // want users to be able to autodownload .exe files.
       var rememberChoice = this.dialogElement("rememberChoice");
 #if 0
       // Just because we have a content-type of application/octet-stream
       // here doesn't actually mean that the content is of that type. Many
       // servers default to sending text/plain for file types they don't know
       // about. To account for this, the uriloader does some checking to see
       // if a file sent as text/plain contains binary characters, and if so (*)
       // it morphs the content-type into application/octet-stream so that
       // the file can be properly handled. Since this is not generic binary
       // data, rather, a data format that the system probably knows about,
       // we don't want to use the content-type provided by this dialog's
       // opener, as that's the generic application/octet-stream that the
       // uriloader has passed, rather we want to ask the MIME Service.
       // This is so we don't needlessly disable the "autohandle" checkbox.
       // commented out to close the opening brace in the if statement.
       // var mimeService = Components.classes["@mozilla.org/mime;1"].getService(Components.interfaces.nsIMIMEService);
       // var type = mimeService.getTypeFromURI(this.mLauncher.source);
       // this.realMIMEInfo = mimeService.getFromTypeAndExtension(type, "");
       // if (type == "application/octet-stream") {
 #endif
       if (shouldntRememberChoice) {
         rememberChoice.checked = false;
         rememberChoice.disabled = true;
       }
       else {
         rememberChoice.checked = !this.mLauncher.MIMEInfo.alwaysAskBeforeHandling &&
                                  this.mLauncher.MIMEInfo.preferredAction != this.nsIMIMEInfo.handleInternally;
       }
       this.toggleRememberChoice(rememberChoice);
       // XXXben - menulist won't init properly, hack.
       var openHandler = this.dialogElement("openHandler");
       openHandler.parentNode.removeChild(openHandler);
       var openHandlerBox = this.dialogElement("openHandlerBox");
       openHandlerBox.appendChild(openHandler);
     }
     this.mDialog.setTimeout("dialog.postShowCallback()", 0);
     let acceptDelay = Services.prefs.getIntPref("security.dialog_enable_delay");
     this.mDialog.document.documentElement.getButton("accept").disabled = true;
     this._showTimer = Components.classes["@mozilla.org/timer;1"]
                                 .createInstance(nsITimer);
     this._showTimer.initWithCallback(this, acceptDelay, nsITimer.TYPE_ONE_SHOT);
   },
   notify: function (aTimer) {
     if (aTimer == this._showTimer) {
       if (!this.mDialog) {
         this.reallyShow();
       } else {
         // The user may have already canceled the dialog.
         try {
           if (!this._blurred) {
             this.mDialog.document.documentElement.getButton("accept").disabled = false;
           }
         } catch (ex) {}
         this._delayExpired = true;
       }
       // The timer won't release us, so we have to release it.
       this._showTimer = null;
     }
     else if (aTimer == this._saveToDiskTimer) {
       // Since saveToDisk may open a file picker and therefore block this routine,
       // we should only call it once the dialog is closed.
       this.mLauncher.saveToDisk(null, false);
       this._saveToDiskTimer = null;
     }
   },
   postShowCallback: function () {
     this.mDialog.sizeToContent();
     // Set initial focus
     this.dialogElement("mode").focus();
   },
   // initIntro:
   initIntro: function(url, filename, displayname) {
     this.dialogElement( "location" ).value = displayname;
     this.dialogElement( "location" ).setAttribute("realname", filename);
     this.dialogElement( "location" ).setAttribute("tooltiptext", displayname);
     // if mSourcePath is a local file, then let's use the pretty path name
     // instead of an ugly url...
     var pathString;
     if (url instanceof Components.interfaces.nsIFileURL) {
       try {
         // Getting .file might throw, or .parent could be null
         pathString = url.file.parent.path;
       } catch (ex) {}
     }
     if (!pathString) {
       // wasn't a fileURL
       var tmpurl = url.clone(); // don't want to change the real url
       try {
         tmpurl.userPass = "";
       } catch (ex) {}
       pathString = tmpurl.prePath;
     }
     // Set the location text, which is separate from the intro text so it can be cropped
     var location = this.dialogElement( "source" );
     location.value = pathString;
     location.setAttribute("tooltiptext", this.mSourcePath);
     // Show the type of file.
     var type = this.dialogElement("type");
     var mimeInfo = this.mLauncher.MIMEInfo;
     // 1. Try to use the pretty description of the type, if one is available.
     var typeString = mimeInfo.description;
     if (typeString == "") {
       // 2. If there is none, use the extension to identify the file, e.g. "ZIP file"
       var primaryExtension = "";
       try {
         primaryExtension = mimeInfo.primaryExtension;
       }
       catch (ex) {
       }
       if (primaryExtension != "")
         typeString = this.dialogElement("strings").getFormattedString("fileType", [primaryExtension.toUpperCase()]);
       // 3. If we can't even do that, just give up and show the MIME type.
       else
         typeString = mimeInfo.MIMEType;
     }
     // When the length is unknown, contentLength would be -1
     if (this.mLauncher.contentLength >= 0) {
       let [size, unit] = DownloadUtils.
                          convertByteUnits(this.mLauncher.contentLength);
       type.value = this.dialogElement("strings")
                        .getFormattedString("orderedFileSizeWithType",
                                            [typeString, size, unit]);
     }
     else {
       type.value = typeString;
     }
   },
   _blurred: false,
   _delayExpired: false,
   onBlur: function(aEvent) {
     this._blurred = true;
     this.mDialog.document.documentElement.getButton("accept").disabled = true;
   },
   onFocus: function(aEvent) {
     this._blurred = false;
     if (this._delayExpired) {
       var script = "document.documentElement.getButton('accept').disabled = false";
       this.mDialog.setTimeout(script, 250);
     }
   },
   // Returns true if opening the default application makes sense.
   openWithDefaultOK: function() {
     // The checking is different on Windows...
 #ifdef XP_WIN
     // Windows presents some special cases.
     // We need to prevent use of "system default" when the file is
     // executable (so the user doesn't launch nasty programs downloaded
     // from the web), and, enable use of "system default" if it isn't
     // executable (because we will prompt the user for the default app
     // in that case).
     //  Default is Ok if the file isn't executable (and vice-versa).
     return !this.mLauncher.targetFileIsExecutable;
 #else
     // On other platforms, default is Ok if there is a default app.
     // Note that nsIMIMEInfo providers need to ensure that this holds true
     // on each platform.
     return this.mLauncher.MIMEInfo.hasDefaultHandler;
 #endif
   },
   // Set "default" application description field.
   initDefaultApp: function() {
     // Use description, if we can get one.
     var desc = this.mLauncher.MIMEInfo.defaultDescription;
     if (desc) {
       var defaultApp = this.dialogElement("strings").getFormattedString("defaultApp", [desc]);
       this.dialogElement("defaultHandler").label = defaultApp;
     }
     else {
       this.dialogElement("modeDeck").setAttribute("selectedIndex", "1");
       // Hide the default handler item too, in case the user picks a
       // custom handler at a later date which triggers the menulist to show.
       this.dialogElement("defaultHandler").hidden = true;
     }
   },
   // getPath:
   getPath: function (aFile) {
 #ifdef XP_MACOSX
     return aFile.leafName || aFile.path;
 #else
     return aFile.path;
 #endif
   },
   // initAppAndSaveToDiskValues:
   initAppAndSaveToDiskValues: function() {
     var modeGroup = this.dialogElement("mode");
     // We don't let users open .exe files or random binary data directly
     // from the browser at the moment because of security concerns.
     var openWithDefaultOK = this.openWithDefaultOK();
     var mimeType = this.mLauncher.MIMEInfo.MIMEType;
     if (this.mLauncher.targetFileIsExecutable || (
       (mimeType == "application/octet-stream" ||
        mimeType == "application/x-msdownload") &&
         !openWithDefaultOK)) {
       this.dialogElement("open").disabled = true;
       var openHandler = this.dialogElement("openHandler");
       openHandler.disabled = true;
       openHandler.selectedItem = null;
       modeGroup.selectedItem = this.dialogElement("save");
       return;
     }
     // Fill in helper app info, if there is any.
     try {
       this.chosenApp =
         this.mLauncher.MIMEInfo.preferredApplicationHandler
                                .QueryInterface(Components.interfaces.nsILocalHandlerApp);
     } catch (e) {
       this.chosenApp = null;
     }
     // Initialize "default application" field.
     this.initDefaultApp();
     var otherHandler = this.dialogElement("otherHandler");
     // Fill application name textbox.
     if (this.chosenApp && this.chosenApp.executable &&
         this.chosenApp.executable.path) {
       otherHandler.setAttribute("path",
                                 this.getPath(this.chosenApp.executable));
       otherHandler.label = this.getFileDisplayName(this.chosenApp.executable);
       otherHandler.hidden = false;
     }
     var useDefault = this.dialogElement("useSystemDefault");
     var openHandler = this.dialogElement("openHandler");
     openHandler.selectedIndex = 0;
     if (this.mLauncher.MIMEInfo.preferredAction == this.nsIMIMEInfo.useSystemDefault) {
       // Open (using system default).
       modeGroup.selectedItem = this.dialogElement("open");
     } else if (this.mLauncher.MIMEInfo.preferredAction == this.nsIMIMEInfo.useHelperApp) {
       // Open with given helper app.
       modeGroup.selectedItem = this.dialogElement("open");
       openHandler.selectedIndex = 1;
     } else {
       // Save to disk.
       modeGroup.selectedItem = this.dialogElement("save");
     }
     // If we don't have a "default app" then disable that choice.
     if (!openWithDefaultOK) {
       var useDefault = this.dialogElement("defaultHandler");
       var isSelected = useDefault.selected;
       // Disable that choice.
       useDefault.hidden = true;
       // If that's the default, then switch to "save to disk."
       if (isSelected) {
         openHandler.selectedIndex = 1;
         modeGroup.selectedItem = this.dialogElement("save");
       }
     }
     otherHandler.nextSibling.hidden = otherHandler.nextSibling.nextSibling.hidden = false;
     this.updateOKButton();
   },
   // Returns the user-selected application
   helperAppChoice: function() {
     return this.chosenApp;
   },
   get saveToDisk() {
     return this.dialogElement("save").selected;
   },
   get useOtherHandler() {
     return this.dialogElement("open").selected && this.dialogElement("openHandler").selectedIndex == 1;
   },
   get useSystemDefault() {
     return this.dialogElement("open").selected && this.dialogElement("openHandler").selectedIndex == 0;
   },
   toggleRememberChoice: function (aCheckbox) {
     this.dialogElement("settingsChange").hidden = !aCheckbox.checked;
     this.mDialog.sizeToContent();
   },
   openHandlerCommand: function () {
     var openHandler = this.dialogElement("openHandler");
     if (openHandler.selectedItem.id == "choose")
       this.chooseApp();
     else
       openHandler.setAttribute("lastSelectedItemID", openHandler.selectedItem.id);
   },
   updateOKButton: function() {
     var ok = false;
     if (this.dialogElement("save").selected) {
       // This is always OK.
       ok = true;
     }
     else if (this.dialogElement("open").selected) {
       switch (this.dialogElement("openHandler").selectedIndex) {
       case 0:
         // No app need be specified in this case.
         ok = true;
         break;
       case 1:
         // only enable the OK button if we have a default app to use or if
         // the user chose an app....
         ok = this.chosenApp || /\S/.test(this.dialogElement("otherHandler").getAttribute("path"));
         break;
       }
     }
     // Enable Ok button if ok to press.
     this.mDialog.document.documentElement.getButton("accept").disabled = !ok;
   },
   // Returns true iff the user-specified helper app has been modified.
   appChanged: function() {
     return this.helperAppChoice() != this.mLauncher.MIMEInfo.preferredApplicationHandler;
   },
   updateMIMEInfo: function() {
     // Don't update mime type preferences when the preferred action is set to
     // the internal handler -- this dialog is the result of the handler fallback
     // (e.g. Content-Disposition was set as attachment)
     var discardUpdate = this.mLauncher.MIMEInfo.preferredAction == this.nsIMIMEInfo.handleInternally &&
                         !this.dialogElement("rememberChoice").checked;
     var needUpdate = false;
     // If current selection differs from what's in the mime info object,
     // then we need to update.
     if (this.saveToDisk) {
       needUpdate = this.mLauncher.MIMEInfo.preferredAction != this.nsIMIMEInfo.saveToDisk;
       if (needUpdate)
         this.mLauncher.MIMEInfo.preferredAction = this.nsIMIMEInfo.saveToDisk;
     }
     else if (this.useSystemDefault) {
       needUpdate = this.mLauncher.MIMEInfo.preferredAction != this.nsIMIMEInfo.useSystemDefault;
       if (needUpdate)
         this.mLauncher.MIMEInfo.preferredAction = this.nsIMIMEInfo.useSystemDefault;
     }
     else {
       // For "open with", we need to check both preferred action and whether the user chose
       // a new app.
       needUpdate = this.mLauncher.MIMEInfo.preferredAction != this.nsIMIMEInfo.useHelperApp || this.appChanged();
       if (needUpdate) {
         this.mLauncher.MIMEInfo.preferredAction = this.nsIMIMEInfo.useHelperApp;
         // App may have changed - Update application
         var app = this.helperAppChoice();
         this.mLauncher.MIMEInfo.preferredApplicationHandler = app;
       }
     }
     // We will also need to update if the "always ask" flag has changed.
     needUpdate = needUpdate || this.mLauncher.MIMEInfo.alwaysAskBeforeHandling != (!this.dialogElement("rememberChoice").checked);
     // One last special case: If the input "always ask" flag was false, then we always
     // update.  In that case we are displaying the helper app dialog for the first
     // time for this mime type and we need to store the user's action in the mimeTypes.rdf
     // data source (whether that action has changed or not; if it didn't change, then we need
     // to store the "always ask" flag so the helper app dialog will or won't display
     // next time, per the user's selection).
     needUpdate = needUpdate || !this.mLauncher.MIMEInfo.alwaysAskBeforeHandling;
     // Make sure mime info has updated setting for the "always ask" flag.
     this.mLauncher.MIMEInfo.alwaysAskBeforeHandling = !this.dialogElement("rememberChoice").checked;
     return needUpdate && !discardUpdate;
   },
   // See if the user changed things, and if so, update the
   // mimeTypes.rdf entry for this mime type.
   updateHelperAppPref: function() {
     var ha = new this.mDialog.HelperApps();
     ha.updateTypeInfo(this.mLauncher.MIMEInfo);
     ha.destroy();
   },
   // onOK:
   onOK: function() {
     // Verify typed app path, if necessary.
     if (this.useOtherHandler) {
       var helperApp = this.helperAppChoice();
       if (!helperApp || !helperApp.executable ||
           !helperApp.executable.exists()) {
         // Show alert and try again.
         var bundle = this.dialogElement("strings");
         var msg = bundle.getFormattedString("badApp", [this.dialogElement("otherHandler").getAttribute("path")]);
         Services.prompt.alert(this.mDialog, bundle.getString("badApp.title"), msg);
         // Disable the OK button.
         this.mDialog.document.documentElement.getButton("accept").disabled = true;
         this.dialogElement("mode").focus();
         // Clear chosen application.
         this.chosenApp = null;
         // Leave dialog up.
         return false;
       }
     }
     // Remove our web progress listener (a progress dialog will be
     // taking over).
     this.mLauncher.setWebProgressListener(null);
     // saveToDisk and launchWithApplication can return errors in
     // certain circumstances (e.g. The user clicks cancel in the
     // "Save to Disk" dialog. In those cases, we don't want to
     // update the helper application preferences in the RDF file.
     try {
       var needUpdate = this.updateMIMEInfo();
       if (this.dialogElement("save").selected) {
         // If we're using a default download location, create a path
         // for the file to be saved to to pass to |saveToDisk| - otherwise
         // we must ask the user to pick a save name.
 #if 0
         var prefs = Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefBranch);
         var targetFile = null;
         try {
           targetFile = prefs.getComplexValue("browser.download.defaultFolder",
                                              Components.interfaces.nsILocalFile);
           var leafName = this.dialogElement("location").getAttribute("realname");
           // Ensure that we don't overwrite any existing files here.
           targetFile = this.validateLeafName(targetFile, leafName, null);
         }
         catch(e) { }
         this.mLauncher.saveToDisk(targetFile, false);
 #endif
         // see @notify
         // we cannot use opener's setTimeout, see bug 420405
         this._saveToDiskTimer = Components.classes["@mozilla.org/timer;1"]
                                           .createInstance(nsITimer);
         this._saveToDiskTimer.initWithCallback(this, 0,
                                                nsITimer.TYPE_ONE_SHOT);
       }
       else
         this.mLauncher.launchWithApplication(null, false);
       // Update user pref for this mime type (if necessary). We do not
       // store anything in the mime type preferences for the ambiguous
       // type application/octet-stream. We do NOT do this for
       // application/x-msdownload since we want users to be able to
       // autodownload these to disk.
       if (needUpdate && this.mLauncher.MIMEInfo.MIMEType != "application/octet-stream")
         this.updateHelperAppPref();
     } catch(e) { }
     // Unhook dialog from this object.
     this.mDialog.dialog = null;
     // Close up dialog by returning true.
     return true;
   },
   // onCancel:
   onCancel: function() {
     // Remove our web progress listener.
     this.mLauncher.setWebProgressListener(null);
     // Cancel app launcher.
     try {
       this.mLauncher.cancel(Components.results.NS_BINDING_ABORTED);
     } catch(exception) {
     }
     // Unhook dialog from this object.
     this.mDialog.dialog = null;
     // Close up dialog by returning true.
     return true;
   },
   // dialogElement:  Convenience.
   dialogElement: function(id) {
     return this.mDialog.document.getElementById(id);
   },
   // Retrieve the pretty description from the file
   getFileDisplayName: function getFileDisplayName(file)
   {
 #ifdef XP_WIN
     if (file instanceof Components.interfaces.nsILocalFileWin) {
       try {
         return file.getVersionInfoField("FileDescription");
       } catch (e) {}
     }
 #endif
 #ifdef XP_MACOSX
     if (file instanceof Components.interfaces.nsILocalFileMac) {
       try {
         return file.bundleDisplayName;
       } catch (e) {}
     }
 #endif
     return file.leafName;
   },
   // chooseApp:  Open file picker and prompt user for application.
   chooseApp: function() {
 #ifdef XP_WIN
     // Protect against the lack of an extension
     var fileExtension = "";
     try {
       fileExtension = this.mLauncher.MIMEInfo.primaryExtension;
     } catch(ex) {
     }
     // Try to use the pretty description of the type, if one is available.
     var typeString = this.mLauncher.MIMEInfo.description;
     if (!typeString) {
       // If there is none, use the extension to
       // identify the file, e.g. "ZIP file"
       if (fileExtension) {
         typeString =
           this.dialogElement("strings").
           getFormattedString("fileType", [fileExtension.toUpperCase()]);
       } else {
         // If we can't even do that, just give up and show the MIME type.
         typeString = this.mLauncher.MIMEInfo.MIMEType;
       }
     }
     var params = {};
     params.title =
       this.dialogElement("strings").getString("chooseAppFilePickerTitle");
     params.description = typeString;
     params.filename    = this.mLauncher.suggestedFileName;
     params.mimeInfo    = this.mLauncher.MIMEInfo;
     params.handlerApp  = null;
     this.mDialog.openDialog("chrome://global/content/appPicker.xul", null,
                             "chrome,modal,centerscreen,titlebar,dialog=yes",
                             params);
     if (params.handlerApp &&
         params.handlerApp.executable &&
         params.handlerApp.executable.isFile()) {
       // Remember the file they chose to run.
       this.chosenApp = params.handlerApp;
 #else
     var nsIFilePicker = Components.interfaces.nsIFilePicker;
     var fp = Components.classes["@mozilla.org/filepicker;1"]
                        .createInstance(nsIFilePicker);
     fp.init(this.mDialog,
             this.dialogElement("strings").getString("chooseAppFilePickerTitle"),
             nsIFilePicker.modeOpen);
     fp.appendFilters(nsIFilePicker.filterApps);
     if (fp.show() == nsIFilePicker.returnOK && fp.file) {
       // Remember the file they chose to run.
       var localHandlerApp =
         Components.classes["@mozilla.org/uriloader/local-handler-app;1"].
                    createInstance(Components.interfaces.nsILocalHandlerApp);
       localHandlerApp.executable = fp.file;
       this.chosenApp = localHandlerApp;
 #endif
       // Show the "handler" menulist since we have a (user-specified)
       // application now.
       this.dialogElement("modeDeck").setAttribute("selectedIndex", "0");
       // Update dialog.
       var otherHandler = this.dialogElement("otherHandler");
       otherHandler.removeAttribute("hidden");
       otherHandler.setAttribute("path", this.getPath(this.chosenApp.executable));
       otherHandler.label = this.getFileDisplayName(this.chosenApp.executable);
       this.dialogElement("openHandler").selectedIndex = 1;
       this.dialogElement("openHandler").setAttribute("lastSelectedItemID", "otherHandler");
       this.dialogElement("mode").selectedItem = this.dialogElement("open");
     }
     else {
       var openHandler = this.dialogElement("openHandler");
       var lastSelectedID = openHandler.getAttribute("lastSelectedItemID");
       if (!lastSelectedID)
         lastSelectedID = "defaultHandler";
       openHandler.selectedItem = this.dialogElement(lastSelectedID);
     }
   },
   // Turn this on to get debugging messages.
   debug: false,
   // Dump text (if debug is on).
   dump: function( text ) {
     if ( this.debug ) {
       dump( text );
     }
   },
   // dumpObj:
   dumpObj: function( spec ) {
     var val = "<undefined>";
     try {
       val = eval( "this."+spec ).toString();
     } catch( exception ) {
     }
     this.dump( spec + "=" + val + "\n" );
   },
   // dumpObjectProperties
   dumpObjectProperties: function( desc, obj ) {
     for( prop in obj ) {
       this.dump( desc + "." + prop + "=" );
       var val = "<undefined>";
       try {
         val = obj[ prop ];
       } catch ( exception ) {
       }
       this.dump( val + "\n" );
     }
   }
 }
 this.NSGetFactory = XPCOMUtils.generateNSGetFactory([nsUnknownContentTypeDialog]);