Add m-esr52 at 52.6.0

1 files changed, 1429 insertions, 0 deletions

diff --git a/uriloader/exthandler/nsHandlerService.js b/uriloader/exthandler/nsHandlerService.js
new file mode 100644
index 000000000..c932f9f5d
--- /dev/null
+++ b/uriloader/exthandler/nsHandlerService.js
@@ -0,0 +1,1429 @@
+/* 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/. */
+
+const Ci = Components.interfaces;
+const Cc = Components.classes;
+const Cu = Components.utils;
+const Cr = Components.results;
+
+
+const CLASS_MIMEINFO        = "mimetype";
+const CLASS_PROTOCOLINFO    = "scheme";
+
+
+// namespace prefix
+const NC_NS                 = "http://home.netscape.com/NC-rdf#";
+
+// the most recent default handlers that have been injected.  Note that
+// this is used to construct an RDF resource, which needs to have NC_NS
+// prepended, since that hasn't been done yet
+const DEFAULT_HANDLERS_VERSION = "defaultHandlersVersion";
+
+// type list properties
+
+const NC_MIME_TYPES         = NC_NS + "MIME-types";
+const NC_PROTOCOL_SCHEMES   = NC_NS + "Protocol-Schemes";
+
+// content type ("type") properties
+
+// nsIHandlerInfo::type
+const NC_VALUE              = NC_NS + "value";
+const NC_DESCRIPTION        = NC_NS + "description";
+
+// additional extensions
+const NC_FILE_EXTENSIONS    = NC_NS + "fileExtensions";
+
+// references nsIHandlerInfo record
+const NC_HANDLER_INFO       = NC_NS + "handlerProp";
+
+// handler info ("info") properties
+
+// nsIHandlerInfo::preferredAction
+const NC_SAVE_TO_DISK       = NC_NS + "saveToDisk";
+const NC_HANDLE_INTERNALLY  = NC_NS + "handleInternal";
+const NC_USE_SYSTEM_DEFAULT = NC_NS + "useSystemDefault";
+
+// nsIHandlerInfo::alwaysAskBeforeHandling
+const NC_ALWAYS_ASK         = NC_NS + "alwaysAsk";
+
+// references nsIHandlerApp records
+const NC_PREFERRED_APP      = NC_NS + "externalApplication";
+const NC_POSSIBLE_APP       = NC_NS + "possibleApplication";
+
+// handler app ("handler") properties
+
+// nsIHandlerApp::name
+const NC_PRETTY_NAME        = NC_NS + "prettyName";
+
+// nsILocalHandlerApp::executable
+const NC_PATH               = NC_NS + "path";
+
+// nsIWebHandlerApp::uriTemplate
+const NC_URI_TEMPLATE       = NC_NS + "uriTemplate";
+
+// nsIDBusHandlerApp::service
+const NC_SERVICE            = NC_NS + "service";
+
+// nsIDBusHandlerApp::method
+const NC_METHOD             = NC_NS + "method";
+
+// nsIDBusHandlerApp::objectPath
+const NC_OBJPATH            = NC_NS + "objectPath";
+
+// nsIDBusHandlerApp::dbusInterface
+const NC_INTERFACE            = NC_NS + "dBusInterface";
+
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+
+
+function HandlerService() {
+  this._init();
+}
+
+const HandlerServiceFactory = {
+  _instance: null,
+  createInstance: function (outer, iid) {
+    if (this._instance)
+      return this._instance;
+
+    let processType = Cc["@mozilla.org/xre/runtime;1"].
+      getService(Ci.nsIXULRuntime).processType;
+    if (processType != Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT)
+      return Cr.NS_ERROR_NOT_IMPLEMENTED;
+
+    return (this._instance = new HandlerService());
+  }
+};
+
+HandlerService.prototype = {
+  //**************************************************************************//
+  // XPCOM Plumbing
+
+  classID:          Components.ID("{32314cc8-22f7-4f7f-a645-1a45453ba6a6}"),
+  QueryInterface:   XPCOMUtils.generateQI([Ci.nsIHandlerService]),
+  _xpcom_factory: HandlerServiceFactory,
+
+  //**************************************************************************//
+  // Initialization & Destruction
+  
+  _init: function HS__init() {
+    // Observe profile-before-change so we can switch to the datasource
+    // in the new profile when the user changes profiles.
+    this._observerSvc.addObserver(this, "profile-before-change", false);
+
+    // Observe xpcom-shutdown so we can remove these observers
+    // when the application shuts down.
+    this._observerSvc.addObserver(this, "xpcom-shutdown", false);
+
+    // Observe profile-do-change so that non-default profiles get upgraded too
+    this._observerSvc.addObserver(this, "profile-do-change", false);
+    
+    // do any necessary updating of the datastore
+    this._updateDB();
+  },
+
+  _updateDB: function HS__updateDB() {
+    try {
+      var defaultHandlersVersion = this._datastoreDefaultHandlersVersion;
+    } catch(ex) {
+      // accessing the datastore failed, we can't update anything
+      return;
+    }
+
+    try {
+      // if we don't have the current version of the default prefs for
+      // this locale, inject any new default handers into the datastore
+      if (defaultHandlersVersion < this._prefsDefaultHandlersVersion) {
+
+        // set the new version first so that if we recurse we don't
+        // call _injectNewDefaults several times
+        this._datastoreDefaultHandlersVersion =
+          this._prefsDefaultHandlersVersion;
+        this._injectNewDefaults();
+      } 
+    } catch (ex) {
+      // if injecting the defaults failed, set the version back to the
+      // previous value
+      this._datastoreDefaultHandlersVersion = defaultHandlersVersion;
+    }
+  },
+
+  get _currentLocale() {
+    var chromeRegistry = Cc["@mozilla.org/chrome/chrome-registry;1"].
+                         getService(Ci.nsIXULChromeRegistry);
+    var currentLocale = chromeRegistry.getSelectedLocale("global");
+    return currentLocale;
+  }, 
+
+  _destroy: function HS__destroy() {
+    this._observerSvc.removeObserver(this, "profile-before-change");
+    this._observerSvc.removeObserver(this, "xpcom-shutdown");
+    this._observerSvc.removeObserver(this, "profile-do-change");
+
+    // XXX Should we also null references to all the services that get stored
+    // by our memoizing getters in the Convenience Getters section?
+  },
+
+  _onProfileChange: function HS__onProfileChange() {
+    // Lose our reference to the datasource so we reacquire it
+    // from the new profile the next time we need it.
+    this.__ds = null;
+  },
+
+  _isInHandlerArray: function HS__isInHandlerArray(aArray, aHandler) {
+    var enumerator = aArray.enumerate();
+    while (enumerator.hasMoreElements()) {
+      let handler = enumerator.getNext();
+      handler.QueryInterface(Ci.nsIHandlerApp);
+      if (handler.equals(aHandler))
+        return true;
+    }
+    
+    return false;
+  },
+
+  // note that this applies to the current locale only 
+  get _datastoreDefaultHandlersVersion() {
+    var version = this._getValue("urn:root", NC_NS + this._currentLocale +
+                                             "_" + DEFAULT_HANDLERS_VERSION);
+    
+    return version ? version : -1;
+  },
+
+  set _datastoreDefaultHandlersVersion(aNewVersion) {
+    return this._setLiteral("urn:root", NC_NS + this._currentLocale + "_" + 
+                            DEFAULT_HANDLERS_VERSION, aNewVersion);
+  },
+
+  get _prefsDefaultHandlersVersion() {
+    // get handler service pref branch
+    var prefSvc = Cc["@mozilla.org/preferences-service;1"].
+                  getService(Ci.nsIPrefService);
+    var handlerSvcBranch = prefSvc.getBranch("gecko.handlerService.");
+
+    // get the version of the preferences for this locale
+    return Number(handlerSvcBranch.
+                  getComplexValue("defaultHandlersVersion", 
+                                  Ci.nsIPrefLocalizedString).data);
+  },
+  
+  _injectNewDefaults: function HS__injectNewDefaults() {
+    // get handler service pref branch
+    var prefSvc = Cc["@mozilla.org/preferences-service;1"].
+                  getService(Ci.nsIPrefService);
+
+    let schemesPrefBranch = prefSvc.getBranch("gecko.handlerService.schemes.");
+    let schemePrefList = schemesPrefBranch.getChildList("");
+
+    var schemes = {};
+
+    // read all the scheme prefs into a hash
+    for (var schemePrefName of schemePrefList) {
+
+      let [scheme, handlerNumber, attribute] = schemePrefName.split(".");
+
+      try {
+        var attrData =
+          schemesPrefBranch.getComplexValue(schemePrefName,
+                                            Ci.nsIPrefLocalizedString).data;
+        if (!(scheme in schemes))
+          schemes[scheme] = {};
+  
+        if (!(handlerNumber in schemes[scheme]))
+          schemes[scheme][handlerNumber] = {};
+        
+        schemes[scheme][handlerNumber][attribute] = attrData;
+      } catch (ex) {}
+    }
+
+    let protoSvc = Cc["@mozilla.org/uriloader/external-protocol-service;1"].
+                   getService(Ci.nsIExternalProtocolService);
+    for (var scheme in schemes) {
+
+      // This clause is essentially a reimplementation of 
+      // nsIExternalProtocolHandlerService.getProtocolHandlerInfo().
+      // Necessary because calling that from here would make XPConnect barf
+      // when getService tried to re-enter the constructor for this
+      // service.
+      let osDefaultHandlerFound = {};
+      let protoInfo = protoSvc.getProtocolHandlerInfoFromOS(scheme, 
+                               osDefaultHandlerFound);
+      
+      if (this.exists(protoInfo))
+        this.fillHandlerInfo(protoInfo, null);
+      else
+        protoSvc.setProtocolHandlerDefaults(protoInfo, 
+                                            osDefaultHandlerFound.value);
+
+      // cache the possible handlers to avoid extra xpconnect traversals.      
+      let possibleHandlers = protoInfo.possibleApplicationHandlers;
+
+      for (let handlerNumber in schemes[scheme]) {
+        let handlerPrefs = schemes[scheme][handlerNumber];
+        let handlerApp = Cc["@mozilla.org/uriloader/web-handler-app;1"].
+                         createInstance(Ci.nsIWebHandlerApp);
+
+        handlerApp.uriTemplate = handlerPrefs.uriTemplate;
+        handlerApp.name = handlerPrefs.name;                
+
+        if (!this._isInHandlerArray(possibleHandlers, handlerApp)) {
+          possibleHandlers.appendElement(handlerApp, false);
+        }
+      }
+
+      this.store(protoInfo);
+    }
+  },
+
+  //**************************************************************************//
+  // nsIObserver
+  
+  observe: function HS__observe(subject, topic, data) {
+    switch(topic) {
+      case "profile-before-change":
+        this._onProfileChange();
+        break;
+      case "xpcom-shutdown":
+        this._destroy();
+        break;
+      case "profile-do-change":
+        this._updateDB();
+        break;  
+    }
+  },
+
+
+  //**************************************************************************//
+  // nsIHandlerService
+
+  enumerate: function HS_enumerate() {
+    var handlers = Cc["@mozilla.org/array;1"].
+                   createInstance(Ci.nsIMutableArray);
+    this._appendHandlers(handlers, CLASS_MIMEINFO);
+    this._appendHandlers(handlers, CLASS_PROTOCOLINFO);
+    return handlers.enumerate();
+  },
+
+  fillHandlerInfo: function HS_fillHandlerInfo(aHandlerInfo, aOverrideType) {
+    var type = aOverrideType || aHandlerInfo.type;
+    var typeID = this._getTypeID(this._getClass(aHandlerInfo), type);
+
+    // Determine whether or not information about this handler is available
+    // in the datastore by looking for its "value" property, which stores its
+    // type and should always be present.
+    if (!this._hasValue(typeID, NC_VALUE))
+      throw Cr.NS_ERROR_NOT_AVAILABLE;
+
+    // Retrieve the human-readable description of the type.
+    if (this._hasValue(typeID, NC_DESCRIPTION))
+      aHandlerInfo.description = this._getValue(typeID, NC_DESCRIPTION);
+
+    // Note: for historical reasons, we don't actually check that the type
+    // record has a "handlerProp" property referencing the info record.  It's
+    // unclear whether or not we should start doing this check; perhaps some
+    // legacy datasources don't have such references.
+    var infoID = this._getInfoID(this._getClass(aHandlerInfo), type);
+
+    aHandlerInfo.preferredAction = this._retrievePreferredAction(infoID);
+
+    var preferredHandlerID =
+      this._getPreferredHandlerID(this._getClass(aHandlerInfo), type);
+
+    // Retrieve the preferred handler.
+    // Note: for historical reasons, we don't actually check that the info
+    // record has an "externalApplication" property referencing the preferred
+    // handler record.  It's unclear whether or not we should start doing
+    // this check; perhaps some legacy datasources don't have such references.
+    aHandlerInfo.preferredApplicationHandler =
+      this._retrieveHandlerApp(preferredHandlerID);
+
+    // Fill the array of possible handlers with the ones in the datastore.
+    this._fillPossibleHandlers(infoID,
+                               aHandlerInfo.possibleApplicationHandlers,
+                               aHandlerInfo.preferredApplicationHandler);
+
+    // If we have an "always ask" flag stored in the RDF, always use its
+    // value. Otherwise, use the default value stored in the pref service.
+    var alwaysAsk;
+    if (this._hasValue(infoID, NC_ALWAYS_ASK)) {
+      alwaysAsk = (this._getValue(infoID, NC_ALWAYS_ASK) != "false");
+    } else {
+      var prefSvc = Cc["@mozilla.org/preferences-service;1"].
+                    getService(Ci.nsIPrefService);
+      var prefBranch = prefSvc.getBranch("network.protocol-handler.");
+      try {
+        alwaysAsk = prefBranch.getBoolPref("warn-external." + type);
+      } catch (e) {
+        // will throw if pref didn't exist.
+        try {
+          alwaysAsk = prefBranch.getBoolPref("warn-external-default");
+        } catch (e) {
+          // Nothing to tell us what to do, so be paranoid and prompt.
+          alwaysAsk = true;
+        }
+      }
+    }
+    aHandlerInfo.alwaysAskBeforeHandling = alwaysAsk;
+
+    // If the object represents a MIME type handler, then also retrieve
+    // any file extensions.
+    if (aHandlerInfo instanceof Ci.nsIMIMEInfo)
+      for (let fileExtension of this._retrieveFileExtensions(typeID))
+        aHandlerInfo.appendExtension(fileExtension);
+  },
+
+  store: function HS_store(aHandlerInfo) {
+    // FIXME: when we switch from RDF to something with transactions (like
+    // SQLite), enclose the following changes in a transaction so they all
+    // get rolled back if any of them fail and we don't leave the datastore
+    // in an inconsistent state.
+
+    this._ensureRecordsForType(aHandlerInfo);
+    this._storePreferredAction(aHandlerInfo);
+    this._storePreferredHandler(aHandlerInfo);
+    this._storePossibleHandlers(aHandlerInfo);
+    this._storeAlwaysAsk(aHandlerInfo);
+    this._storeExtensions(aHandlerInfo);
+
+    // Write the changes to the database immediately so we don't lose them
+    // if the application crashes.
+    if (this._ds instanceof Ci.nsIRDFRemoteDataSource)
+      this._ds.Flush();
+  },
+
+  exists: function HS_exists(aHandlerInfo) {
+    var found;
+
+    try {
+      var typeID = this._getTypeID(this._getClass(aHandlerInfo), aHandlerInfo.type);
+      found = this._hasLiteralAssertion(typeID, NC_VALUE, aHandlerInfo.type);
+    } catch (e) {
+      // If the RDF threw (eg, corrupt file), treat as nonexistent.
+      found = false;
+    }
+
+    return found;
+  },
+
+  remove: function HS_remove(aHandlerInfo) {
+    var preferredHandlerID =
+      this._getPreferredHandlerID(this._getClass(aHandlerInfo), aHandlerInfo.type);
+    this._removeAssertions(preferredHandlerID);
+
+    var infoID = this._getInfoID(this._getClass(aHandlerInfo), aHandlerInfo.type);
+
+    // Get a list of possible handlers.  After we have removed the info record,
+    // we'll check if any other info records reference these handlers, and we'll
+    // remove the handler records that aren't referenced by other info records.
+    var possibleHandlerIDs = [];
+    var possibleHandlerTargets = this._getTargets(infoID, NC_POSSIBLE_APP);
+    while (possibleHandlerTargets.hasMoreElements()) {
+      let possibleHandlerTarget = possibleHandlerTargets.getNext();
+      // Note: possibleHandlerTarget should always be an nsIRDFResource.
+      // The conditional is just here in case of a corrupt RDF datasource.
+      if (possibleHandlerTarget instanceof Ci.nsIRDFResource)
+        possibleHandlerIDs.push(possibleHandlerTarget.ValueUTF8);
+    }
+
+    // Remove the info record.
+    this._removeAssertions(infoID);
+
+    // Now that we've removed the info record, remove any possible handlers
+    // that aren't referenced by other info records.
+    for (let possibleHandlerID of possibleHandlerIDs)
+      if (!this._existsResourceTarget(NC_POSSIBLE_APP, possibleHandlerID))
+        this._removeAssertions(possibleHandlerID);
+
+    var typeID = this._getTypeID(this._getClass(aHandlerInfo), aHandlerInfo.type);
+    this._removeAssertions(typeID);
+
+    // Now that there's no longer a handler for this type, remove the type
+    // from the list of types for which there are known handlers.
+    var typeList = this._ensureAndGetTypeList(this._getClass(aHandlerInfo));
+    var type = this._rdf.GetResource(typeID);
+    var typeIndex = typeList.IndexOf(type);
+    if (typeIndex != -1)
+      typeList.RemoveElementAt(typeIndex, true);
+
+    // Write the changes to the database immediately so we don't lose them
+    // if the application crashes.
+    // XXX If we're removing a bunch of handlers at once, will flushing
+    // after every removal cause a significant performance hit?
+    if (this._ds instanceof Ci.nsIRDFRemoteDataSource)
+      this._ds.Flush();
+  },
+
+  getTypeFromExtension: function HS_getTypeFromExtension(aFileExtension) {
+    var fileExtension = aFileExtension.toLowerCase();
+    var typeID;
+
+    // See bug 1100069 for why we want to fail gracefully and silently here.
+    try {
+      this._ds;
+    } catch (ex) {
+      Components.returnCode = Cr.NS_ERROR_NOT_AVAILABLE;
+      return;
+    }
+
+    if (this._existsLiteralTarget(NC_FILE_EXTENSIONS, fileExtension))
+      typeID = this._getSourceForLiteral(NC_FILE_EXTENSIONS, fileExtension);
+
+    if (typeID && this._hasValue(typeID, NC_VALUE)) {
+      let type = this._getValue(typeID, NC_VALUE);
+      if (type == "")
+        throw Cr.NS_ERROR_FAILURE;
+      return type;
+    }
+
+    return "";
+  },
+
+
+  //**************************************************************************//
+  // Retrieval Methods
+
+  /**
+   * Retrieve the preferred action for the info record with the given ID.
+   *
+   * @param aInfoID  {string}  the info record ID
+   *
+   * @returns  {integer}  the preferred action enumeration value
+   */
+  _retrievePreferredAction: function HS__retrievePreferredAction(aInfoID) {
+    if (this._getValue(aInfoID, NC_SAVE_TO_DISK) == "true")
+      return Ci.nsIHandlerInfo.saveToDisk;
+    
+    if (this._getValue(aInfoID, NC_USE_SYSTEM_DEFAULT) == "true")
+      return Ci.nsIHandlerInfo.useSystemDefault;
+    
+    if (this._getValue(aInfoID, NC_HANDLE_INTERNALLY) == "true")
+      return Ci.nsIHandlerInfo.handleInternally;
+
+    return Ci.nsIHandlerInfo.useHelperApp;
+  },
+
+  /**
+   * Fill an array of possible handlers with the handlers for the given info ID.
+   *
+   * @param aInfoID            {string}           the ID of the info record
+   * @param aPossibleHandlers  {nsIMutableArray}  the array of possible handlers
+   * @param aPreferredHandler  {nsIHandlerApp}    the preferred handler, if any
+   */
+  _fillPossibleHandlers: function HS__fillPossibleHandlers(aInfoID,
+                                                           aPossibleHandlers,
+                                                           aPreferredHandler) {
+    // The set of possible handlers should include the preferred handler,
+    // but legacy datastores (from before we added possible handlers) won't
+    // include the preferred handler, so check if it's included as we build
+    // the list of handlers, and, if it's not included, add it to the list.
+    if (aPreferredHandler)
+      aPossibleHandlers.appendElement(aPreferredHandler, false);
+
+    var possibleHandlerTargets = this._getTargets(aInfoID, NC_POSSIBLE_APP);
+
+    while (possibleHandlerTargets.hasMoreElements()) {
+      let possibleHandlerTarget = possibleHandlerTargets.getNext();
+      if (!(possibleHandlerTarget instanceof Ci.nsIRDFResource))
+        continue;
+
+      let possibleHandlerID = possibleHandlerTarget.ValueUTF8;
+      let possibleHandler = this._retrieveHandlerApp(possibleHandlerID);
+      if (possibleHandler && (!aPreferredHandler ||
+                              !possibleHandler.equals(aPreferredHandler)))
+        aPossibleHandlers.appendElement(possibleHandler, false);
+    }
+  },
+
+  /**
+   * Retrieve the handler app object with the given ID.
+   *
+   * @param aHandlerAppID  {string}  the ID of the handler app to retrieve
+   *
+   * @returns  {nsIHandlerApp}  the handler app, if any; otherwise null
+   */
+  _retrieveHandlerApp: function HS__retrieveHandlerApp(aHandlerAppID) {
+    var handlerApp;
+
+    // If it has a path, it's a local handler; otherwise, it's a web handler.
+    if (this._hasValue(aHandlerAppID, NC_PATH)) {
+      let executable =
+        this._getFileWithPath(this._getValue(aHandlerAppID, NC_PATH));
+      if (!executable)
+        return null;
+
+      handlerApp = Cc["@mozilla.org/uriloader/local-handler-app;1"].
+                   createInstance(Ci.nsILocalHandlerApp);
+      handlerApp.executable = executable;
+    }
+    else if (this._hasValue(aHandlerAppID, NC_URI_TEMPLATE)) {
+      let uriTemplate = this._getValue(aHandlerAppID, NC_URI_TEMPLATE);
+      if (!uriTemplate)
+        return null;
+
+      handlerApp = Cc["@mozilla.org/uriloader/web-handler-app;1"].
+                   createInstance(Ci.nsIWebHandlerApp);
+      handlerApp.uriTemplate = uriTemplate;
+    }
+    else if (this._hasValue(aHandlerAppID, NC_SERVICE)) {
+      let service = this._getValue(aHandlerAppID, NC_SERVICE);
+      if (!service)
+        return null;
+      
+      let method = this._getValue(aHandlerAppID, NC_METHOD);
+      if (!method)
+        return null;
+      
+      let objpath = this._getValue(aHandlerAppID, NC_OBJPATH);
+      if (!objpath)
+        return null;
+      
+      let iface = this._getValue(aHandlerAppID, NC_INTERFACE);
+      if (!iface)
+        return null;
+      
+      handlerApp = Cc["@mozilla.org/uriloader/dbus-handler-app;1"].
+                   createInstance(Ci.nsIDBusHandlerApp);
+      handlerApp.service   = service;
+      handlerApp.method    = method;
+      handlerApp.objectPath   = objpath;
+      handlerApp.dBusInterface = iface;
+      
+    }
+    else
+      return null;
+
+    handlerApp.name = this._getValue(aHandlerAppID, NC_PRETTY_NAME);
+
+    return handlerApp;
+  },
+
+  /*
+   * Retrieve file extensions, if any, for the MIME type with the given type ID.
+   *
+   * @param aTypeID  {string}  the type record ID
+   */
+  _retrieveFileExtensions: function HS__retrieveFileExtensions(aTypeID) {
+    var fileExtensions = [];
+
+    var fileExtensionTargets = this._getTargets(aTypeID, NC_FILE_EXTENSIONS);
+
+    while (fileExtensionTargets.hasMoreElements()) {
+      let fileExtensionTarget = fileExtensionTargets.getNext();
+      if (fileExtensionTarget instanceof Ci.nsIRDFLiteral &&
+          fileExtensionTarget.Value != "")
+        fileExtensions.push(fileExtensionTarget.Value);
+    }
+
+    return fileExtensions;
+  },
+
+  /**
+   * Get the file with the given path.  This is not as simple as merely
+   * initializing a local file object with the path, because the path might be
+   * relative to the current process directory, in which case we have to
+   * construct a path starting from that directory.
+   *
+   * @param aPath  {string}  a path to a file
+   *
+   * @returns {nsILocalFile} the file, or null if the file does not exist
+   */
+  _getFileWithPath: function HS__getFileWithPath(aPath) {
+    var file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsILocalFile);
+
+    try {
+      file.initWithPath(aPath);
+
+      if (file.exists())
+        return file;
+    }
+    catch(ex) {
+      // Note: for historical reasons, we don't actually check to see
+      // if the exception is NS_ERROR_FILE_UNRECOGNIZED_PATH, which is what
+      // nsILocalFile::initWithPath throws when a path is relative.
+
+      file = this._dirSvc.get("XCurProcD", Ci.nsIFile);
+
+      try {
+        file.append(aPath);
+        if (file.exists())
+          return file;
+      }
+      catch(ex) {}
+    }
+
+    return null;
+  },
+
+
+  //**************************************************************************//
+  // Storage Methods
+
+  _storePreferredAction: function HS__storePreferredAction(aHandlerInfo) {
+    var infoID = this._getInfoID(this._getClass(aHandlerInfo), aHandlerInfo.type);
+
+    switch(aHandlerInfo.preferredAction) {
+      case Ci.nsIHandlerInfo.saveToDisk:
+        this._setLiteral(infoID, NC_SAVE_TO_DISK, "true");
+        this._removeTarget(infoID, NC_HANDLE_INTERNALLY);
+        this._removeTarget(infoID, NC_USE_SYSTEM_DEFAULT);
+        break;
+
+      case Ci.nsIHandlerInfo.handleInternally:
+        this._setLiteral(infoID, NC_HANDLE_INTERNALLY, "true");
+        this._removeTarget(infoID, NC_SAVE_TO_DISK);
+        this._removeTarget(infoID, NC_USE_SYSTEM_DEFAULT);
+        break;
+
+      case Ci.nsIHandlerInfo.useSystemDefault:
+        this._setLiteral(infoID, NC_USE_SYSTEM_DEFAULT, "true");
+        this._removeTarget(infoID, NC_SAVE_TO_DISK);
+        this._removeTarget(infoID, NC_HANDLE_INTERNALLY);
+        break;
+
+      // This value is indicated in the datastore either by the absence of
+      // the three properties or by setting them all "false".  Of these two
+      // options, the former seems preferable, because it reduces the size
+      // of the RDF file and thus the amount of stuff we have to parse.
+      case Ci.nsIHandlerInfo.useHelperApp:
+      default:
+        this._removeTarget(infoID, NC_SAVE_TO_DISK);
+        this._removeTarget(infoID, NC_HANDLE_INTERNALLY);
+        this._removeTarget(infoID, NC_USE_SYSTEM_DEFAULT);
+        break;
+    }
+  },
+
+  _storePreferredHandler: function HS__storePreferredHandler(aHandlerInfo) {
+    var infoID = this._getInfoID(this._getClass(aHandlerInfo), aHandlerInfo.type);
+    var handlerID =
+      this._getPreferredHandlerID(this._getClass(aHandlerInfo), aHandlerInfo.type);
+
+    var handler = aHandlerInfo.preferredApplicationHandler;
+
+    if (handler) {
+      this._storeHandlerApp(handlerID, handler);
+
+      // Make this app be the preferred app for the handler info.
+      //
+      // Note: nsExternalHelperAppService::FillContentHandlerProperties ignores
+      // this setting and instead identifies the preferred app as the resource
+      // whose URI follows the pattern urn:<class>:externalApplication:<type>.
+      // But the old downloadactions.js code used to set this property, so just
+      // in case there is still some code somewhere that relies on its presence,
+      // we set it here.
+      this._setResource(infoID, NC_PREFERRED_APP, handlerID);
+    }
+    else {
+      // There isn't a preferred handler.  Remove the existing record for it,
+      // if any.
+      this._removeTarget(infoID, NC_PREFERRED_APP);
+      this._removeAssertions(handlerID);
+    }
+  },
+
+  /**
+   * Store the list of possible handler apps for the content type represented
+   * by the given handler info object.
+   *
+   * @param aHandlerInfo  {nsIHandlerInfo}  the handler info object
+   */
+  _storePossibleHandlers: function HS__storePossibleHandlers(aHandlerInfo) {
+    var infoID = this._getInfoID(this._getClass(aHandlerInfo), aHandlerInfo.type);
+
+    // First, retrieve the set of handler apps currently stored for the type,
+    // keeping track of their IDs in a hash that we'll use to determine which
+    // ones are no longer valid and should be removed.
+    var currentHandlerApps = {};
+    var currentHandlerTargets = this._getTargets(infoID, NC_POSSIBLE_APP);
+    while (currentHandlerTargets.hasMoreElements()) {
+      let handlerApp = currentHandlerTargets.getNext();
+      if (handlerApp instanceof Ci.nsIRDFResource) {
+        let handlerAppID = handlerApp.ValueUTF8;
+        currentHandlerApps[handlerAppID] = true;
+      }
+    }
+
+    // Next, store any new handler apps.
+    var newHandlerApps =
+      aHandlerInfo.possibleApplicationHandlers.enumerate();
+    while (newHandlerApps.hasMoreElements()) {
+      let handlerApp =
+        newHandlerApps.getNext().QueryInterface(Ci.nsIHandlerApp);
+      let handlerAppID = this._getPossibleHandlerAppID(handlerApp);
+      if (!this._hasResourceAssertion(infoID, NC_POSSIBLE_APP, handlerAppID)) {
+        this._storeHandlerApp(handlerAppID, handlerApp);
+        this._addResourceAssertion(infoID, NC_POSSIBLE_APP, handlerAppID);
+      }
+      delete currentHandlerApps[handlerAppID];
+    }
+
+    // Finally, remove any old handler apps that aren't being used anymore,
+    // and if those handler apps aren't being used by any other type either,
+    // then completely remove their record from the datastore so we don't
+    // leave it clogged up with information about handler apps we don't care
+    // about anymore.
+    for (let handlerAppID in currentHandlerApps) {
+      this._removeResourceAssertion(infoID, NC_POSSIBLE_APP, handlerAppID);
+      if (!this._existsResourceTarget(NC_POSSIBLE_APP, handlerAppID))
+        this._removeAssertions(handlerAppID);
+    }
+  },
+
+  /**
+   * Store the given handler app.
+   *
+   * Note: the reason this method takes the ID of the handler app in a param
+   * is that the ID is different than it usually is when the handler app
+   * in question is a preferred handler app, so this method can't just derive
+   * the ID of the handler app by calling _getPossibleHandlerAppID, its callers
+   * have to do that for it.
+   *
+   * @param aHandlerAppID {string}        the ID of the handler app to store
+   * @param aHandlerApp   {nsIHandlerApp} the handler app to store
+   */
+  _storeHandlerApp: function HS__storeHandlerApp(aHandlerAppID, aHandlerApp) {
+    aHandlerApp.QueryInterface(Ci.nsIHandlerApp);
+    this._setLiteral(aHandlerAppID, NC_PRETTY_NAME, aHandlerApp.name);
+
+    // In the case of the preferred handler, the handler ID could have been
+    // used to refer to a different kind of handler in the past (i.e. either
+    // a local hander or a web handler), so if the new handler is a local
+    // handler, then we remove any web handler properties and vice versa.
+    // This is unnecessary but harmless for possible handlers.
+
+    if (aHandlerApp instanceof Ci.nsILocalHandlerApp) {
+      this._setLiteral(aHandlerAppID, NC_PATH, aHandlerApp.executable.path);
+      this._removeTarget(aHandlerAppID, NC_URI_TEMPLATE);
+      this._removeTarget(aHandlerAppID, NC_METHOD);
+      this._removeTarget(aHandlerAppID, NC_SERVICE);
+      this._removeTarget(aHandlerAppID, NC_OBJPATH);
+      this._removeTarget(aHandlerAppID, NC_INTERFACE);
+    }
+    else if(aHandlerApp instanceof Ci.nsIWebHandlerApp){
+      aHandlerApp.QueryInterface(Ci.nsIWebHandlerApp);
+      this._setLiteral(aHandlerAppID, NC_URI_TEMPLATE, aHandlerApp.uriTemplate);
+      this._removeTarget(aHandlerAppID, NC_PATH);
+      this._removeTarget(aHandlerAppID, NC_METHOD);
+      this._removeTarget(aHandlerAppID, NC_SERVICE);
+      this._removeTarget(aHandlerAppID, NC_OBJPATH);
+      this._removeTarget(aHandlerAppID, NC_INTERFACE);
+    }
+    else if(aHandlerApp instanceof Ci.nsIDBusHandlerApp){
+      aHandlerApp.QueryInterface(Ci.nsIDBusHandlerApp);
+      this._setLiteral(aHandlerAppID, NC_SERVICE, aHandlerApp.service);
+      this._setLiteral(aHandlerAppID, NC_METHOD, aHandlerApp.method);
+      this._setLiteral(aHandlerAppID, NC_OBJPATH, aHandlerApp.objectPath);
+      this._setLiteral(aHandlerAppID, NC_INTERFACE, aHandlerApp.dBusInterface);
+      this._removeTarget(aHandlerAppID, NC_PATH);
+      this._removeTarget(aHandlerAppID, NC_URI_TEMPLATE);
+    }
+    else {
+      throw "unknown handler type";
+    }
+	
+  },
+
+  _storeAlwaysAsk: function HS__storeAlwaysAsk(aHandlerInfo) {
+    var infoID = this._getInfoID(this._getClass(aHandlerInfo), aHandlerInfo.type);
+    this._setLiteral(infoID,
+                     NC_ALWAYS_ASK,
+                     aHandlerInfo.alwaysAskBeforeHandling ? "true" : "false");
+  },
+
+  _storeExtensions: function HS__storeExtensions(aHandlerInfo) {
+    if (aHandlerInfo instanceof Ci.nsIMIMEInfo) {
+      var typeID = this._getTypeID(this._getClass(aHandlerInfo), aHandlerInfo.type);
+      var extEnum = aHandlerInfo.getFileExtensions();
+      while (extEnum.hasMore()) {
+        let ext = extEnum.getNext().toLowerCase();
+        if (!this._hasLiteralAssertion(typeID, NC_FILE_EXTENSIONS, ext)) {
+          this._setLiteral(typeID, NC_FILE_EXTENSIONS, ext);
+        }
+      }
+    }
+  },
+
+
+  //**************************************************************************//
+  // Convenience Getters
+
+  // Observer Service
+  __observerSvc: null,
+  get _observerSvc() {
+    if (!this.__observerSvc)
+      this.__observerSvc =
+        Cc["@mozilla.org/observer-service;1"].
+        getService(Ci.nsIObserverService);
+    return this.__observerSvc;
+  },
+
+  // Directory Service
+  __dirSvc: null,
+  get _dirSvc() {
+    if (!this.__dirSvc)
+      this.__dirSvc =
+        Cc["@mozilla.org/file/directory_service;1"].
+        getService(Ci.nsIProperties);
+    return this.__dirSvc;
+  },
+
+  // MIME Service
+  __mimeSvc: null,
+  get _mimeSvc() {
+    if (!this.__mimeSvc)
+      this.__mimeSvc =
+        Cc["@mozilla.org/mime;1"].
+        getService(Ci.nsIMIMEService);
+    return this.__mimeSvc;
+  },
+
+  // Protocol Service
+  __protocolSvc: null,
+  get _protocolSvc() {
+    if (!this.__protocolSvc)
+      this.__protocolSvc =
+        Cc["@mozilla.org/uriloader/external-protocol-service;1"].
+        getService(Ci.nsIExternalProtocolService);
+    return this.__protocolSvc;
+  },
+
+  // RDF Service
+  __rdf: null,
+  get _rdf() {
+    if (!this.__rdf)
+      this.__rdf = Cc["@mozilla.org/rdf/rdf-service;1"].
+                   getService(Ci.nsIRDFService);
+    return this.__rdf;
+  },
+
+  // RDF Container Utils
+  __containerUtils: null,
+  get _containerUtils() {
+    if (!this.__containerUtils)
+      this.__containerUtils = Cc["@mozilla.org/rdf/container-utils;1"].
+                              getService(Ci.nsIRDFContainerUtils);
+    return this.__containerUtils;
+  },
+
+  // RDF datasource containing content handling config (i.e. mimeTypes.rdf)
+  __ds: null,
+  get _ds() {
+    if (!this.__ds) {
+      var file = this._dirSvc.get("UMimTyp", Ci.nsIFile);
+      // FIXME: make this a memoizing getter if we use it anywhere else.
+      var ioService = Cc["@mozilla.org/network/io-service;1"].
+                      getService(Ci.nsIIOService);
+      var fileHandler = ioService.getProtocolHandler("file").
+                        QueryInterface(Ci.nsIFileProtocolHandler);
+      this.__ds =
+        this._rdf.GetDataSourceBlocking(fileHandler.getURLSpecFromFile(file));
+    }
+
+    return this.__ds;
+  },
+
+
+  //**************************************************************************//
+  // Datastore Utils
+
+  /**
+   * Get the string identifying whether this is a MIME or a protocol handler.
+   * This string is used in the URI IDs of various RDF properties.
+   * 
+   * @param aHandlerInfo {nsIHandlerInfo} the handler for which to get the class
+   * 
+   * @returns {string} the class
+   */
+  _getClass: function HS__getClass(aHandlerInfo) {
+    if (aHandlerInfo instanceof Ci.nsIMIMEInfo)
+      return CLASS_MIMEINFO;
+    else
+      return CLASS_PROTOCOLINFO;
+  },
+
+  /**
+   * Return the unique identifier for a content type record, which stores
+   * the value field plus a reference to the content type's handler info record.
+   *
+   * |urn:<class>:<type>|
+   *
+   * XXX: should this be a property of nsIHandlerInfo?
+   *
+   * @param aClass {string} the class (CLASS_MIMEINFO or CLASS_PROTOCOLINFO)
+   * @param aType  {string} the type (a MIME type or protocol scheme)
+   *
+   * @returns {string} the ID
+   */
+  _getTypeID: function HS__getTypeID(aClass, aType) {
+    return "urn:" + aClass + ":" + aType;
+  },
+
+  /**
+   * Return the unique identifier for a handler info record, which stores
+   * the preferredAction and alwaysAsk fields plus a reference to the preferred
+   * handler app.  Roughly equivalent to the nsIHandlerInfo interface.
+   *
+   * |urn:<class>:handler:<type>|
+   *
+   * FIXME: the type info record should be merged into the type record,
+   * since there's a one to one relationship between them, and this record
+   * merely stores additional attributes of a content type.
+   *
+   * @param aClass {string} the class (CLASS_MIMEINFO or CLASS_PROTOCOLINFO)
+   * @param aType  {string} the type (a MIME type or protocol scheme)
+   *
+   * @returns {string} the ID
+   */
+  _getInfoID: function HS__getInfoID(aClass, aType) {
+    return "urn:" + aClass + ":handler:" + aType;
+  },
+
+  /**
+   * Return the unique identifier for a preferred handler record, which stores
+   * information about the preferred handler for a given content type, including
+   * its human-readable name and the path to its executable (for a local app)
+   * or its URI template (for a web app).
+   * 
+   * |urn:<class>:externalApplication:<type>|
+   *
+   * XXX: should this be a property of nsIHandlerApp?
+   *
+   * FIXME: this should be an arbitrary ID, and we should retrieve it from
+   * the datastore for a given content type via the NC:ExternalApplication
+   * property rather than looking for a specific ID, so a handler doesn't
+   * have to change IDs when it goes from being a possible handler to being
+   * the preferred one (once we support possible handlers).
+   * 
+   * @param aClass {string} the class (CLASS_MIMEINFO or CLASS_PROTOCOLINFO)
+   * @param aType  {string} the type (a MIME type or protocol scheme)
+   * 
+   * @returns {string} the ID
+   */
+  _getPreferredHandlerID: function HS__getPreferredHandlerID(aClass, aType) {
+    return "urn:" + aClass + ":externalApplication:" + aType;
+  },
+
+  /**
+   * Return the unique identifier for a handler app record, which stores
+   * information about a possible handler for one or more content types,
+   * including its human-readable name and the path to its executable (for a
+   * local app) or its URI template (for a web app).
+   *
+   * Note: handler app IDs for preferred handlers are different.  For those,
+   * see the _getPreferredHandlerID method.
+   *
+   * @param aHandlerApp  {nsIHandlerApp}   the handler app object
+   */
+  _getPossibleHandlerAppID: function HS__getPossibleHandlerAppID(aHandlerApp) {
+    var handlerAppID = "urn:handler:";
+
+    if (aHandlerApp instanceof Ci.nsILocalHandlerApp)
+      handlerAppID += "local:" + aHandlerApp.executable.path;
+    else if(aHandlerApp instanceof Ci.nsIWebHandlerApp){
+      aHandlerApp.QueryInterface(Ci.nsIWebHandlerApp);
+      handlerAppID += "web:" + aHandlerApp.uriTemplate;
+    }
+    else if(aHandlerApp instanceof Ci.nsIDBusHandlerApp){
+      aHandlerApp.QueryInterface(Ci.nsIDBusHandlerApp);
+      handlerAppID += "dbus:" + aHandlerApp.service + " " + aHandlerApp.method + " " + aHandlerApp.uriTemplate;
+    }else{
+	throw "unknown handler type";
+    }
+    
+    return handlerAppID;
+  },
+
+  /**
+   * Get the list of types for the given class, creating the list if it doesn't
+   * already exist. The class can be either CLASS_MIMEINFO or CLASS_PROTOCOLINFO
+   * (i.e. the result of a call to _getClass).
+   * 
+   * |urn:<class>s|
+   * |urn:<class>s:root|
+   * 
+   * @param aClass {string} the class for which to retrieve a list of types
+   *
+   * @returns {nsIRDFContainer} the list of types
+   */
+  _ensureAndGetTypeList: function HS__ensureAndGetTypeList(aClass) {
+    var source = this._rdf.GetResource("urn:" + aClass + "s");
+    var property =
+      this._rdf.GetResource(aClass == CLASS_MIMEINFO ? NC_MIME_TYPES
+                                                     : NC_PROTOCOL_SCHEMES);
+    var target = this._rdf.GetResource("urn:" + aClass + "s:root");
+
+    // Make sure we have an arc from the source to the target.
+    if (!this._ds.HasAssertion(source, property, target, true))
+      this._ds.Assert(source, property, target, true);
+
+    // Make sure the target is a container.
+    if (!this._containerUtils.IsContainer(this._ds, target))
+      this._containerUtils.MakeSeq(this._ds, target);
+
+    // Get the type list as an RDF container.
+    var typeList = Cc["@mozilla.org/rdf/container;1"].
+                   createInstance(Ci.nsIRDFContainer);
+    typeList.Init(this._ds, target);
+
+    return typeList;
+  },
+
+  /**
+   * Make sure there are records in the datasource for the given content type
+   * by creating them if they don't already exist.  We have to do this before
+   * storing any specific data, because we can't assume the presence
+   * of the records (the nsIHandlerInfo object might have been created
+   * from the OS), and the records have to all be there in order for the helper
+   * app service to properly construct an nsIHandlerInfo object for the type.
+   *
+   * Based on old downloadactions.js::_ensureMIMERegistryEntry.
+   *
+   * @param aHandlerInfo {nsIHandlerInfo} the type to make sure has a record
+   */
+  _ensureRecordsForType: function HS__ensureRecordsForType(aHandlerInfo) {
+    // Get the list of types.
+    var typeList = this._ensureAndGetTypeList(this._getClass(aHandlerInfo));
+
+    // If there's already a record in the datastore for this type, then we
+    // don't need to do anything more.
+    var typeID = this._getTypeID(this._getClass(aHandlerInfo), aHandlerInfo.type);
+    var type = this._rdf.GetResource(typeID);
+    if (typeList.IndexOf(type) != -1)
+      return;
+
+    // Create a basic type record for this type.
+    typeList.AppendElement(type);
+    this._setLiteral(typeID, NC_VALUE, aHandlerInfo.type);
+    
+    // Create a basic info record for this type.
+    var infoID = this._getInfoID(this._getClass(aHandlerInfo), aHandlerInfo.type);
+    this._setLiteral(infoID, NC_ALWAYS_ASK, "false");
+    this._setResource(typeID, NC_HANDLER_INFO, infoID);
+    // XXX Shouldn't we set preferredAction to useSystemDefault?
+    // That's what it is if there's no record in the datastore; why should it
+    // change to useHelperApp just because we add a record to the datastore?
+    
+    // Create a basic preferred handler record for this type.
+    // XXX Not sure this is necessary, since preferred handlers are optional,
+    // and nsExternalHelperAppService::FillHandlerInfoForTypeFromDS doesn't seem
+    // to require the record , but downloadactions.js::_ensureMIMERegistryEntry
+    // used to create it, so we'll do the same.
+    var preferredHandlerID =
+      this._getPreferredHandlerID(this._getClass(aHandlerInfo), aHandlerInfo.type);
+    this._setLiteral(preferredHandlerID, NC_PATH, "");
+    this._setResource(infoID, NC_PREFERRED_APP, preferredHandlerID);
+  },
+
+  /**
+   * Append known handlers of the given class to the given array.  The class
+   * can be either CLASS_MIMEINFO or CLASS_PROTOCOLINFO.
+   *
+   * @param aHandlers   {array} the array of handlers to append to
+   * @param aClass      {string} the class for which to append handlers
+   */
+  _appendHandlers: function HS__appendHandlers(aHandlers, aClass) {
+    var typeList = this._ensureAndGetTypeList(aClass);
+    var enumerator = typeList.GetElements();
+
+    while (enumerator.hasMoreElements()) {
+      var element = enumerator.getNext();
+      
+      // This should never happen.  If it does, that means our datasource
+      // is corrupted with type list entries that point to literal values
+      // instead of resources.  If it does happen, let's just do our best
+      // to recover by ignoring this entry and moving on to the next one.
+      if (!(element instanceof Ci.nsIRDFResource))
+        continue;
+
+      // Get the value of the element's NC:value property, which contains
+      // the MIME type or scheme for which we're retrieving a handler info.
+      var type = this._getValue(element.ValueUTF8, NC_VALUE);
+      if (!type)
+        continue;
+
+      var handler;
+      if (typeList.Resource.ValueUTF8 == "urn:mimetypes:root")
+        handler = this._mimeSvc.getFromTypeAndExtension(type, null);
+      else
+        handler = this._protocolSvc.getProtocolHandlerInfo(type);
+
+      aHandlers.appendElement(handler, false);
+    }
+  },
+
+  /**
+   * Whether or not a property of an RDF source has a value.
+   *
+   * @param sourceURI   {string}  the URI of the source
+   * @param propertyURI {string}  the URI of the property
+   * @returns           {boolean} whether or not the property has a value
+   */
+  _hasValue: function HS__hasValue(sourceURI, propertyURI) {
+    var source = this._rdf.GetResource(sourceURI);
+    var property = this._rdf.GetResource(propertyURI);
+    return this._ds.hasArcOut(source, property);
+  },
+
+  /**
+   * Get the value of a property of an RDF source.
+   *
+   * @param sourceURI   {string} the URI of the source
+   * @param propertyURI {string} the URI of the property
+   * @returns           {string} the value of the property
+   */
+  _getValue: function HS__getValue(sourceURI, propertyURI) {
+    var source = this._rdf.GetResource(sourceURI);
+    var property = this._rdf.GetResource(propertyURI);
+
+    var target = this._ds.GetTarget(source, property, true);
+
+    if (!target)
+      return null;
+    
+    if (target instanceof Ci.nsIRDFResource)
+      return target.ValueUTF8;
+
+    if (target instanceof Ci.nsIRDFLiteral)
+      return target.Value;
+
+    return null;
+  },
+
+  /**
+   * Get all targets for the property of an RDF source.
+   *
+   * @param sourceURI   {string} the URI of the source
+   * @param propertyURI {string} the URI of the property
+   * 
+   * @returns {nsISimpleEnumerator} an enumerator of targets
+   */
+  _getTargets: function HS__getTargets(sourceURI, propertyURI) {
+    var source = this._rdf.GetResource(sourceURI);
+    var property = this._rdf.GetResource(propertyURI);
+
+    return this._ds.GetTargets(source, property, true);
+  },
+
+  /**
+   * Set a property of an RDF source to a literal value.
+   *
+   * @param sourceURI   {string} the URI of the source
+   * @param propertyURI {string} the URI of the property
+   * @param value       {string} the literal value
+   */
+  _setLiteral: function HS__setLiteral(sourceURI, propertyURI, value) {
+    var source = this._rdf.GetResource(sourceURI);
+    var property = this._rdf.GetResource(propertyURI);
+    var target = this._rdf.GetLiteral(value);
+    
+    this._setTarget(source, property, target);
+  },
+
+  /**
+   * Set a property of an RDF source to a resource target.
+   *
+   * @param sourceURI   {string} the URI of the source
+   * @param propertyURI {string} the URI of the property
+   * @param targetURI   {string} the URI of the target
+   */
+  _setResource: function HS__setResource(sourceURI, propertyURI, targetURI) {
+    var source = this._rdf.GetResource(sourceURI);
+    var property = this._rdf.GetResource(propertyURI);
+    var target = this._rdf.GetResource(targetURI);
+    
+    this._setTarget(source, property, target);
+  },
+
+  /**
+   * Assert an arc into the RDF datasource if there is no arc with the given
+   * source and property; otherwise, if there is already an existing arc,
+   * change it to point to the given target. _setLiteral and _setResource
+   * call this after converting their string arguments into resources
+   * and literals, and most callers should call one of those two methods
+   * instead of this one.
+   *
+   * @param source    {nsIRDFResource}  the source
+   * @param property  {nsIRDFResource}  the property
+   * @param target    {nsIRDFNode}      the target
+   */
+  _setTarget: function HS__setTarget(source, property, target) {
+    if (this._ds.hasArcOut(source, property)) {
+      var oldTarget = this._ds.GetTarget(source, property, true);
+      this._ds.Change(source, property, oldTarget, target);
+    }
+    else
+      this._ds.Assert(source, property, target, true);
+  },
+
+  /**
+   * Assert that a property of an RDF source has a resource target.
+   * 
+   * The difference between this method and _setResource is that this one adds
+   * an assertion even if one already exists, which allows its callers to make
+   * sets of assertions (i.e. to set a property to multiple targets).
+   *
+   * @param sourceURI   {string} the URI of the source
+   * @param propertyURI {string} the URI of the property
+   * @param targetURI   {string} the URI of the target
+   */
+  _addResourceAssertion: function HS__addResourceAssertion(sourceURI,
+                                                           propertyURI,
+                                                           targetURI) {
+    var source = this._rdf.GetResource(sourceURI);
+    var property = this._rdf.GetResource(propertyURI);
+    var target = this._rdf.GetResource(targetURI);
+    
+    this._ds.Assert(source, property, target, true);
+  },
+
+  /**
+   * Remove an assertion with a resource target.
+   *
+   * @param sourceURI   {string} the URI of the source
+   * @param propertyURI {string} the URI of the property
+   * @param targetURI   {string} the URI of the target
+   */
+  _removeResourceAssertion: function HS__removeResourceAssertion(sourceURI,
+                                                                 propertyURI,
+                                                                 targetURI) {
+    var source = this._rdf.GetResource(sourceURI);
+    var property = this._rdf.GetResource(propertyURI);
+    var target = this._rdf.GetResource(targetURI);
+
+    this._ds.Unassert(source, property, target);
+  },
+
+  /**
+   * Whether or not a property of an RDF source has a given resource target.
+   * 
+   * @param sourceURI   {string} the URI of the source
+   * @param propertyURI {string} the URI of the property
+   * @param targetURI   {string} the URI of the target
+   *
+   * @returns {boolean} whether or not there is such an assertion
+   */
+  _hasResourceAssertion: function HS__hasResourceAssertion(sourceURI,
+                                                           propertyURI,
+                                                           targetURI) {
+    var source = this._rdf.GetResource(sourceURI);
+    var property = this._rdf.GetResource(propertyURI);
+    var target = this._rdf.GetResource(targetURI);
+
+    return this._ds.HasAssertion(source, property, target, true);
+  },
+
+  /**
+   * Whether or not a property of an RDF source has a given literal value.
+   * 
+   * @param sourceURI   {string} the URI of the source
+   * @param propertyURI {string} the URI of the property
+   * @param value       {string} the literal value
+   *
+   * @returns {boolean} whether or not there is such an assertion
+   */
+  _hasLiteralAssertion: function HS__hasLiteralAssertion(sourceURI,
+                                                         propertyURI,
+                                                         value) {
+    var source = this._rdf.GetResource(sourceURI);
+    var property = this._rdf.GetResource(propertyURI);
+    var target = this._rdf.GetLiteral(value);
+
+    return this._ds.HasAssertion(source, property, target, true);
+  },
+
+  /**
+   * Whether or not there is an RDF source that has the given property set to
+   * the given literal value.
+   * 
+   * @param propertyURI {string} the URI of the property
+   * @param value       {string} the literal value
+   *
+   * @returns {boolean} whether or not there is a source
+   */
+  _existsLiteralTarget: function HS__existsLiteralTarget(propertyURI, value) {
+    var property = this._rdf.GetResource(propertyURI);
+    var target = this._rdf.GetLiteral(value);
+
+    return this._ds.hasArcIn(target, property);
+  },
+
+  /**
+   * Get the source for a property set to a given literal value.
+   *
+   * @param propertyURI {string} the URI of the property
+   * @param value       {string} the literal value
+   */
+  _getSourceForLiteral: function HS__getSourceForLiteral(propertyURI, value) {
+    var property = this._rdf.GetResource(propertyURI);
+    var target = this._rdf.GetLiteral(value);
+
+    var source = this._ds.GetSource(property, target, true);
+    if (source)
+      return source.ValueUTF8;
+
+    return null;
+  },
+
+  /**
+   * Whether or not there is an RDF source that has the given property set to
+   * the given resource target.
+   * 
+   * @param propertyURI {string} the URI of the property
+   * @param targetURI   {string} the URI of the target
+   *
+   * @returns {boolean} whether or not there is a source
+   */
+  _existsResourceTarget: function HS__existsResourceTarget(propertyURI,
+                                                           targetURI) {
+    var property = this._rdf.GetResource(propertyURI);
+    var target = this._rdf.GetResource(targetURI);
+
+    return this._ds.hasArcIn(target, property);
+  },
+
+  /**
+   * Remove a property of an RDF source.
+   *
+   * @param sourceURI   {string} the URI of the source
+   * @param propertyURI {string} the URI of the property
+   */
+  _removeTarget: function HS__removeTarget(sourceURI, propertyURI) {
+    var source = this._rdf.GetResource(sourceURI);
+    var property = this._rdf.GetResource(propertyURI);
+
+    if (this._ds.hasArcOut(source, property)) {
+      var target = this._ds.GetTarget(source, property, true);
+      this._ds.Unassert(source, property, target);
+    }
+  },
+
+ /**
+  * Remove all assertions about a given RDF source.
+  *
+  * Note: not recursive.  If some assertions point to other resources,
+  * and you want to remove assertions about those resources too, you need
+  * to do so manually.
+  *
+  * @param sourceURI {string} the URI of the source
+  */
+  _removeAssertions: function HS__removeAssertions(sourceURI) {
+    var source = this._rdf.GetResource(sourceURI);
+    var properties = this._ds.ArcLabelsOut(source);
+ 
+    while (properties.hasMoreElements()) {
+      let property = properties.getNext();
+      let targets = this._ds.GetTargets(source, property, true);
+      while (targets.hasMoreElements()) {
+        let target = targets.getNext();
+        this._ds.Unassert(source, property, target);
+      }
+    }
+  }
+
+};
+
+//****************************************************************************//
+// More XPCOM Plumbing
+
+this.NSGetFactory = XPCOMUtils.generateNSGetFactory([HandlerService]);