Backed out 2 changesets (bug 833098) for depending on bug 1457749

Backed out changeset c00426f6bc7d (bug 833098)
Backed out changeset 2ea9f1f5269e (bug 833098)

browser/components/build/nsModule.cpp

@@ -20,6 +20,7 @@
 #include "nsIEHistoryEnumerator.h"
 #endif
 
+#include "rdf.h"
 #include "nsFeedSniffer.h"
 #include "AboutRedirector.h"
 #include "nsIAboutModule.h"

dom/bindings/Bindings.conf

@@ -1707,6 +1707,9 @@ addExternalIface('LoadInfo', nativeType='nsILoadInfo',
 addExternalIface('MenuBuilder', nativeType='nsIMenuBuilder', notflattened=True)
 addExternalIface('XULControllers', nativeType='nsIControllers', notflattened=True)
 addExternalIface('MozObserver', nativeType='nsIObserver', notflattened=True)
+addExternalIface('MozRDFCompositeDataSource', nativeType='nsIRDFCompositeDataSource',
+                 notflattened=True)
+addExternalIface('MozRDFResource', nativeType='nsIRDFResource', notflattened=True)
 addExternalIface('MozTreeView', nativeType='nsITreeView',
                   headerFile='nsITreeView.h', notflattened=True)
 addExternalIface('MozWakeLockListener', headerFile='nsIDOMWakeLockListener.h')

dom/xul/XULDocument.h

@@ -29,6 +29,8 @@
 #include "js/TracingAPI.h"
 #include "js/TypeDecls.h"
 
+class nsIRDFResource;
+class nsIRDFService;
 class nsPIWindowRoot;
 class nsXULPrototypeElement;
 #if 0 // XXXbe save me, scc (need NSCAP_FORWARD_DECL(nsXULPrototypeScript))
@@ -252,6 +254,11 @@ protected:
     // pseudo constants
     static int32_t gRefCnt;
 
+    static nsIRDFService* gRDFService;
+    static nsIRDFResource* kNC_persist;
+    static nsIRDFResource* kNC_attribute;
+    static nsIRDFResource* kNC_value;
+
     static LazyLogModule gXULLog;
 
     nsresult

dom/xul/nsXULCommandDispatcher.cpp

@@ -21,6 +21,7 @@
 #include "nsIScriptGlobalObject.h"
 #include "nsPIDOMWindow.h"
 #include "nsPIWindowRoot.h"
+#include "nsRDFCID.h"
 #include "nsXULCommandDispatcher.h"
 #include "mozilla/Logging.h"
 #include "nsContentUtils.h"

dom/xul/nsXULContentSink.cpp

@@ -34,6 +34,7 @@
 #include "nsIScriptSecurityManager.h"
 #include "nsLayoutCID.h"
 #include "nsNetUtil.h"
+#include "nsRDFCID.h"
 #include "nsString.h"
 #include "nsReadableUtils.h"
 #include "nsXULElement.h"

dom/xul/nsXULContentUtils.cpp

@@ -19,9 +19,11 @@
 #include "nsICollation.h"
 #include "nsIDocument.h"
 #include "nsIDOMXULCommandDispatcher.h"
+#include "nsIRDFService.h"
 #include "nsIServiceManager.h"
 #include "nsXULContentUtils.h"
 #include "nsLayoutCID.h"
+#include "nsRDFCID.h"
 #include "nsString.h"
 #include "nsGkAtoms.h"
 #include "XULDocument.h"
@@ -31,15 +33,30 @@ using dom::XULDocument;
 
 //------------------------------------------------------------------------
 
+nsIRDFService* nsXULContentUtils::gRDF;
 nsICollation *nsXULContentUtils::gCollation;
 
 //------------------------------------------------------------------------
 // Constructors n' stuff
 //
 
+nsresult
+nsXULContentUtils::Init()
+{
+    static NS_DEFINE_CID(kRDFServiceCID, NS_RDFSERVICE_CID);
+    nsresult rv = CallGetService(kRDFServiceCID, &gRDF);
+    if (NS_FAILED(rv)) {
+        return rv;
+    }
+
+    return NS_OK;
+}
+
+
 nsresult
 nsXULContentUtils::Finish()
 {
+    NS_IF_RELEASE(gRDF);
     NS_IF_RELEASE(gCollation);
 
     return NS_OK;

dom/xul/nsXULContentUtils.h

@@ -18,6 +18,7 @@ class nsAtom;
 class nsICollation;
 class nsIContent;
 class nsIDocument;
+class nsIRDFService;
 
 namespace mozilla {
 namespace dom {
@@ -28,6 +29,7 @@ class Element;
 class nsXULContentUtils
 {
 protected:
+    static nsIRDFService* gRDF;
     static nsICollation *gCollation;
 
     static bool gDisableXULCache;
@@ -36,6 +38,9 @@ protected:
     DisableXULCacheChangedCallback(const char* aPrefName, void* aClosure);
 
 public:
+    static nsresult
+    Init();
+
     static nsresult
     Finish();
 
@@ -48,6 +53,12 @@ public:
     static nsresult
     SetCommandUpdater(nsIDocument* aDocument, mozilla::dom::Element* aElement);
 
+    static nsIRDFService*
+    RDFService()
+    {
+        return gRDF;
+    }
+
     static nsICollation*
     GetCollation();
 };

layout/build/nsLayoutStatics.cpp

@@ -49,6 +49,7 @@
 #include "nsHTMLDNSPrefetch.h"
 #include "nsHtml5Module.h"
 #include "nsHTMLTags.h"
+#include "nsIRDFContentSink.h"	// for RDF atom initialization
 #include "mozilla/dom/FallbackEncoding.h"
 #include "nsFocusManager.h"
 #include "nsListControlFrame.h"
@@ -180,6 +181,15 @@ nsLayoutStatics::Initialize()
     return rv;
   }
 
+#ifdef MOZ_XUL
+  rv = nsXULContentUtils::Init();
+  if (NS_FAILED(rv)) {
+    NS_ERROR("Could not initialize nsXULContentUtils");
+    return rv;
+  }
+
+#endif
+
   nsMathMLOperators::AddRefTable();
 
 #ifdef DEBUG

modules/libpref/init/all.js

@@ -2020,6 +2020,12 @@ pref("network.standard-url.punycode-host", true);
 // Idle timeout for ftp control connections - 5 minute default
 pref("network.ftp.idleConnectionTimeout", 300);
 
+// directory listing format
+// 2: HTML
+// 3: XUL directory viewer
+// all other values are treated like 2
+pref("network.dir.format", 2);
+
 // enables the prefetch service (i.e., prefetching of <link rel="next"> and
 // <link rel="prefetch"> URLs).
 pref("network.prefetch-next", true);

rdf/base/moz.build

@@ -0,0 +1,59 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+XPIDL_SOURCES += [
+    'nsIRDFCompositeDataSource.idl',
+    'nsIRDFContainer.idl',
+    'nsIRDFContainerUtils.idl',
+    'nsIRDFDataSource.idl',
+    'nsIRDFDelegateFactory.idl',
+    'nsIRDFInferDataSource.idl',
+    'nsIRDFInMemoryDataSource.idl',
+    'nsIRDFLiteral.idl',
+    'nsIRDFNode.idl',
+    'nsIRDFObserver.idl',
+    'nsIRDFPropagatableDataSource.idl',
+    'nsIRDFPurgeableDataSource.idl',
+    'nsIRDFRemoteDataSource.idl',
+    'nsIRDFResource.idl',
+    'nsIRDFService.idl',
+    'nsIRDFXMLParser.idl',
+    'nsIRDFXMLSerializer.idl',
+    'nsIRDFXMLSink.idl',
+    'nsIRDFXMLSource.idl',
+    'rdfIDataSource.idl',
+    'rdfITripleVisitor.idl',
+]
+
+XPIDL_MODULE = 'rdf'
+
+EXPORTS += [
+    'nsIRDFContentSink.h',
+    'nsRDFResource.h',
+    'rdf.h',
+]
+
+UNIFIED_SOURCES += [
+    'nsCompositeDataSource.cpp',
+    'nsContainerEnumerator.cpp',
+    'nsDefaultResourceFactory.cpp',
+    'nsInMemoryDataSource.cpp',
+    'nsNameSpaceMap.cpp',
+    'nsRDFContainer.cpp',
+    'nsRDFContainerUtils.cpp',
+    'nsRDFContentSink.cpp',
+    'nsRDFResource.cpp',
+    'nsRDFService.cpp',
+    'nsRDFXMLDataSource.cpp',
+    'nsRDFXMLParser.cpp',
+    'nsRDFXMLSerializer.cpp',
+    'rdfutil.cpp',
+]
+
+FINAL_LIBRARY = 'xul'
+
+if CONFIG['CC_TYPE'] in ('clang', 'gcc'):
+    CXXFLAGS += ['-Wno-error=shadow']

rdf/base/nsContainerEnumerator.cpp

@@ -0,0 +1,262 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+
+  A simple cursor that enumerates the elements of an RDF container
+  (RDF:Bag, RDF:Seq, or RDF:Alt).
+
+  Caveats
+  -------
+
+  1. This uses an implementation-specific detail to determine the
+     index of the last element in the container; specifically, the RDF
+     utilities maintain a counter attribute on the container that
+     holds the numeric value of the next value that is to be
+     assigned. So, this cursor will bust if you use it with a bag that
+     hasn't been created using the RDF utility routines.
+
+ */
+
+#include "nscore.h"
+#include "nsCOMPtr.h"
+#include "nsIRDFContainerUtils.h"
+#include "nsIRDFDataSource.h"
+#include "nsIRDFNode.h"
+#include "nsIRDFService.h"
+#include "nsIServiceManager.h"
+#include "nsRDFCID.h"
+#include "nsString.h"
+#include "mozilla/Logging.h"
+#include "rdf.h"
+#include "rdfutil.h"
+
+////////////////////////////////////////////////////////////////////////
+
+class ContainerEnumeratorImpl : public nsISimpleEnumerator {
+private:
+    // pseudo-constants
+    static nsrefcnt              gRefCnt;
+    static nsIRDFResource*       kRDF_nextVal;
+    static nsIRDFContainerUtils* gRDFC;
+
+    nsCOMPtr<nsIRDFDataSource>      mDataSource;
+    nsCOMPtr<nsIRDFResource>        mContainer;
+    nsCOMPtr<nsIRDFResource>        mOrdinalProperty;
+
+    nsCOMPtr<nsISimpleEnumerator>   mCurrent;
+    nsCOMPtr<nsIRDFNode>            mResult;
+    int32_t mNextIndex;
+
+    virtual ~ContainerEnumeratorImpl();
+
+public:
+    ContainerEnumeratorImpl(nsIRDFDataSource* ds, nsIRDFResource* container);
+
+    nsresult Init();
+
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSISIMPLEENUMERATOR
+};
+
+nsrefcnt              ContainerEnumeratorImpl::gRefCnt;
+nsIRDFResource*       ContainerEnumeratorImpl::kRDF_nextVal;
+nsIRDFContainerUtils* ContainerEnumeratorImpl::gRDFC;
+
+
+ContainerEnumeratorImpl::ContainerEnumeratorImpl(nsIRDFDataSource* aDataSource,
+                                                 nsIRDFResource* aContainer)
+    : mDataSource(aDataSource),
+      mContainer(aContainer),
+      mNextIndex(1)
+{
+}
+
+nsresult
+ContainerEnumeratorImpl::Init()
+{
+    if (gRefCnt++ == 0) {
+        nsresult rv;
+
+        NS_DEFINE_CID(kRDFServiceCID, NS_RDFSERVICE_CID);
+        nsCOMPtr<nsIRDFService> rdf = do_GetService(kRDFServiceCID);
+        NS_ASSERTION(rdf != nullptr, "unable to acquire resource manager");
+        if (! rdf)
+            return NS_ERROR_FAILURE;
+
+        rv = rdf->GetResource(NS_LITERAL_CSTRING(RDF_NAMESPACE_URI "nextVal"), &kRDF_nextVal);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "unable to get resource");
+        if (NS_FAILED(rv)) return rv;
+
+        NS_DEFINE_CID(kRDFContainerUtilsCID, NS_RDFCONTAINERUTILS_CID);
+        rv = CallGetService(kRDFContainerUtilsCID, &gRDFC);
+        if (NS_FAILED(rv)) return rv;
+    }
+
+    return NS_OK;
+}
+
+
+ContainerEnumeratorImpl::~ContainerEnumeratorImpl()
+{
+    if (--gRefCnt == 0) {
+        NS_IF_RELEASE(kRDF_nextVal);
+        NS_IF_RELEASE(gRDFC);
+    }
+}
+
+NS_IMPL_ISUPPORTS(ContainerEnumeratorImpl, nsISimpleEnumerator)
+
+
+NS_IMETHODIMP
+ContainerEnumeratorImpl::HasMoreElements(bool* aResult)
+{
+    NS_PRECONDITION(aResult != nullptr, "null ptr");
+    if (! aResult)
+        return NS_ERROR_NULL_POINTER;
+
+    nsresult rv;
+
+    // If we've already queued up a next value, then we know there are more elements.
+    if (mResult) {
+        *aResult = true;
+        return NS_OK;
+    }
+
+    // Otherwise, we need to grovel
+
+    // Figure out the upper bound so we'll know when we're done. Since it's
+    // possible that we're targeting a composite datasource, we'll need to
+    // "GetTargets()" and take the maximum value of "nextVal" to know the
+    // upper bound.
+    //
+    // Remember that since nextVal is the next index that we'd assign
+    // to an element in a container, it's *one more* than count of
+    // elements in the container.
+    int32_t max = 0;
+
+    nsCOMPtr<nsISimpleEnumerator> targets;
+    rv = mDataSource->GetTargets(mContainer, kRDF_nextVal, true, getter_AddRefs(targets));
+    if (NS_FAILED(rv)) return rv;
+
+    while (1) {
+        bool hasmore;
+        targets->HasMoreElements(&hasmore);
+        if (! hasmore)
+            break;
+
+        nsCOMPtr<nsISupports> isupports;
+        targets->GetNext(getter_AddRefs(isupports));
+
+        nsCOMPtr<nsIRDFLiteral> nextValLiteral = do_QueryInterface(isupports);
+        if (! nextValLiteral)
+             continue;
+
+         const char16_t *nextValStr;
+         nextValLiteral->GetValueConst(&nextValStr);
+
+         nsresult err;
+         int32_t nextVal = nsAutoString(nextValStr).ToInteger(&err);
+
+         if (nextVal > max)
+             max = nextVal;
+    }
+
+    // Now pre-fetch our next value into mResult.
+    while (mCurrent || mNextIndex < max) {
+
+        // If mCurrent has been depleted, then conjure up a new one
+        if (! mCurrent) {
+            rv = gRDFC->IndexToOrdinalResource(mNextIndex, getter_AddRefs(mOrdinalProperty));
+            if (NS_FAILED(rv)) return rv;
+
+            rv = mDataSource->GetTargets(mContainer, mOrdinalProperty, true, getter_AddRefs(mCurrent));
+            if (NS_FAILED(rv)) return rv;
+
+            ++mNextIndex;
+        }
+
+        if (mCurrent) {
+            bool hasMore;
+            rv = mCurrent->HasMoreElements(&hasMore);
+            if (NS_FAILED(rv)) return rv;
+
+            // Is the current enumerator depleted? If so, iterate to
+            // the next index.
+            if (! hasMore) {
+                mCurrent = nullptr;
+                continue;
+            }
+
+            // "Peek" ahead and pull out the next target.
+            nsCOMPtr<nsISupports> result;
+            rv = mCurrent->GetNext(getter_AddRefs(result));
+            if (NS_FAILED(rv)) return rv;
+
+            mResult = do_QueryInterface(result, &rv);
+            if (NS_FAILED(rv)) return rv;
+
+            *aResult = true;
+            return NS_OK;
+        }
+    }
+
+    // If we get here, we ran out of elements. The cursor is empty.
+    *aResult = false;
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+ContainerEnumeratorImpl::GetNext(nsISupports** aResult)
+{
+    nsresult rv;
+
+    bool hasMore;
+    rv = HasMoreElements(&hasMore);
+    if (NS_FAILED(rv)) return rv;
+
+    if (! hasMore)
+        return NS_ERROR_UNEXPECTED;
+
+    NS_ADDREF(*aResult = mResult);
+    mResult = nullptr;
+
+    return NS_OK;
+}
+
+
+////////////////////////////////////////////////////////////////////////
+
+nsresult
+NS_NewContainerEnumerator(nsIRDFDataSource* aDataSource,
+                          nsIRDFResource* aContainer,
+                          nsISimpleEnumerator** aResult)
+{
+    NS_PRECONDITION(aDataSource != nullptr, "null ptr");
+    if (! aDataSource)
+        return NS_ERROR_NULL_POINTER;
+
+    NS_PRECONDITION(aContainer != nullptr, "null ptr");
+    if (! aContainer)
+        return NS_ERROR_NULL_POINTER;
+
+    NS_PRECONDITION(aResult != nullptr, "null ptr");
+    if (! aResult)
+        return NS_ERROR_NULL_POINTER;
+
+    ContainerEnumeratorImpl* result = new ContainerEnumeratorImpl(aDataSource, aContainer);
+    if (! result)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    NS_ADDREF(result);
+
+    nsresult rv = result->Init();
+    if (NS_FAILED(rv))
+        NS_RELEASE(result);
+
+    *aResult = result;
+    return rv;
+}

rdf/base/nsDefaultResourceFactory.cpp

@@ -0,0 +1,30 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+
+  The default resource factory implementation. This resource factory
+  produces nsIRDFResource objects for any URI prefix that is not
+  covered by some other factory.
+
+ */
+
+#include "nsRDFResource.h"
+
+nsresult
+NS_NewDefaultResource(nsIRDFResource** aResult)
+{
+    NS_PRECONDITION(aResult != nullptr, "null ptr");
+    if (! aResult)
+        return NS_ERROR_NULL_POINTER;
+
+    nsRDFResource* resource = new nsRDFResource();
+    if (! resource)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    NS_ADDREF(resource);
+    *aResult = resource;
+    return NS_OK;
+}

rdf/base/nsIRDFCompositeDataSource.idl

@@ -0,0 +1,68 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsIRDFDataSource.idl"
+
+interface nsISimpleEnumerator;
+
+/**
+ * An nsIRDFCompositeDataSource composes individual data sources, providing
+ * the illusion of a single, coherent RDF graph.
+ */
+[scriptable, uuid(96343820-307C-11D2-BC15-00805F912FE7)]
+interface nsIRDFCompositeDataSource : nsIRDFDataSource {
+
+    /**
+     *
+     * Set this value to <code>true</code> if the composite datasource
+     * may contains at least one datasource that has <em>negative</em>
+     * assertions. (This is the default.)
+     *
+     * Set this value to <code>false</code> if none of the datasources
+     * being composed contains a negative assertion. This allows the
+     * composite datasource to perform some query optimizations.
+     *
+     * By default, this value is <code>true</true>.
+     */
+    attribute boolean	allowNegativeAssertions;
+
+    /**
+     * Set to <code>true</code> if the composite datasource should
+     * take care to coalesce duplicate arcs when returning values from
+     * queries. (This is the default.)
+     *
+     * Set to <code>false</code> if the composite datasource shouldn't
+     * bother to check for duplicates. This allows the composite
+     * datasource to more efficiently answer queries.
+     *
+     * By default, this value is <code>true</code>.
+     */
+    attribute boolean	coalesceDuplicateArcs;
+
+    /**
+     * Add a datasource the the composite data source.
+     * @param aDataSource the datasource to add to composite
+     */
+    void AddDataSource(in nsIRDFDataSource aDataSource);
+
+    /**
+     * Remove a datasource from the composite data source.
+     * @param aDataSource the datasource to remove from the composite
+     */
+    void RemoveDataSource(in nsIRDFDataSource aDataSource);
+
+    /**
+     * Retrieve the datasources in the composite data source.
+     * @return an nsISimpleEnumerator that will enumerate each
+     * of the datasources in the composite
+     */
+    nsISimpleEnumerator GetDataSources();
+};
+
+%{C++
+extern nsresult
+NS_NewRDFCompositeDataSource(nsIRDFCompositeDataSource** result);
+%}
+

rdf/base/nsIRDFContainer.idl

@@ -0,0 +1,94 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "nsIRDFDataSource.idl"
+#include "nsIRDFResource.idl"
+#include "nsIRDFNode.idl"
+#include "nsISimpleEnumerator.idl"
+
+// A wrapper for manipulating RDF containers
+[scriptable, uuid(D4214E90-FB94-11D2-BDD8-00104BDE6048)]
+interface nsIRDFContainer : nsISupports {
+    readonly attribute nsIRDFDataSource DataSource;
+    readonly attribute nsIRDFResource   Resource;
+
+    /**
+     * Initialize the container wrapper to the specified resource
+     * using the specified datasource for context.
+     */
+    void Init(in nsIRDFDataSource aDataSource, in nsIRDFResource aContainer);
+
+    /**
+     * Return the number of elements in the container. Note that this
+     * may not always be accurate due to aggregation.
+     */
+    long GetCount();
+
+    /**
+     * Return an enumerator that can be used to enumerate the contents
+     * of the container in ascending order.
+     */
+    nsISimpleEnumerator GetElements();
+
+    /**
+     * Append an element to the container, assigning it the next
+     * available ordinal.
+     */
+    void AppendElement(in nsIRDFNode aElement);
+
+    /**
+     * Remove the first occurence of the specified element from the
+     * container. If aRenumber is 'true', then the underlying RDF graph
+     * will be 're-numbered' to account for the removal.
+     */
+    void RemoveElement(in nsIRDFNode aElement, in boolean aRenumber);
+
+    /**
+     * Insert aElement at the specified index. If aRenumber is 'true', then
+     * the underlying RDF graph will be 're-numbered' to accomodate the new
+     * element.
+     */
+    void InsertElementAt(in nsIRDFNode aElement, in long aIndex, in boolean aRenumber);
+
+    /**
+     * Remove the element at the specified index. If aRenumber is 'true', then
+     * the underlying RDF graph will be 're-numbered' to account for the
+     * removal.
+     *
+     * @return the element that was removed.
+     */
+    nsIRDFNode RemoveElementAt(in long aIndex, in boolean aRenumber);
+
+    /**
+     * Determine the index of an element in the container.
+     *
+     * @return The index of the specified element in the container. If
+     * the element is not contained in the container, this function
+     * returns '-1'.
+     */
+    long IndexOf(in nsIRDFNode aElement);
+};
+
+%{C++
+nsresult
+NS_NewRDFContainer(nsIRDFContainer** aResult);
+
+nsresult
+NS_NewRDFContainer(nsIRDFDataSource* aDataSource,
+                   nsIRDFResource* aResource,
+                   nsIRDFContainer** aResult);
+
+/**
+ * Create a cursor on a container that enumerates its contents in
+ * order
+ */
+nsresult
+NS_NewContainerEnumerator(nsIRDFDataSource* aDataSource,
+                          nsIRDFResource* aContainer,
+                          nsISimpleEnumerator** aResult);
+
+
+%}

rdf/base/nsIRDFContainerUtils.idl

@@ -0,0 +1,82 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "nsIRDFContainer.idl"
+#include "nsIRDFResource.idl"
+
+
+// Container utilities
+[scriptable, uuid(D4214E91-FB94-11D2-BDD8-00104BDE6048)]
+interface nsIRDFContainerUtils : nsISupports {
+    /**
+     * Returns 'true' if the property is an RDF ordinal property.
+     */
+    boolean IsOrdinalProperty(in nsIRDFResource aProperty);
+
+    /**
+     * Convert the specified index to an ordinal property.
+     */
+    nsIRDFResource IndexToOrdinalResource(in long aIndex);
+
+    /**
+     * Convert the specified ordinal property into an index
+     */
+    long OrdinalResourceToIndex(in nsIRDFResource aOrdinal);
+
+    /**
+     * Return 'true' if the specified resource is a container
+     */
+    boolean IsContainer(in nsIRDFDataSource aDataSource, in nsIRDFResource aResource);
+
+    /**
+     * Return 'true' if the specified resource is a container and it is empty
+     */
+    boolean IsEmpty(in nsIRDFDataSource aDataSource, in nsIRDFResource aResource);
+
+    /**
+     * Return 'true' if the specified resource is a bag
+     */
+    boolean IsBag(in nsIRDFDataSource aDataSource, in nsIRDFResource aResource);
+
+    /**
+     * Return 'true' if the specified resource is a sequence
+     */
+    boolean IsSeq(in nsIRDFDataSource aDataSource, in nsIRDFResource aResource);
+
+    /**
+     * Return 'true' if the specified resource is an alternation
+     */
+    boolean IsAlt(in nsIRDFDataSource aDataSource, in nsIRDFResource aResource);
+
+    /**
+     * Decorates the specified resource appropriately to make it
+     * usable as an empty bag in the specified data source.
+     */
+    nsIRDFContainer MakeBag(in nsIRDFDataSource aDataSource, in nsIRDFResource aResource);
+
+    /**
+     * Decorates the specified resource appropriately to make it
+     * usable as an empty sequence in the specified data source.
+     */
+    nsIRDFContainer MakeSeq(in nsIRDFDataSource aDataSource, in nsIRDFResource aResource);
+
+    /**
+     * Decorates the specified resource appropriately to make it
+     * usable as an empty alternation in the specified data source.
+     */
+    nsIRDFContainer MakeAlt(in nsIRDFDataSource aDataSource, in nsIRDFResource aResource);
+
+    /**
+     * Retrieve the index of element in the container. Returns -1 if
+     * the element is not in the container.
+     */
+    long indexOf(in nsIRDFDataSource aDataSource, in nsIRDFResource aContainer, in nsIRDFNode aElement);
+};
+
+%{C++
+extern nsresult
+NS_NewRDFContainerUtils(nsIRDFContainerUtils** aResult);
+%}

rdf/base/nsIRDFContentSink.h

@@ -0,0 +1,57 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+
+  An RDF-specific content sink. The content sink is targeted by the
+  parser for building the RDF content model.
+
+ */
+
+#ifndef nsIRDFContentSink_h___
+#define nsIRDFContentSink_h___
+
+#include "nsIXMLContentSink.h"
+class nsIRDFDataSource;
+class nsIURI;
+
+// {3a7459d7-d723-483c-aef0-404fc48e09b8}
+#define NS_IRDFCONTENTSINK_IID \
+{ 0x3a7459d7, 0xd723, 0x483c, { 0xae, 0xf0, 0x40, 0x4f, 0xc4, 0x8e, 0x09, 0xb8 } }
+
+/**
+ * This interface represents a content sink for RDF files.
+ */
+
+class nsIRDFContentSink : public nsIXMLContentSink {
+public:
+    NS_DECLARE_STATIC_IID_ACCESSOR(NS_IRDFCONTENTSINK_IID)
+
+    /**
+     * Initialize the content sink.
+     */
+    NS_IMETHOD Init(nsIURI* aURL) = 0;
+
+    /**
+     * Set the content sink's RDF Data source
+     */
+    NS_IMETHOD SetDataSource(nsIRDFDataSource* aDataSource) = 0;
+
+    /**
+     * Retrieve the content sink's RDF data source.
+     */
+    NS_IMETHOD GetDataSource(nsIRDFDataSource*& rDataSource) = 0;
+};
+
+NS_DEFINE_STATIC_IID_ACCESSOR(nsIRDFContentSink, NS_IRDFCONTENTSINK_IID)
+
+/**
+ * This constructs a content sink that can be used without a
+ * document, say, to create a stand-alone in-memory graph.
+ */
+nsresult
+NS_NewRDFContentSink(nsIRDFContentSink** aResult);
+
+#endif // nsIRDFContentSink_h___

rdf/base/nsIRDFDataSource.idl

@@ -0,0 +1,181 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "nsIRDFResource.idl"
+#include "nsIRDFNode.idl"
+#include "nsISimpleEnumerator.idl"
+#include "nsIRDFObserver.idl"
+
+[scriptable, uuid(0F78DA58-8321-11d2-8EAC-00805F29F370)]
+interface nsIRDFDataSource : nsISupports
+{
+    /** The "URI" of the data source. This used by the RDF service's
+     * |GetDataSource()| method to cache datasources.
+     */
+    readonly attribute ACString URI;
+
+    /** Find an RDF resource that points to a given node over the
+     * specified arc & truth value
+     *
+     * @throws NS_RDF_NO_VALUE if there is no source that leads
+     * to the target with the specified property.
+     */
+    nsIRDFResource GetSource(in nsIRDFResource aProperty,
+                             in nsIRDFNode     aTarget,
+                             in boolean        aTruthValue);
+
+    /**
+     * Find all RDF resources that point to a given node over the
+     * specified arc & truth value
+     */
+    nsISimpleEnumerator GetSources(in nsIRDFResource aProperty,
+                                   in nsIRDFNode     aTarget,
+                                   in boolean        aTruthValue);
+
+    /**
+     * Find a child of that is related to the source by the given arc
+     * arc and truth value
+     *
+     * @throws NS_RDF_NO_VALUE if there is no target accessible from the
+     * source via the specified property.
+     */
+    nsIRDFNode GetTarget(in nsIRDFResource aSource,
+                         in nsIRDFResource aProperty,
+                         in boolean        aTruthValue);
+
+    /**
+     * Find all children of that are related to the source by the given arc
+     * arc and truth value.
+     */
+    nsISimpleEnumerator GetTargets(in nsIRDFResource aSource,
+                                   in nsIRDFResource aProperty,
+                                   in boolean aTruthValue);
+
+    /**
+     * Add an assertion to the graph.
+     */
+    void Assert(in nsIRDFResource aSource, 
+                in nsIRDFResource aProperty, 
+                in nsIRDFNode     aTarget,
+                in boolean        aTruthValue);
+
+    /**
+     * Remove an assertion from the graph.
+     */
+    void Unassert(in nsIRDFResource aSource,
+                  in nsIRDFResource aProperty,
+                  in nsIRDFNode     aTarget);
+
+    /**
+     * Change an assertion from
+     *
+     *   [aSource]--[aProperty]-->[aOldTarget]
+     *
+     * to
+     * 
+     *   [aSource]--[aProperty]-->[aNewTarget]
+     */
+    void Change(in nsIRDFResource aSource,
+                in nsIRDFResource aProperty,
+                in nsIRDFNode     aOldTarget,
+                in nsIRDFNode     aNewTarget);
+
+    /**
+     * 'Move' an assertion from
+     *
+     *   [aOldSource]--[aProperty]-->[aTarget]
+     *
+     * to
+     * 
+     *   [aNewSource]--[aProperty]-->[aTarget]
+     */
+    void Move(in nsIRDFResource aOldSource,
+              in nsIRDFResource aNewSource,
+              in nsIRDFResource aProperty,
+              in nsIRDFNode     aTarget);
+
+    /**
+     * Query whether an assertion exists in this graph.
+     */
+    boolean HasAssertion(in nsIRDFResource aSource,
+                         in nsIRDFResource aProperty,
+                         in nsIRDFNode     aTarget,
+                         in boolean        aTruthValue);
+
+    /**
+     * Add an observer to this data source. If the datasource
+     * supports observers, the datasource source should hold a strong
+     * reference to the observer.
+     */
+    void AddObserver(in nsIRDFObserver aObserver);
+
+    /**
+     * Remove an observer from this data source.
+     */
+    void RemoveObserver(in nsIRDFObserver aObserver);
+
+    /**
+     * Get a cursor to iterate over all the arcs that point into a node.
+     */
+    nsISimpleEnumerator ArcLabelsIn(in nsIRDFNode aNode);
+
+    /**
+     * Get a cursor to iterate over all the arcs that originate in
+     * a resource.
+     */
+    nsISimpleEnumerator ArcLabelsOut(in nsIRDFResource aSource);
+
+    /**
+     * Retrieve all of the resources that the data source currently
+     * refers to.
+     */
+    nsISimpleEnumerator GetAllResources();
+
+    /**
+     * Returns whether a given command is enabled for a set of sources. 
+     */
+    boolean IsCommandEnabled(in nsISupports aSources,
+                             in nsIRDFResource   aCommand,
+                             in nsISupports aArguments);
+
+    /**
+     * Perform the specified command on set of sources.
+     */
+    void DoCommand(in nsISupports aSources,
+                   in nsIRDFResource   aCommand,
+                   in nsISupports aArguments);
+
+    /**
+     * Returns the set of all commands defined for a given source.
+     */
+    nsISimpleEnumerator GetAllCmds(in nsIRDFResource aSource);
+
+    /**
+     * Returns true if the specified node is pointed to by the specified arc.
+     * Equivalent to enumerating ArcLabelsIn and comparing for the specified arc.
+     */
+    boolean hasArcIn(in nsIRDFNode aNode, in nsIRDFResource aArc);
+
+    /**
+     * Returns true if the specified node has the specified outward arc.
+     * Equivalent to enumerating ArcLabelsOut and comparing for the specified arc.
+     */
+    boolean hasArcOut(in nsIRDFResource aSource, in nsIRDFResource aArc);
+
+    /**
+     * Notify observers that the datasource is about to send several
+     * notifications at once.
+     * This must be followed by calling endUpdateBatch(), otherwise
+     * viewers will get out of sync.
+     */
+    void beginUpdateBatch();
+
+    /**
+     * Notify observers that the datasource has completed issuing
+     * a notification group.
+     */
+    void endUpdateBatch();
+};

rdf/base/nsIRDFDelegateFactory.idl

@@ -0,0 +1,40 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+
+  An interface used for runtime pseudo-aggregation of RDF delegate
+  objects.
+
+*/
+
+#include "nsrootidl.idl"
+#include "nsISupports.idl"
+interface nsIRDFResource;
+
+/**
+ * This interface should be implemented by an XPCOM factory that
+ * is registered to handle "@mozilla.org/rdf/delegate-factory/[key]/[scheme];1"
+ * ContractIDs.
+ *
+ * The factory will be invoked to create delegate objects from
+ * nsIRDFResource::GetDelegate().
+ */
+[scriptable, uuid(A1B89470-A124-11d3-BE59-0020A6361667)]
+interface nsIRDFDelegateFactory : nsISupports
+{
+    /**
+     * Create a delegate for the specified RDF resource.
+     *
+     * The created delegate should forward AddRef() and Release()
+     * calls to the aOuter object.
+     */
+    void CreateDelegate(in nsIRDFResource aOuter,
+                        in string aKey,
+                        in nsIIDRef aIID,
+                        [retval, iid_is(aIID)] out nsQIResult aResult);
+};
+
+

rdf/base/nsIRDFInMemoryDataSource.idl

@@ -0,0 +1,14 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "nsIRDFResource.idl"
+#include "nsIRDFNode.idl"
+
+[scriptable, uuid(17C4E0AA-1DD2-11B2-8029-BF6F668DE500)]
+interface nsIRDFInMemoryDataSource : nsISupports
+{
+    void EnsureFastContainment(in nsIRDFResource aSource);
+};

rdf/base/nsIRDFInferDataSource.idl

@@ -0,0 +1,28 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsIRDFDataSource.idl"
+
+/**
+ * An nsIRDFInferDataSource is implemented by a infer engine. This
+ * engine mimics assertions in addition to those in the baseDataSource
+ * according to a particular vocabulary.
+ * Infer engines have contract IDs in the form of
+ * "@mozilla.org/rdf/infer-datasource;1?engine="
+ */
+
+[scriptable, uuid(2b04860f-4017-40f6-8a57-784a1e35077a)]
+interface nsIRDFInferDataSource : nsIRDFDataSource {
+    /**
+     *
+     * The wrapped datasource.
+     *
+     * The InferDataSource contains all arcs from the wrapped
+     * datasource plus those infered by the vocabulary implemented
+     * by the InferDataSource.
+     */
+    attribute nsIRDFDataSource baseDataSource;
+};
+

rdf/base/nsIRDFLiteral.idl

@@ -0,0 +1,68 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsIRDFNode.idl"
+
+%{C++
+#include "nscore.h" // for char16_t
+%}
+
+[ptr] native const_octet_ptr(const uint8_t);
+
+/**
+ * A literal node in the graph, whose value is a string.
+ */
+[scriptable, uuid(E0C493D2-9542-11d2-8EB8-00805F29F370)]
+interface nsIRDFLiteral : nsIRDFNode {
+    /**
+     * The Unicode string value of the literal.
+     */
+    readonly attribute wstring Value;
+
+    /**
+     * An unscriptable version used to avoid a string copy. Meant
+     * for use as a performance optimization.
+     */
+    [noscript] void GetValueConst([shared] out wstring aConstValue);
+};
+
+/**
+ * A literal node in the graph, whose value is a date
+ */
+[scriptable, uuid(E13A24E1-C77A-11d2-80BE-006097B76B8E)]
+interface nsIRDFDate : nsIRDFNode {
+    /**
+     * The date value of the literal
+     */
+    readonly attribute PRTime Value;
+};
+
+/**
+ * A literal node in the graph, whose value is an integer
+ */
+[scriptable, uuid(E13A24E3-C77A-11d2-80BE-006097B76B8E)]
+interface nsIRDFInt : nsIRDFNode {
+    /**
+     * The integer value of the literal
+     */
+    readonly attribute long Value;
+};
+
+/**
+ * A literal node in the graph, whose value is arbitrary
+ * binary data.
+ */
+[scriptable, uuid(237f85a2-1dd2-11b2-94af-8122582fc45e)]
+interface nsIRDFBlob : nsIRDFNode {
+    /**
+     * The binary data.
+     */
+    [noscript] readonly attribute const_octet_ptr value;
+
+    /**
+     * The data's length.
+     */
+    readonly attribute long length;
+};

rdf/base/nsIRDFNode.idl

@@ -0,0 +1,15 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+// An nsIRDFNode object is an abstract placeholder for a node in the
+// RDF data model. Its concreted implementations (e.g., nsIRDFResource
+// or nsIRDFLiteral) are the actual objects that populate the graph.
+[scriptable, uuid(0F78DA50-8321-11d2-8EAC-00805F29F370)]
+interface nsIRDFNode : nsISupports {
+    // Determine if two nodes are identical
+    boolean EqualsNode(in nsIRDFNode aNode);
+};

rdf/base/nsIRDFObserver.idl

@@ -0,0 +1,94 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "nsIRDFResource.idl"
+#include "nsIRDFNode.idl"
+
+interface nsIRDFDataSource;
+
+// An nsIRDFObserver object is an observer that will be notified
+// when assertions are made or removed from a datasource
+[scriptable, uuid(3CC75360-484A-11D2-BC16-00805F912FE7)]
+interface nsIRDFObserver : nsISupports {
+    /**
+     * This method is called whenever a new assertion is made
+     * in the data source
+     * @param aDataSource the datasource that is issuing
+     *   the notification.
+     * @param aSource the subject of the assertion
+     * @param aProperty the predicate of the assertion
+     * @param aTarget the object of the assertion
+     */
+    void onAssert(in nsIRDFDataSource aDataSource,
+                  in nsIRDFResource aSource,
+                  in nsIRDFResource aProperty,
+                  in nsIRDFNode     aTarget);
+
+    /**
+     * This method is called whenever an assertion is removed
+     * from the data source
+     * @param aDataSource the datasource that is issuing
+     *   the notification.
+     * @param aSource the subject of the assertion
+     * @param aProperty the predicate of the assertion
+     * @param aTarget the object of the assertion
+     */
+    void onUnassert(in nsIRDFDataSource aDataSource,
+                    in nsIRDFResource aSource,
+                    in nsIRDFResource aProperty,
+                    in nsIRDFNode     aTarget);
+
+    /**
+     * This method is called when the object of an assertion
+     * changes from one value to another.
+     * @param aDataSource the datasource that is issuing
+     *   the notification.
+     * @param aSource the subject of the assertion
+     * @param aProperty the predicate of the assertion
+     * @param aOldTarget the old object of the assertion
+     * @param aNewTarget the new object of the assertion
+     */
+    void onChange(in nsIRDFDataSource aDataSource,
+                  in nsIRDFResource aSource,
+                  in nsIRDFResource aProperty,
+                  in nsIRDFNode     aOldTarget,
+                  in nsIRDFNode     aNewTarget);
+
+    /**
+     * This method is called when the subject of an assertion
+     * changes from one value to another.
+     * @param aDataSource the datasource that is issuing
+     *   the notification.
+     * @param aOldSource the old subject of the assertion
+     * @param aNewSource the new subject of the assertion
+     * @param aProperty the predicate of the assertion
+     * @param aTarget the object of the assertion
+     */
+    void onMove(in nsIRDFDataSource aDataSource,
+                in nsIRDFResource aOldSource,
+                in nsIRDFResource aNewSource,
+                in nsIRDFResource aProperty,
+                in nsIRDFNode     aTarget);
+
+    /**
+     * This method is called when a datasource is about to
+     * send several notifications at once. The observer can
+     * use this as a cue to optimize its behavior. The observer
+     * can expect the datasource to call endUpdateBatch() when
+     * the group of notifications has completed.
+     * @param aDataSource the datasource that is going to
+     *   be issuing the notifications.
+     */
+    void onBeginUpdateBatch(in nsIRDFDataSource aDataSource);
+
+    /**
+     * This method is called when a datasource has completed
+     * issuing a notification group.
+     * @param aDataSource the datasource that has finished
+     *   issuing a group of notifications
+     */
+    void onEndUpdateBatch(in nsIRDFDataSource aDataSource);
+};

rdf/base/nsIRDFPropagatableDataSource.idl

@@ -0,0 +1,27 @@
+/* -*- Mode: idl; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+
+#include "nsISupports.idl"
+
+/**
+ * An nsIRDFPropagatableDataSource provides an ability to suppress
+ * synchronization notifications.
+ */
+[scriptable, uuid(5a9b4770-9fcb-4307-a12e-4b6708e78b97)]
+interface nsIRDFPropagatableDataSource: nsISupports {
+
+  /**
+   * Set this value to <code>true</code> to enable synchronization
+   * notifications.
+   *
+   * Set this value to <code>false</code> to disable synchronization
+   * notifications.
+   *
+   * By default, this value is <code>true</code>.
+   */
+  attribute boolean propagateChanges;
+
+};

rdf/base/nsIRDFPurgeableDataSource.idl

@@ -0,0 +1,19 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "nsIRDFResource.idl"
+#include "nsIRDFNode.idl"
+
+[scriptable, uuid(951700F0-FED0-11D2-BDD9-00104BDE6048)]
+interface nsIRDFPurgeableDataSource : nsISupports
+{
+    boolean Mark(in nsIRDFResource aSource,
+                 in nsIRDFResource aProperty,
+                 in nsIRDFNode aTarget,
+                 in boolean aTruthValue);
+
+    void Sweep();
+};

rdf/base/nsIRDFRemoteDataSource.idl

@@ -0,0 +1,44 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+/**
+ * A datasource that may load asynchronously
+ */
+[scriptable, uuid(1D297320-27F7-11d3-BE01-000064657374)]
+interface nsIRDFRemoteDataSource : nsISupports
+{
+    /**
+     * This value is <code>true</code> when the datasource has
+     * fully loaded itself.
+     */
+    readonly attribute boolean loaded;
+
+    /**
+     * Specify the URI for the data source: this is the prefix
+     * that will be used to register the data source in the
+     * data source registry.
+     * @param aURI the URI to load
+     */
+    void Init(in string aURI);
+
+    /**
+     * Refresh the remote datasource, re-loading its contents
+     * from the URI.
+     *
+     * @param aBlocking If <code>true</code>, the call will block
+     * until the datasource has completely reloaded.
+     */
+    void Refresh(in boolean aBlocking);
+
+    /**
+     * Request that a data source write its contents out to 
+     * permanent storage, if applicable.
+     */
+    void Flush();
+    void FlushTo(in string aURI);
+};
+

rdf/base/nsIRDFResource.idl

@@ -0,0 +1,81 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsrootidl.idl"
+#include "nsIRDFNode.idl"
+
+
+/**
+ * An nsIRDFResource is an object that has unique identity in the 
+ * RDF data model. The object's identity is determined by its URI.
+ */
+[scriptable, uuid(fb9686a7-719a-49dc-9107-10dea5739341)]
+interface nsIRDFResource : nsIRDFNode {
+    /**
+     * The single-byte string value of the resource.
+     * @note THIS IS OBSOLETE. C++ should use GetValueConst and script
+     *       should use .valueUTF8
+     */
+    readonly attribute string Value;
+
+    /**
+     * The UTF-8 URI of the resource.
+     */
+    readonly attribute AUTF8String ValueUTF8;
+
+    /**
+     * An unscriptable version used to avoid a string copy. Meant
+     * for use as a performance optimization. The string is encoded
+     * in UTF-8.
+     */
+    [noscript] void GetValueConst([shared] out string aConstValue);
+
+    /**
+     * This method is called by the nsIRDFService after constructing
+     * a resource object to initialize its URI. You would not normally
+     * call this method directly
+     */
+    void Init(in string uri);
+
+    /**
+     * Determine if the resource has the given URI.
+     */
+    boolean EqualsString(in string aURI);
+
+    /**
+     * Retrieve the "delegate" object for this resource. A resource
+     * may have several delegate objects, each of whose lifetimes is
+     * bound to the life of the resource object.
+     *
+     * This method will return the delegate for the given key after
+     * QueryInterface()-ing it to the requested IID.
+     *
+     * If no delegate exists for the specified key, this method will
+     * attempt to create one using the component manager. Specifically,
+     * it will combine aKey with the resource's URI scheme to produce
+     * a ContractID as follows:
+     *
+     *   component:/rdf/delegate-factory/[key]/[scheme]
+     *
+     * This ContractID will be used to locate a factory using the
+     * FindFactory() method of nsIComponentManager. If the nsIFactory
+     * exists, it will be used to create a "delegate factory"; that
+     * is, an object that supports nsIRDFDelegateFactory. The delegate
+     * factory will be used to construct the delegate object.
+     */
+    void GetDelegate(in string aKey, in nsIIDRef aIID,
+                     [iid_is(aIID),retval] out nsQIResult aResult);
+
+    /**
+     * Force a delegate to be "unbound" from the resource.
+     *
+     * Normally, a delegate object's lifetime will be identical to
+     * that of the resource to which it is bound; this method allows a
+     * delegate to unlink itself from an RDF resource prematurely.
+     */
+    void ReleaseDelegate(in string aKey);
+};
+
+

rdf/base/nsIRDFService.idl

@@ -0,0 +1,146 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "nsIRDFResource.idl"
+#include "nsIRDFLiteral.idl"
+#include "nsIRDFDataSource.idl"
+
+
+/**
+ * The RDF service interface. This is a singleton object which should be
+ * obtained from the <code>nsServiceManager</code>.
+ */
+[scriptable, uuid(BFD05261-834C-11d2-8EAC-00805F29F370)]
+interface nsIRDFService : nsISupports {
+    /**
+     * Construct an RDF resource from a single-byte URI. <code>nsIRDFService</code>
+     * caches resources that are in-use, so multiple calls to <code>GetResource()</code>
+     * for the same <code>uri</code> will return identical pointers. FindResource
+     * is used to find out whether there already exists a resource corresponding to that url.
+     */
+    nsIRDFResource GetResource(in AUTF8String aURI);
+
+    /**
+     * Construct an RDF resource from a Unicode URI. This is provided
+     * as a convenience method, allowing automatic, in-line C++
+     * conversion from <code>nsString</code> objects. The <code>uri</code> will
+     * be converted to a single-byte representation internally.
+     */
+    nsIRDFResource GetUnicodeResource(in AString aURI);
+
+    nsIRDFResource GetAnonymousResource();
+
+    /**
+     * Construct an RDF literal from a Unicode string.
+     */
+    nsIRDFLiteral  GetLiteral(in wstring aValue);
+
+    /**
+     * Construct an RDF literal from a PRTime.
+     */
+    nsIRDFDate     GetDateLiteral(in PRTime aValue);
+
+    /**
+     * Construct an RDF literal from an int.
+     */
+    nsIRDFInt      GetIntLiteral(in long aValue);
+
+    /**
+     * Construct an RDF literal from a data blob
+     */
+    [noscript] nsIRDFBlob getBlobLiteral(in const_octet_ptr aValue, in long aLength);
+
+    boolean IsAnonymousResource(in nsIRDFResource aResource);
+
+    /**
+     * Registers a resource with the RDF system, making it unique w.r.t.
+     * GetResource.
+     *
+     * An implementation of nsIRDFResource should call this in its
+     * Init() method if it wishes the resource to be globally unique
+     * (which is usually the case).
+     *
+     * @note that the resource will <i>not</i> be ref-counted by the
+     * RDF service: the assumption is that the resource implementation
+     * will call nsIRDFService::UnregisterResource() when the last
+     * reference to the resource is released.
+     *
+     * @note that the nsIRDFService implementation may choose to
+     * maintain a reference to the resource's URI; therefore, the
+     * resource implementation should ensure that the resource's URI
+     * (accessible via nsIRDFResource::GetValue(const char* *aURI)) is
+     * valid before calling RegisterResource(). Furthermore, the
+     * resource implementation should ensure that this pointer
+     * <i>remains</i> valid for the lifetime of the resource. (The
+     * implementation of the resource cache in nsIRDFService uses the
+     * URI maintained "internally" in the resource as a key into the
+     * cache rather than copying the resource URI itself.)
+     */
+    void RegisterResource(in nsIRDFResource aResource, in boolean aReplace);
+
+    /**
+     * Called to notify the resource manager that a resource is no
+     * longer in use. This method should only be called from the
+     * destructor of a "custom" resource implementation to notify the
+     * RDF service that the last reference to the resource has been
+     * released, so the resource is no longer valid.
+     *
+     * @note As mentioned in nsIRDFResourceFactory::CreateResource(),
+     * the RDF service will use the result of
+     * nsIRDFResource::GetValue() as a key into its cache. For this
+     * reason, you must always un-cache the resource <b>before</b>
+     * releasing the storage for the <code>const char*</code> URI.
+     */
+    void UnregisterResource(in nsIRDFResource aResource);
+
+    /**
+     * Register a <i>named data source</i>. The RDF service will call
+     * <code>nsIRDFDataSource::GetURI()</code> to determine the URI under
+     * which to register the data source.
+     *
+     * @note that the data source will <i>not</i> be refcounted by the
+     * RDF service! The assumption is that an RDF data source
+     * registers with the service once it is initialized (via
+     * <code>nsIRDFDataSource::Init()</code>), and unregisters when the
+     * last reference to the data source is released.
+     */
+    void RegisterDataSource(in nsIRDFDataSource aDataSource,
+                            in boolean          aReplace);
+
+    /**
+     * Unregister a <i>named data source</i>. The RDF service will call
+     * <code>nsIRDFDataSource::GetURI()</code> to determine the URI under which the
+     * data source was registered.
+     */
+    void UnregisterDataSource(in nsIRDFDataSource aDataSource);
+
+    /**
+     * Get the <i>named data source</i> corresponding to the URI. If a data
+     * source has been registered via <code>RegisterDataSource()</code>, that
+     * data source will be returned.
+     *
+     * If no data source is currently
+     * registered for the specified URI, and a data source <i>constructor</i>
+     * function has been registered via <code>RegisterDatasourceConstructor()</code>,
+     * the RDF service will call the constructor to attempt to construct a
+     * new data source. If construction is successful, the data source will
+     * be initialized via <code>nsIRDFDataSource::Init()</code>.
+     */
+    nsIRDFDataSource GetDataSource(in string aURI);
+
+    /**
+     * Same as GetDataSource, but if a remote/XML data source needs to be
+     * constructed, then this method will issue a <b>blocking</b> Refresh
+     * call on that data source.
+     */
+    nsIRDFDataSource GetDataSourceBlocking(in string aURI);
+};
+
+%{C++
+extern nsresult
+NS_NewRDFService(nsIRDFService** result);
+%}
+

rdf/base/nsIRDFXMLParser.idl

@@ -0,0 +1,33 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "nsIRDFDataSource.idl"
+#include "nsIStreamListener.idl"
+#include "nsIURI.idl"
+
+[scriptable, uuid(1831dd2e-1dd2-11b2-bdb3-86b7b50b70b5)]
+interface nsIRDFXMLParser : nsISupports
+{
+    /**
+     * Create a stream listener that can be used to asynchronously
+     * parse RDF/XML.
+     * @param aSink the RDF datasource the will receive the data
+     * @param aBaseURI the base URI used to resolve relative
+     *   references in the RDF/XML
+     * @return an nsIStreamListener object to handle the data
+     */
+    nsIStreamListener parseAsync(in nsIRDFDataSource aSink, in nsIURI aBaseURI);
+
+    /**
+     * Parse a string of RDF/XML
+     * @param aSink the RDF datasource that will receive the data
+     * @param aBaseURI the base URI used to resolve relative
+     *   references in the RDF/XML
+     * @param aSource a UTF8 string containing RDF/XML data.
+     */
+    void parseString(in nsIRDFDataSource aSink, in nsIURI aBaseURI, in AUTF8String aSource);
+};

rdf/base/nsIRDFXMLSerializer.idl

@@ -0,0 +1,31 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "nsIRDFDataSource.idl"
+
+%{C++
+class nsAtom;
+%}
+[ptr] native nsAtomPtr(nsAtom);
+
+[scriptable, uuid(8ae1fbf8-1dd2-11b2-bd21-d728069cca92)]
+interface nsIRDFXMLSerializer : nsISupports
+{
+    /**
+     * Initialize the serializer with the specified datasource.
+     * @param aDataSource the datasource from which data will be
+     *   serialized
+     */
+    void init(in nsIRDFDataSource aDataSource);
+
+    /**
+     * Add the specified namespace to the serializer.
+     * @param aPrefix the attribute namespace prefix
+     * @param aURI the namespace URI
+     */
+    [noscript] void addNameSpace(in nsAtomPtr aPrefix, in DOMString aURI);
+};

rdf/base/nsIRDFXMLSink.idl

@@ -0,0 +1,133 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+
+  Interfaces for the RDF/XML sink, which parses RDF/XML into
+  a graph representation.
+
+*/
+
+#include "nsISupports.idl"
+
+%{C++
+class nsAtom;
+%}
+[ptr] native nsAtomPtr(nsAtom);
+
+// XXX Until these get scriptable. See nsIRDFXMLSink::AddNameSpace()
+[ref] native nsStringRef(nsString);
+%{C++
+#include "nsStringFwd.h"
+%}
+
+interface nsIRDFXMLSink;
+
+/**
+ * An observer that is notified as progress is made on the load
+ * of an RDF/XML document in an <code>nsIRDFXMLSink</code>.
+ */
+[scriptable, uuid(EB1A5D30-AB33-11D2-8EC6-00805F29F370)]
+interface nsIRDFXMLSinkObserver : nsISupports
+{
+    /**
+     * Called when the load begins.
+     * @param aSink the RDF/XML sink on which the load is beginning.
+     */
+    void onBeginLoad(in nsIRDFXMLSink aSink);
+
+    /**
+     * Called when the load is suspended (e.g., for network quantization).
+     * @param aSink the RDF/XML sink that is being interrupted.
+     */
+    void onInterrupt(in nsIRDFXMLSink aSink);
+
+    /**
+     * Called when a suspended load is resuming.
+     * @param aSink the RDF/XML sink that is resuming.
+     */
+    void onResume(in nsIRDFXMLSink aSink);
+
+    /**
+     * Called when an RDF/XML load completes successfully.
+     * @param aSink the RDF/XML sink that has finished loading.
+     */
+    void onEndLoad(in nsIRDFXMLSink aSink);
+
+    /**
+     * Called when an error occurs during the load
+     * @param aSink the RDF/XML sink in which the error occurred
+     * @param aStatus the networking result code
+     * @param aErrorMsg an error message, if applicable
+     */
+    void onError(in nsIRDFXMLSink aSink, in nsresult aStatus, in wstring aErrorMsg);
+};
+
+
+
+/**
+ * A "sink" that receives and processes RDF/XML. This interface is used
+ * by the RDF/XML parser.
+ */
+[scriptable, uuid(EB1A5D31-AB33-11D2-8EC6-00805F29F370)]
+interface nsIRDFXMLSink : nsISupports
+{
+    /**
+     * Set to <code>true</code> if the sink is read-only and cannot
+     * be modified
+     */
+    attribute boolean readOnly;
+
+    /**
+     * Initiate the RDF/XML load.
+     */
+    void beginLoad();
+
+    /**
+     * Suspend the RDF/XML load.
+     */
+    void interrupt();
+
+    /**
+     * Resume the RDF/XML load.
+     */
+    void resume();
+
+    /**
+     * Complete the RDF/XML load.
+     */
+    void endLoad();
+
+    /**
+     * Add namespace information to the RDF/XML sink.
+     * @param aPrefix the namespace prefix
+     * @param aURI the namespace URI
+     */
+    [noscript] void addNameSpace(in nsAtomPtr aPrefix,
+                                 [const] in nsStringRef aURI);
+
+    /**
+     * Add an observer that will be notified as the RDF/XML load
+     * progresses.
+     * <p>
+     *
+     * Note that the sink will acquire a strong reference to the
+     * observer, so care should be taken to avoid cyclical references
+     * that cannot be released (i.e., if the observer holds a
+     * reference to the sink, it should be sure that it eventually
+     * clears the reference).
+     *
+     * @param aObserver the observer to add to the sink's set of
+     * load observers.
+     */
+    void addXMLSinkObserver(in nsIRDFXMLSinkObserver aObserver);
+
+    /**
+     * Remove an observer from the sink's set of observers.
+     * @param aObserver the observer to remove.
+     */
+    void removeXMLSinkObserver(in nsIRDFXMLSinkObserver aObserver);
+};
+

rdf/base/nsIRDFXMLSource.idl

@@ -0,0 +1,20 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+#include "nsIOutputStream.idl"
+
+[scriptable, uuid(4DA56F10-99FE-11d2-8EBB-00805F29F370)]
+interface nsIRDFXMLSource : nsISupports
+{
+    /**
+     * Serialize the contents of the datasource to aStream.
+     * @param aStream the output stream the will receive the
+     *   RDF/XML. Currently, the output stream need only
+     *   implement the |write()| method.
+     */
+    void Serialize(in nsIOutputStream aStream);
+};
+

rdf/base/nsNameSpaceMap.cpp

@@ -0,0 +1,64 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsNameSpaceMap.h"
+#include "nsReadableUtils.h"
+
+nsNameSpaceMap::nsNameSpaceMap()
+    : mEntries(nullptr)
+{
+    MOZ_COUNT_CTOR(nsNameSpaceMap);
+}
+
+nsNameSpaceMap::~nsNameSpaceMap()
+{
+    MOZ_COUNT_DTOR(nsNameSpaceMap);
+
+    while (mEntries) {
+        Entry* doomed = mEntries;
+        mEntries = mEntries->mNext;
+        delete doomed;
+    }
+}
+
+nsresult
+nsNameSpaceMap::Put(const nsAString& aURI, nsAtom* aPrefix)
+{
+    nsCString uriUTF8;
+    AppendUTF16toUTF8(aURI, uriUTF8);
+    return Put(uriUTF8, aPrefix);
+}
+
+nsresult
+nsNameSpaceMap::Put(const nsACString& aURI, nsAtom* aPrefix)
+{
+    Entry* entry;
+
+    // Make sure we're not adding a duplicate
+    for (entry = mEntries; entry != nullptr; entry = entry->mNext) {
+        if (entry->mURI == aURI || entry->mPrefix == aPrefix)
+            return NS_ERROR_FAILURE;
+    }
+
+    entry = new Entry(aURI, aPrefix);
+    if (! entry)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    entry->mNext = mEntries;
+    mEntries = entry;
+    return NS_OK;
+}
+
+nsNameSpaceMap::const_iterator
+nsNameSpaceMap::GetNameSpaceOf(const nsACString& aURI) const
+{
+    for (Entry* entry = mEntries; entry != nullptr; entry = entry->mNext) {
+        if (StringBeginsWith(aURI, entry->mURI))
+            return const_iterator(entry);
+    }
+
+    return last();
+}

rdf/base/nsNameSpaceMap.h

@@ -0,0 +1,98 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsNameSpaceMap_h__
+#define nsNameSpaceMap_h__
+
+#include "nsCOMPtr.h"
+#include "nsString.h"
+#include "nsAtom.h"
+
+class nsNameSpaceMap
+{
+public:
+    class Entry {
+    public:
+        Entry(const nsACString& aURI, nsAtom* aPrefix)
+            : mURI(aURI), mPrefix(aPrefix), mNext(nullptr) {
+            MOZ_COUNT_CTOR(nsNameSpaceMap::Entry); }
+
+        ~Entry() { MOZ_COUNT_DTOR(nsNameSpaceMap::Entry); }
+
+        nsCString mURI;
+        RefPtr<nsAtom> mPrefix;
+
+        Entry* mNext;
+    };
+
+    nsNameSpaceMap();
+    ~nsNameSpaceMap();
+
+    nsresult
+    Put(const nsAString& aURI, nsAtom* aPrefix);
+
+    nsresult
+    Put(const nsACString& aURI, nsAtom* aPrefix);
+
+    class const_iterator {
+    protected:
+        friend class nsNameSpaceMap;
+
+        explicit const_iterator(const Entry* aCurrent)
+            : mCurrent(aCurrent) {}
+
+        const Entry* mCurrent;
+
+    public:
+        const_iterator()
+            : mCurrent(nullptr) {}
+
+        const_iterator(const const_iterator& iter)
+            : mCurrent(iter.mCurrent) {}
+
+        const_iterator&
+        operator=(const const_iterator& iter) {
+            mCurrent = iter.mCurrent;
+            return *this; }
+
+        const_iterator&
+        operator++() {
+            mCurrent = mCurrent->mNext;
+            return *this; }
+
+        const_iterator
+        operator++(int) {
+            const_iterator tmp(*this);
+            mCurrent = mCurrent->mNext;
+            return tmp; }
+
+        const Entry* operator->() const { return mCurrent; }
+
+        const Entry& operator*() const { return *mCurrent; }
+
+        bool
+        operator==(const const_iterator& iter) const {
+            return mCurrent == iter.mCurrent; }
+
+        bool
+        operator!=(const const_iterator& iter) const {
+            return ! iter.operator==(*this); }
+    };
+
+    const_iterator first() const {
+        return const_iterator(mEntries); }
+
+    const_iterator last() const {
+        return const_iterator(nullptr); }
+
+    const_iterator GetNameSpaceOf(const nsACString& aURI) const;
+
+protected:
+    Entry* mEntries;
+};
+
+
+#endif // nsNameSpaceMap_h__

rdf/base/nsRDFBaseDataSources.h

@@ -0,0 +1,32 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+
+  This header file just contains prototypes for the factory methods
+  for "builtin" data sources that are included in rdf.dll.
+
+  Each of these data sources is exposed to the external world via its
+  CID in ../include/nsRDFCID.h.
+
+*/
+
+#ifndef nsBaseDataSources_h__
+#define nsBaseDataSources_h__
+
+#include "nsError.h"
+class nsIRDFDataSource;
+
+// in nsInMemoryDataSource.cpp
+nsresult
+NS_NewRDFInMemoryDataSource(nsISupports* aOuter, const nsIID& aIID, void** aResult);
+
+// in nsRDFXMLDataSource.cpp
+extern nsresult
+NS_NewRDFXMLDataSource(nsIRDFDataSource** aResult);
+
+#endif // nsBaseDataSources_h__
+
+

rdf/base/nsRDFContainer.cpp

@@ -0,0 +1,724 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+
+  Implementation for the RDF container.
+
+  Notes
+  -----
+
+  1. RDF containers are one-indexed. This means that a lot of the loops
+     that you'd normally think you'd write like this:
+
+       for (i = 0; i < count; ++i) {}
+
+     You've gotta write like this:
+
+       for (i = 1; i <= count; ++i) {}
+
+     "Sure, right, yeah, of course.", you say. Well maybe I'm just
+     thick, but it's easy to slip up.
+
+  2. The RDF:nextVal property on the container is an
+     implementation-level hack that is used to quickly compute the
+     next value for appending to the container. It will no doubt
+     become royally screwed up in the case of aggregation.
+
+  3. The RDF:nextVal property is also used to retrieve the count of
+     elements in the container.
+
+ */
+
+
+#include "nsCOMPtr.h"
+#include "nsIRDFContainer.h"
+#include "nsIRDFContainerUtils.h"
+#include "nsIRDFInMemoryDataSource.h"
+#include "nsIRDFPropagatableDataSource.h"
+#include "nsIRDFService.h"
+#include "nsIServiceManager.h"
+#include "nsRDFCID.h"
+#include "nsString.h"
+#include "rdf.h"
+
+#define RDF_SEQ_LIST_LIMIT   8
+
+class RDFContainerImpl : public nsIRDFContainer
+{
+public:
+
+    // nsISupports interface
+    NS_DECL_ISUPPORTS
+
+    // nsIRDFContainer interface
+    NS_DECL_NSIRDFCONTAINER
+
+private:
+    friend nsresult NS_NewRDFContainer(nsIRDFContainer** aResult);
+
+    RDFContainerImpl();
+    virtual ~RDFContainerImpl();
+
+    nsresult Init();
+
+    nsresult Renumber(int32_t aStartIndex, int32_t aIncrement);
+    nsresult SetNextValue(int32_t aIndex);
+    nsresult GetNextValue(nsIRDFResource** aResult);
+
+    nsIRDFDataSource* mDataSource;
+    nsIRDFResource*   mContainer;
+
+    // pseudo constants
+    static int32_t gRefCnt;
+    static nsIRDFService*        gRDFService;
+    static nsIRDFContainerUtils* gRDFContainerUtils;
+    static nsIRDFResource*       kRDF_nextVal;
+};
+
+
+int32_t               RDFContainerImpl::gRefCnt = 0;
+nsIRDFService*        RDFContainerImpl::gRDFService;
+nsIRDFContainerUtils* RDFContainerImpl::gRDFContainerUtils;
+nsIRDFResource*       RDFContainerImpl::kRDF_nextVal;
+
+////////////////////////////////////////////////////////////////////////
+// nsISupports interface
+
+NS_IMPL_ISUPPORTS(RDFContainerImpl, nsIRDFContainer)
+
+
+
+////////////////////////////////////////////////////////////////////////
+// nsIRDFContainer interface
+
+NS_IMETHODIMP
+RDFContainerImpl::GetDataSource(nsIRDFDataSource** _retval)
+{
+    *_retval = mDataSource;
+    NS_IF_ADDREF(*_retval);
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+RDFContainerImpl::GetResource(nsIRDFResource** _retval)
+{
+    *_retval = mContainer;
+    NS_IF_ADDREF(*_retval);
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+RDFContainerImpl::Init(nsIRDFDataSource *aDataSource, nsIRDFResource *aContainer)
+{
+    NS_PRECONDITION(aDataSource != nullptr, "null ptr");
+    if (! aDataSource)
+        return NS_ERROR_NULL_POINTER;
+
+    NS_PRECONDITION(aContainer != nullptr, "null ptr");
+    if (! aContainer)
+        return NS_ERROR_NULL_POINTER;
+
+    nsresult rv;
+    bool isContainer;
+    rv = gRDFContainerUtils->IsContainer(aDataSource, aContainer, &isContainer);
+    if (NS_FAILED(rv)) return rv;
+
+    // ``throw'' if we can't create a container on the specified
+    // datasource/resource combination.
+    if (! isContainer)
+        return NS_ERROR_FAILURE;
+
+    NS_IF_RELEASE(mDataSource);
+    mDataSource = aDataSource;
+    NS_ADDREF(mDataSource);
+
+    NS_IF_RELEASE(mContainer);
+    mContainer = aContainer;
+    NS_ADDREF(mContainer);
+
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+RDFContainerImpl::GetCount(int32_t *aCount)
+{
+    if (!mDataSource || !mContainer)
+        return NS_ERROR_NOT_INITIALIZED;
+
+    nsresult rv;
+
+    // Get the next value, which hangs off of the bag via the
+    // RDF:nextVal property. This is the _next value_ that will get
+    // assigned in a one-indexed array. So, it's actually _one more_
+    // than the actual count of elements in the container.
+    //
+    // XXX To handle aggregation, this should probably be a
+    // GetTargets() that enumerates all of the values and picks the
+    // largest one.
+    nsCOMPtr<nsIRDFNode> nextValNode;
+    rv = mDataSource->GetTarget(mContainer, kRDF_nextVal, true, getter_AddRefs(nextValNode));
+    if (NS_FAILED(rv)) return rv;
+
+    if (rv == NS_RDF_NO_VALUE)
+        return NS_ERROR_UNEXPECTED;
+
+    nsCOMPtr<nsIRDFLiteral> nextValLiteral;
+    rv = nextValNode->QueryInterface(NS_GET_IID(nsIRDFLiteral), getter_AddRefs(nextValLiteral));
+    if (NS_FAILED(rv)) return rv;
+
+    const char16_t *s;
+    rv = nextValLiteral->GetValueConst( &s );
+    if (NS_FAILED(rv)) return rv;
+
+    nsAutoString nextValStr(s);
+
+    int32_t nextVal;
+    nsresult err;
+    nextVal = nextValStr.ToInteger(&err);
+    if (NS_FAILED(err))
+        return NS_ERROR_UNEXPECTED;
+
+    *aCount = nextVal - 1;
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+RDFContainerImpl::GetElements(nsISimpleEnumerator **_retval)
+{
+    if (!mDataSource || !mContainer)
+        return NS_ERROR_NOT_INITIALIZED;
+
+    return NS_NewContainerEnumerator(mDataSource, mContainer, _retval);
+}
+
+
+NS_IMETHODIMP
+RDFContainerImpl::AppendElement(nsIRDFNode *aElement)
+{
+    if (!mDataSource || !mContainer)
+        return NS_ERROR_NOT_INITIALIZED;
+
+    NS_PRECONDITION(aElement != nullptr, "null ptr");
+    if (! aElement)
+        return NS_ERROR_NULL_POINTER;
+
+    nsresult rv;
+
+    nsCOMPtr<nsIRDFResource> nextVal;
+    rv = GetNextValue(getter_AddRefs(nextVal));
+    if (NS_FAILED(rv)) return rv;
+
+    rv = mDataSource->Assert(mContainer, nextVal, aElement, true);
+    if (NS_FAILED(rv)) return rv;
+
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+RDFContainerImpl::RemoveElement(nsIRDFNode *aElement, bool aRenumber)
+{
+    if (!mDataSource || !mContainer)
+        return NS_ERROR_NOT_INITIALIZED;
+
+    NS_PRECONDITION(aElement != nullptr, "null ptr");
+    if (! aElement)
+        return NS_ERROR_NULL_POINTER;
+
+    nsresult rv;
+
+    int32_t idx;
+    rv = IndexOf(aElement, &idx);
+    if (NS_FAILED(rv)) return rv;
+
+    if (idx < 0)
+        return NS_OK;
+
+    // Remove the element.
+    nsCOMPtr<nsIRDFResource> ordinal;
+    rv = gRDFContainerUtils->IndexToOrdinalResource(idx,
+                                                    getter_AddRefs(ordinal));
+    if (NS_FAILED(rv)) return rv;
+
+    rv = mDataSource->Unassert(mContainer, ordinal, aElement);
+    if (NS_FAILED(rv)) return rv;
+
+    if (aRenumber) {
+        // Now slide the rest of the collection backwards to fill in
+        // the gap. This will have the side effect of completely
+        // renumber the container from index to the end.
+        rv = Renumber(idx + 1, -1);
+        if (NS_FAILED(rv)) return rv;
+    }
+
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+RDFContainerImpl::InsertElementAt(nsIRDFNode *aElement, int32_t aIndex, bool aRenumber)
+{
+    if (!mDataSource || !mContainer)
+        return NS_ERROR_NOT_INITIALIZED;
+
+    NS_PRECONDITION(aElement != nullptr, "null ptr");
+    if (! aElement)
+        return NS_ERROR_NULL_POINTER;
+
+    NS_PRECONDITION(aIndex >= 1, "illegal value");
+    if (aIndex < 1)
+        return NS_ERROR_ILLEGAL_VALUE;
+
+    nsresult rv;
+
+    int32_t count;
+    rv = GetCount(&count);
+    if (NS_FAILED(rv)) return rv;
+
+    NS_ASSERTION(aIndex <= count + 1, "illegal value");
+    if (aIndex > count + 1)
+        return NS_ERROR_ILLEGAL_VALUE;
+
+    if (aRenumber) {
+        // Make a hole for the element. This will have the side effect of
+        // completely renumbering the container from 'aIndex' to 'count',
+        // and will spew assertions.
+        rv = Renumber(aIndex, +1);
+        if (NS_FAILED(rv)) return rv;
+    }
+
+    nsCOMPtr<nsIRDFResource> ordinal;
+    rv = gRDFContainerUtils->IndexToOrdinalResource(aIndex, getter_AddRefs(ordinal));
+    if (NS_FAILED(rv)) return rv;
+
+    rv = mDataSource->Assert(mContainer, ordinal, aElement, true);
+    if (NS_FAILED(rv)) return rv;
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+RDFContainerImpl::RemoveElementAt(int32_t aIndex, bool aRenumber, nsIRDFNode** _retval)
+{
+    if (!mDataSource || !mContainer)
+        return NS_ERROR_NOT_INITIALIZED;
+
+    *_retval = nullptr;
+
+    if (aIndex< 1)
+        return NS_ERROR_ILLEGAL_VALUE;
+
+    nsresult rv;
+
+    int32_t count;
+    rv = GetCount(&count);
+    if (NS_FAILED(rv)) return rv;
+
+    if (aIndex > count)
+        return NS_ERROR_ILLEGAL_VALUE;
+
+    nsCOMPtr<nsIRDFResource> ordinal;
+    rv = gRDFContainerUtils->IndexToOrdinalResource(aIndex, getter_AddRefs(ordinal));
+    if (NS_FAILED(rv)) return rv;
+
+    nsCOMPtr<nsIRDFNode> old;
+    rv = mDataSource->GetTarget(mContainer, ordinal, true, getter_AddRefs(old));
+    if (NS_FAILED(rv)) return rv;
+
+    if (rv == NS_OK) {
+        rv = mDataSource->Unassert(mContainer, ordinal, old);
+        if (NS_FAILED(rv)) return rv;
+
+        if (aRenumber) {
+            // Now slide the rest of the collection backwards to fill in
+            // the gap. This will have the side effect of completely
+            // renumber the container from index to the end.
+            rv = Renumber(aIndex + 1, -1);
+            if (NS_FAILED(rv)) return rv;
+        }
+    }
+
+    old.swap(*_retval);
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+RDFContainerImpl::IndexOf(nsIRDFNode *aElement, int32_t *aIndex)
+{
+    if (!mDataSource || !mContainer)
+        return NS_ERROR_NOT_INITIALIZED;
+
+    return gRDFContainerUtils->IndexOf(mDataSource, mContainer,
+                                       aElement, aIndex);
+}
+
+
+////////////////////////////////////////////////////////////////////////
+
+
+RDFContainerImpl::RDFContainerImpl()
+    : mDataSource(nullptr), mContainer(nullptr)
+{
+}
+
+
+nsresult
+RDFContainerImpl::Init()
+{
+    if (gRefCnt++ == 0) {
+        nsresult rv;
+
+        NS_DEFINE_CID(kRDFServiceCID, NS_RDFSERVICE_CID);
+        rv = CallGetService(kRDFServiceCID, &gRDFService);
+        if (NS_FAILED(rv)) {
+            NS_ERROR("unable to get RDF service");
+            return rv;
+        }
+
+        rv = gRDFService->GetResource(NS_LITERAL_CSTRING(RDF_NAMESPACE_URI "nextVal"),
+                                      &kRDF_nextVal);
+        if (NS_FAILED(rv)) return rv;
+
+        NS_DEFINE_CID(kRDFContainerUtilsCID, NS_RDFCONTAINERUTILS_CID);
+        rv = CallGetService(kRDFContainerUtilsCID, &gRDFContainerUtils);
+        if (NS_FAILED(rv)) {
+            NS_ERROR("unable to get RDF container utils service");
+            return rv;
+        }
+    }
+
+    return NS_OK;
+}
+
+
+RDFContainerImpl::~RDFContainerImpl()
+{
+#ifdef DEBUG_REFS
+    --gInstanceCount;
+    fprintf(stdout, "%d - RDF: RDFContainerImpl\n", gInstanceCount);
+#endif
+
+    NS_IF_RELEASE(mContainer);
+    NS_IF_RELEASE(mDataSource);
+
+    if (--gRefCnt == 0) {
+        NS_IF_RELEASE(gRDFContainerUtils);
+        NS_IF_RELEASE(gRDFService);
+        NS_IF_RELEASE(kRDF_nextVal);
+    }
+}
+
+
+nsresult
+NS_NewRDFContainer(nsIRDFContainer** aResult)
+{
+    RDFContainerImpl* result = new RDFContainerImpl();
+    if (! result)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    nsresult rv;
+    rv = result->Init();
+    if (NS_FAILED(rv)) {
+        delete result;
+        return rv;
+    }
+
+    NS_ADDREF(result);
+    *aResult = result;
+    return NS_OK;
+}
+
+
+nsresult
+NS_NewRDFContainer(nsIRDFDataSource* aDataSource,
+                   nsIRDFResource* aResource,
+                   nsIRDFContainer** aResult)
+{
+    nsresult rv;
+    rv = NS_NewRDFContainer(aResult);
+    if (NS_FAILED(rv)) return rv;
+
+    rv = (*aResult)->Init(aDataSource, aResource);
+    if (NS_FAILED(rv)) {
+        NS_RELEASE(*aResult);
+    }
+    return rv;
+}
+
+
+nsresult
+RDFContainerImpl::Renumber(int32_t aStartIndex, int32_t aIncrement)
+{
+    if (!mDataSource || !mContainer)
+        return NS_ERROR_NOT_INITIALIZED;
+
+    // Renumber the elements in the container starting with
+    // aStartIndex, updating each element's index by aIncrement. For
+    // example,
+    //
+    //   (1:a 2:b 3:c)
+    //   Renumber(2, +1);
+    //   (1:a 3:b 4:c)
+    //   Renumber(3, -1);
+    //   (1:a 2:b 3:c)
+    //
+    nsresult rv;
+
+    if (! aIncrement)
+        return NS_OK;
+
+    int32_t count;
+    rv = GetCount(&count);
+    if (NS_FAILED(rv)) return rv;
+
+    if (aIncrement > 0) {
+        // Update the container's nextVal to reflect the
+        // renumbering. We do this now if aIncrement > 0 because we'll
+        // want to be able to acknowledge that new elements are in the
+        // container.
+        rv = SetNextValue(count + aIncrement + 1);
+        if (NS_FAILED(rv)) return rv;
+    }
+
+    int32_t i;
+    if (aIncrement < 0) {
+        i = aStartIndex;
+    }
+    else {
+        i = count; // we're one-indexed.
+    }
+
+    // Note: once we disable notifications, don't exit this method until
+    // enabling notifications
+    nsCOMPtr<nsIRDFPropagatableDataSource> propagatable =
+        do_QueryInterface(mDataSource);
+    if (propagatable) {
+        propagatable->SetPropagateChanges(false);
+    }
+
+    bool    err = false;
+    while (!err && ((aIncrement < 0) ? (i <= count) : (i >= aStartIndex)))
+    {
+        nsCOMPtr<nsIRDFResource> oldOrdinal;
+        rv = gRDFContainerUtils->IndexToOrdinalResource(i, getter_AddRefs(oldOrdinal));
+        if (NS_FAILED(rv))
+        {
+            err = true;
+            continue;
+        }
+
+        nsCOMPtr<nsIRDFResource> newOrdinal;
+        rv = gRDFContainerUtils->IndexToOrdinalResource(i + aIncrement, getter_AddRefs(newOrdinal));
+        if (NS_FAILED(rv))
+        {
+            err = true;
+            continue;
+        }
+
+        // Because of aggregation, we need to be paranoid about the
+        // possibility that >1 element may be present per ordinal. If
+        // there _is_ in fact more than one element, they'll all get
+        // assigned to the same new ordinal; i.e., we don't make any
+        // attempt to "clean up" the duplicate numbering. (Doing so
+        // would require two passes.)
+        nsCOMPtr<nsISimpleEnumerator> targets;
+        rv = mDataSource->GetTargets(mContainer, oldOrdinal, true, getter_AddRefs(targets));
+        if (NS_FAILED(rv))
+        {
+            err = true;
+            continue;
+        }
+
+        while (1) {
+            bool hasMore;
+            rv = targets->HasMoreElements(&hasMore);
+            if (NS_FAILED(rv))
+            {
+                err = true;
+                break;
+            }
+
+            if (! hasMore)
+                break;
+
+            nsCOMPtr<nsISupports> isupports;
+            rv = targets->GetNext(getter_AddRefs(isupports));
+            if (NS_FAILED(rv))
+            {
+                err = true;
+                break;
+            }
+
+            nsCOMPtr<nsIRDFNode> element( do_QueryInterface(isupports) );
+            NS_ASSERTION(element != nullptr, "something funky in the enumerator");
+            if (! element)
+            {
+                err = true;
+                rv = NS_ERROR_UNEXPECTED;
+                break;
+            }
+
+            rv = mDataSource->Unassert(mContainer, oldOrdinal, element);
+            if (NS_FAILED(rv))
+            {
+                err = true;
+                break;
+            }
+
+            rv = mDataSource->Assert(mContainer, newOrdinal, element, true);
+            if (NS_FAILED(rv))
+            {
+                err = true;
+                break;
+            }
+        }
+
+        i -= aIncrement;
+    }
+
+    if (!err && (aIncrement < 0))
+    {
+        // Update the container's nextVal to reflect the
+        // renumbering. We do this now if aIncrement < 0 because, up
+        // until this point, we'll want people to be able to find
+        // things that are still "at the end".
+        rv = SetNextValue(count + aIncrement + 1);
+        if (NS_FAILED(rv))
+        {
+            err = true;
+        }
+    }
+
+    // Note: MUST enable notifications before exiting this method
+    if (propagatable) {
+        propagatable->SetPropagateChanges(true);
+    }
+
+    if (err) return(rv);
+
+    return NS_OK;
+}
+
+
+
+nsresult
+RDFContainerImpl::SetNextValue(int32_t aIndex)
+{
+    if (!mDataSource || !mContainer)
+        return NS_ERROR_NOT_INITIALIZED;
+
+    nsresult rv;
+
+    // Remove the current value of nextVal, if there is one.
+    nsCOMPtr<nsIRDFNode> nextValNode;
+    if (NS_SUCCEEDED(rv = mDataSource->GetTarget(mContainer,
+                                                 kRDF_nextVal,
+                                                 true,
+                                                 getter_AddRefs(nextValNode)))) {
+        if (NS_FAILED(rv = mDataSource->Unassert(mContainer, kRDF_nextVal, nextValNode))) {
+            NS_ERROR("unable to update nextVal");
+            return rv;
+        }
+    }
+
+    nsAutoString s;
+    s.AppendInt(aIndex, 10);
+
+    nsCOMPtr<nsIRDFLiteral> nextVal;
+    if (NS_FAILED(rv = gRDFService->GetLiteral(s.get(), getter_AddRefs(nextVal)))) {
+        NS_ERROR("unable to get nextVal literal");
+        return rv;
+    }
+
+    rv = mDataSource->Assert(mContainer, kRDF_nextVal, nextVal, true);
+    if (rv != NS_RDF_ASSERTION_ACCEPTED) {
+        NS_ERROR("unable to update nextVal");
+        return NS_ERROR_FAILURE;
+    }
+
+    return NS_OK;
+}
+
+
+nsresult
+RDFContainerImpl::GetNextValue(nsIRDFResource** aResult)
+{
+    if (!mDataSource || !mContainer)
+        return NS_ERROR_NOT_INITIALIZED;
+
+    nsresult rv;
+
+    // Get the next value, which hangs off of the bag via the
+    // RDF:nextVal property.
+    nsCOMPtr<nsIRDFNode> nextValNode;
+    rv = mDataSource->GetTarget(mContainer, kRDF_nextVal, true, getter_AddRefs(nextValNode));
+    if (NS_FAILED(rv)) return rv;
+
+    if (rv == NS_RDF_NO_VALUE)
+        return NS_ERROR_UNEXPECTED;
+
+    nsCOMPtr<nsIRDFLiteral> nextValLiteral;
+    rv = nextValNode->QueryInterface(NS_GET_IID(nsIRDFLiteral), getter_AddRefs(nextValLiteral));
+    if (NS_FAILED(rv)) return rv;
+
+    const char16_t* s;
+    rv = nextValLiteral->GetValueConst(&s);
+    if (NS_FAILED(rv)) return rv;
+
+    int32_t nextVal = 0;
+    {
+        for (const char16_t* p = s; *p != 0; ++p) {
+            NS_ASSERTION(*p >= '0' && *p <= '9', "not a digit");
+            if (*p < '0' || *p > '9')
+                break;
+
+            nextVal *= 10;
+            nextVal += *p - '0';
+        }
+    }
+
+    static const char kRDFNameSpaceURI[] = RDF_NAMESPACE_URI;
+    nsAutoCStringN<sizeof(kRDFNameSpaceURI) + 16> nextValStr;
+    nextValStr = kRDFNameSpaceURI;
+    nextValStr.Append('_');
+    nextValStr.AppendInt(nextVal, 10);
+
+    rv = gRDFService->GetResource(nextValStr, aResult);
+    if (NS_FAILED(rv)) return rv;
+
+    // Now increment the RDF:nextVal property.
+    rv = mDataSource->Unassert(mContainer, kRDF_nextVal, nextValLiteral);
+    if (NS_FAILED(rv)) return rv;
+
+    ++nextVal;
+    nextValStr.Truncate();
+    nextValStr.AppendInt(nextVal, 10);
+
+    rv = gRDFService->GetLiteral(NS_ConvertASCIItoUTF16(nextValStr).get(), getter_AddRefs(nextValLiteral));
+    if (NS_FAILED(rv)) return rv;
+
+    rv = mDataSource->Assert(mContainer, kRDF_nextVal, nextValLiteral, true);
+    if (NS_FAILED(rv)) return rv;
+
+    if (RDF_SEQ_LIST_LIMIT == nextVal)
+    {
+        // focal point for RDF container mutation;
+        // basically, provide a hint to allow for fast access
+        nsCOMPtr<nsIRDFInMemoryDataSource> inMem = do_QueryInterface(mDataSource);
+        if (inMem)
+        {
+            // ignore error; failure just means slower access
+            (void)inMem->EnsureFastContainment(mContainer);
+        }
+    }
+
+    return NS_OK;
+}

rdf/base/nsRDFContainerUtils.cpp

@@ -0,0 +1,513 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+
+  Implementation for the RDF container utils.
+
+ */
+
+
+#include "nsCOMPtr.h"
+#include "nsIServiceManager.h"
+#include "nsIRDFContainer.h"
+#include "nsIRDFContainerUtils.h"
+#include "nsIRDFService.h"
+#include "nsRDFCID.h"
+#include "nsString.h"
+#include "plstr.h"
+#include "rdf.h"
+#include "rdfutil.h"
+
+class RDFContainerUtilsImpl : public nsIRDFContainerUtils
+{
+public:
+    // nsISupports interface
+    NS_DECL_ISUPPORTS
+
+    // nsIRDFContainerUtils interface
+    NS_DECL_NSIRDFCONTAINERUTILS
+
+private:
+    friend nsresult NS_NewRDFContainerUtils(nsIRDFContainerUtils** aResult);
+
+    RDFContainerUtilsImpl();
+    virtual ~RDFContainerUtilsImpl();
+
+    nsresult MakeContainer(nsIRDFDataSource* aDataSource,
+                           nsIRDFResource* aResource,
+                           nsIRDFResource* aType,
+                           nsIRDFContainer** aResult);
+
+    bool IsA(nsIRDFDataSource* aDataSource, nsIRDFResource* aResource, nsIRDFResource* aType);
+
+    // pseudo constants
+    static int32_t gRefCnt;
+    static nsIRDFService* gRDFService;
+    static nsIRDFResource* kRDF_instanceOf;
+    static nsIRDFResource* kRDF_nextVal;
+    static nsIRDFResource* kRDF_Bag;
+    static nsIRDFResource* kRDF_Seq;
+    static nsIRDFResource* kRDF_Alt;
+    static nsIRDFLiteral* kOne;
+    static const char kRDFNameSpaceURI[];
+};
+
+int32_t         RDFContainerUtilsImpl::gRefCnt = 0;
+nsIRDFService*  RDFContainerUtilsImpl::gRDFService;
+nsIRDFResource* RDFContainerUtilsImpl::kRDF_instanceOf;
+nsIRDFResource* RDFContainerUtilsImpl::kRDF_nextVal;
+nsIRDFResource* RDFContainerUtilsImpl::kRDF_Bag;
+nsIRDFResource* RDFContainerUtilsImpl::kRDF_Seq;
+nsIRDFResource* RDFContainerUtilsImpl::kRDF_Alt;
+nsIRDFLiteral*  RDFContainerUtilsImpl::kOne;
+const char      RDFContainerUtilsImpl::kRDFNameSpaceURI[] = RDF_NAMESPACE_URI;
+
+////////////////////////////////////////////////////////////////////////
+// nsISupports interface
+
+NS_IMPL_ISUPPORTS(RDFContainerUtilsImpl, nsIRDFContainerUtils)
+
+////////////////////////////////////////////////////////////////////////
+// nsIRDFContainerUtils interface
+
+NS_IMETHODIMP
+RDFContainerUtilsImpl::IsOrdinalProperty(nsIRDFResource *aProperty, bool *_retval)
+{
+    NS_PRECONDITION(aProperty != nullptr, "null ptr");
+    if (! aProperty)
+        return NS_ERROR_NULL_POINTER;
+
+    nsresult rv;
+
+    const char	*propertyStr;
+    rv = aProperty->GetValueConst( &propertyStr );
+    if (NS_FAILED(rv)) return rv;
+
+    if (PL_strncmp(propertyStr, kRDFNameSpaceURI, sizeof(kRDFNameSpaceURI) - 1) != 0) {
+        *_retval = false;
+        return NS_OK;
+    }
+
+    const char* s = propertyStr;
+    s += sizeof(kRDFNameSpaceURI) - 1;
+    if (*s != '_') {
+        *_retval = false;
+        return NS_OK;
+    }
+
+    ++s;
+    while (*s) {
+        if (*s < '0' || *s > '9') {
+            *_retval = false;
+            return NS_OK;
+        }
+
+        ++s;
+    }
+
+    *_retval = true;
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+RDFContainerUtilsImpl::IndexToOrdinalResource(int32_t aIndex, nsIRDFResource **aOrdinal)
+{
+    NS_PRECONDITION(aIndex > 0, "illegal value");
+    if (aIndex <= 0)
+        return NS_ERROR_ILLEGAL_VALUE;
+
+    nsAutoCString uri(kRDFNameSpaceURI);
+    uri.Append('_');
+    uri.AppendInt(aIndex);
+
+    nsresult rv = gRDFService->GetResource(uri, aOrdinal);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "unable to get ordinal resource");
+    if (NS_FAILED(rv)) return rv;
+
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+RDFContainerUtilsImpl::OrdinalResourceToIndex(nsIRDFResource *aOrdinal, int32_t *aIndex)
+{
+    NS_PRECONDITION(aOrdinal != nullptr, "null ptr");
+    if (! aOrdinal)
+        return NS_ERROR_NULL_POINTER;
+
+    const char	*ordinalStr;
+    if (NS_FAILED(aOrdinal->GetValueConst( &ordinalStr )))
+        return NS_ERROR_FAILURE;
+
+    const char* s = ordinalStr;
+    if (PL_strncmp(s, kRDFNameSpaceURI, sizeof(kRDFNameSpaceURI) - 1) != 0) {
+        NS_ERROR("not an ordinal");
+        return NS_ERROR_UNEXPECTED;
+    }
+
+    s += sizeof(kRDFNameSpaceURI) - 1;
+    if (*s != '_') {
+        NS_ERROR("not an ordinal");
+        return NS_ERROR_UNEXPECTED;
+    }
+
+    int32_t idx = 0;
+
+    ++s;
+    while (*s) {
+        if (*s < '0' || *s > '9') {
+            NS_ERROR("not an ordinal");
+            return NS_ERROR_UNEXPECTED;
+        }
+
+        idx *= 10;
+        idx += (*s - '0');
+
+        ++s;
+    }
+
+    *aIndex = idx;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+RDFContainerUtilsImpl::IsContainer(nsIRDFDataSource *aDataSource, nsIRDFResource *aResource, bool *_retval)
+{
+    NS_PRECONDITION(aDataSource != nullptr, "null ptr");
+    if (! aDataSource)
+        return NS_ERROR_NULL_POINTER;
+
+    NS_PRECONDITION(aResource != nullptr, "null ptr");
+    if (! aResource)
+        return NS_ERROR_NULL_POINTER;
+
+    NS_PRECONDITION(_retval != nullptr, "null ptr");
+    if (! _retval)
+        return NS_ERROR_NULL_POINTER;
+
+    if (IsA(aDataSource, aResource, kRDF_Seq) ||
+        IsA(aDataSource, aResource, kRDF_Bag) ||
+        IsA(aDataSource, aResource, kRDF_Alt)) {
+        *_retval = true;
+    }
+    else {
+        *_retval = false;
+    }
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+RDFContainerUtilsImpl::IsEmpty(nsIRDFDataSource* aDataSource, nsIRDFResource* aResource, bool* _retval)
+{
+    if (! aDataSource)
+        return NS_ERROR_NULL_POINTER;
+
+    nsresult rv;
+
+    // By default, say that we're an empty container. Even if we're not
+    // really even a container.
+    *_retval = true;
+
+    nsCOMPtr<nsIRDFNode> nextValNode;
+    rv = aDataSource->GetTarget(aResource, kRDF_nextVal, true, getter_AddRefs(nextValNode));
+    if (NS_FAILED(rv)) return rv;
+
+    if (rv == NS_RDF_NO_VALUE)
+        return NS_OK;
+
+    nsCOMPtr<nsIRDFLiteral> nextValLiteral;
+    rv = nextValNode->QueryInterface(NS_GET_IID(nsIRDFLiteral), getter_AddRefs(nextValLiteral));
+    if (NS_FAILED(rv)) return rv;
+
+    if (nextValLiteral.get() != kOne)
+        *_retval = false;
+
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+RDFContainerUtilsImpl::IsBag(nsIRDFDataSource *aDataSource, nsIRDFResource *aResource, bool *_retval)
+{
+    NS_PRECONDITION(aDataSource != nullptr, "null ptr");
+    if (! aDataSource)
+        return NS_ERROR_NULL_POINTER;
+
+    NS_PRECONDITION(aResource != nullptr, "null ptr");
+    if (! aResource)
+        return NS_ERROR_NULL_POINTER;
+
+    NS_PRECONDITION(_retval != nullptr, "null ptr");
+    if (! _retval)
+        return NS_ERROR_NULL_POINTER;
+
+    *_retval = IsA(aDataSource, aResource, kRDF_Bag);
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+RDFContainerUtilsImpl::IsSeq(nsIRDFDataSource *aDataSource, nsIRDFResource *aResource, bool *_retval)
+{
+    NS_PRECONDITION(aDataSource != nullptr, "null ptr");
+    if (! aDataSource)
+        return NS_ERROR_NULL_POINTER;
+
+    NS_PRECONDITION(aResource != nullptr, "null ptr");
+    if (! aResource)
+        return NS_ERROR_NULL_POINTER;
+
+    NS_PRECONDITION(_retval != nullptr, "null ptr");
+    if (! _retval)
+        return NS_ERROR_NULL_POINTER;
+
+    *_retval = IsA(aDataSource, aResource, kRDF_Seq);
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+RDFContainerUtilsImpl::IsAlt(nsIRDFDataSource *aDataSource, nsIRDFResource *aResource, bool *_retval)
+{
+    NS_PRECONDITION(aDataSource != nullptr, "null ptr");
+    if (! aDataSource)
+        return NS_ERROR_NULL_POINTER;
+
+    NS_PRECONDITION(aResource != nullptr, "null ptr");
+    if (! aResource)
+        return NS_ERROR_NULL_POINTER;
+
+    NS_PRECONDITION(_retval != nullptr, "null ptr");
+    if (! _retval)
+        return NS_ERROR_NULL_POINTER;
+
+    *_retval = IsA(aDataSource, aResource, kRDF_Alt);
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+RDFContainerUtilsImpl::MakeBag(nsIRDFDataSource *aDataSource, nsIRDFResource *aResource, nsIRDFContainer **_retval)
+{
+    return MakeContainer(aDataSource, aResource, kRDF_Bag, _retval);
+}
+
+
+NS_IMETHODIMP
+RDFContainerUtilsImpl::MakeSeq(nsIRDFDataSource *aDataSource, nsIRDFResource *aResource, nsIRDFContainer **_retval)
+{
+    return MakeContainer(aDataSource, aResource, kRDF_Seq, _retval);
+}
+
+
+NS_IMETHODIMP
+RDFContainerUtilsImpl::MakeAlt(nsIRDFDataSource *aDataSource, nsIRDFResource *aResource, nsIRDFContainer **_retval)
+{
+    return MakeContainer(aDataSource, aResource, kRDF_Alt, _retval);
+}
+
+
+
+////////////////////////////////////////////////////////////////////////
+
+
+RDFContainerUtilsImpl::RDFContainerUtilsImpl()
+{
+    if (gRefCnt++ == 0) {
+        nsresult rv;
+
+        NS_DEFINE_CID(kRDFServiceCID, NS_RDFSERVICE_CID);
+        rv = CallGetService(kRDFServiceCID, &gRDFService);
+
+        NS_ASSERTION(NS_SUCCEEDED(rv), "unable to get RDF service");
+        if (NS_SUCCEEDED(rv)) {
+            gRDFService->GetResource(NS_LITERAL_CSTRING(RDF_NAMESPACE_URI "instanceOf"),
+                                     &kRDF_instanceOf);
+            gRDFService->GetResource(NS_LITERAL_CSTRING(RDF_NAMESPACE_URI "nextVal"),
+                                     &kRDF_nextVal);
+            gRDFService->GetResource(NS_LITERAL_CSTRING(RDF_NAMESPACE_URI "Bag"),
+                                     &kRDF_Bag);
+            gRDFService->GetResource(NS_LITERAL_CSTRING(RDF_NAMESPACE_URI "Seq"),
+                                     &kRDF_Seq);
+            gRDFService->GetResource(NS_LITERAL_CSTRING(RDF_NAMESPACE_URI "Alt"),
+                                     &kRDF_Alt);
+            gRDFService->GetLiteral(u"1", &kOne);
+        }
+    }
+}
+
+
+RDFContainerUtilsImpl::~RDFContainerUtilsImpl()
+{
+#ifdef DEBUG_REFS
+    --gInstanceCount;
+    fprintf(stdout, "%d - RDF: RDFContainerUtilsImpl\n", gInstanceCount);
+#endif
+
+    if (--gRefCnt == 0) {
+        NS_IF_RELEASE(gRDFService);
+        NS_IF_RELEASE(kRDF_instanceOf);
+        NS_IF_RELEASE(kRDF_nextVal);
+        NS_IF_RELEASE(kRDF_Bag);
+        NS_IF_RELEASE(kRDF_Seq);
+        NS_IF_RELEASE(kRDF_Alt);
+        NS_IF_RELEASE(kOne);
+    }
+}
+
+
+
+nsresult
+NS_NewRDFContainerUtils(nsIRDFContainerUtils** aResult)
+{
+    NS_PRECONDITION(aResult != nullptr, "null ptr");
+    if (! aResult)
+        return NS_ERROR_NULL_POINTER;
+
+    RDFContainerUtilsImpl* result =
+        new RDFContainerUtilsImpl();
+
+    if (! result)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    NS_ADDREF(result);
+    *aResult = result;
+    return NS_OK;
+}
+
+
+nsresult
+RDFContainerUtilsImpl::MakeContainer(nsIRDFDataSource* aDataSource, nsIRDFResource* aResource, nsIRDFResource* aType, nsIRDFContainer** aResult)
+{
+    NS_PRECONDITION(aDataSource != nullptr, "null ptr");
+    if (! aDataSource)	return NS_ERROR_NULL_POINTER;
+
+    NS_PRECONDITION(aResource != nullptr, "null ptr");
+    if (! aResource)	return NS_ERROR_NULL_POINTER;
+
+    NS_PRECONDITION(aType != nullptr, "null ptr");
+    if (! aType)	return NS_ERROR_NULL_POINTER;
+
+    if (aResult)	*aResult = nullptr;
+
+    nsresult rv;
+
+    // Check to see if somebody has already turned it into a container; if so
+    // don't try to do it again.
+    bool isContainer;
+    rv = IsContainer(aDataSource, aResource, &isContainer);
+    if (NS_FAILED(rv)) return rv;
+
+    if (!isContainer)
+    {
+	rv = aDataSource->Assert(aResource, kRDF_instanceOf, aType, true);
+	if (NS_FAILED(rv)) return rv;
+
+	rv = aDataSource->Assert(aResource, kRDF_nextVal, kOne, true);
+	if (NS_FAILED(rv)) return rv;
+    }
+
+    if (aResult) {
+        rv = NS_NewRDFContainer(aResult);
+        if (NS_FAILED(rv)) return rv;
+
+        rv = (*aResult)->Init(aDataSource, aResource);
+        if (NS_FAILED(rv)) return rv;
+    }
+
+    return NS_OK;
+}
+
+bool
+RDFContainerUtilsImpl::IsA(nsIRDFDataSource* aDataSource, nsIRDFResource* aResource, nsIRDFResource* aType)
+{
+    if (!aDataSource || !aResource || !aType) {
+        NS_WARNING("Unexpected null argument");
+        return false;
+    }
+
+    nsresult rv;
+
+    bool result;
+    rv = aDataSource->HasAssertion(aResource, kRDF_instanceOf, aType, true, &result);
+    if (NS_FAILED(rv))
+      return false;
+
+    return result;
+}
+
+NS_IMETHODIMP
+RDFContainerUtilsImpl::IndexOf(nsIRDFDataSource* aDataSource, nsIRDFResource* aContainer, nsIRDFNode* aElement, int32_t* aIndex)
+{
+    if (!aDataSource || !aContainer)
+        return NS_ERROR_NULL_POINTER;
+
+    // Assume we can't find it.
+    *aIndex = -1;
+
+    // If the resource is null, bail quietly
+    if (! aElement)
+      return NS_OK;
+
+    // We'll assume that fan-out is much higher than fan-in, so grovel
+    // through the inbound arcs, look for an ordinal resource, and
+    // decode it.
+    nsCOMPtr<nsISimpleEnumerator> arcsIn;
+    aDataSource->ArcLabelsIn(aElement, getter_AddRefs(arcsIn));
+    if (! arcsIn)
+        return NS_OK;
+
+    while (1) {
+        bool hasMoreArcs = false;
+        arcsIn->HasMoreElements(&hasMoreArcs);
+        if (! hasMoreArcs)
+            break;
+
+        nsCOMPtr<nsISupports> isupports;
+        arcsIn->GetNext(getter_AddRefs(isupports));
+        if (! isupports)
+            break;
+
+        nsCOMPtr<nsIRDFResource> property =
+            do_QueryInterface(isupports);
+
+        if (! property)
+            continue;
+
+        bool isOrdinal;
+        IsOrdinalProperty(property, &isOrdinal);
+        if (! isOrdinal)
+            continue;
+
+        nsCOMPtr<nsISimpleEnumerator> sources;
+        aDataSource->GetSources(property, aElement, true, getter_AddRefs(sources));
+        if (! sources)
+            continue;
+
+        while (1) {
+            bool hasMoreSources = false;
+            sources->HasMoreElements(&hasMoreSources);
+            if (! hasMoreSources)
+                break;
+
+            nsCOMPtr<nsISupports> isupports2;
+            sources->GetNext(getter_AddRefs(isupports2));
+            if (! isupports2)
+                break;
+
+            nsCOMPtr<nsIRDFResource> source =
+                do_QueryInterface(isupports2);
+
+            if (source == aContainer)
+                // Found it.
+                return OrdinalResourceToIndex(property, aIndex);
+        }
+    }
+
+    return NS_OK;
+}

rdf/base/nsRDFResource.cpp

@@ -0,0 +1,220 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsRDFResource.h"
+#include "nsIServiceManager.h"
+#include "nsIRDFDelegateFactory.h"
+#include "nsIRDFService.h"
+#include "nsRDFCID.h"
+#include "mozilla/Logging.h"
+#include "nsComponentManagerUtils.h"
+#include "nsServiceManagerUtils.h"
+
+static NS_DEFINE_CID(kRDFServiceCID, NS_RDFSERVICE_CID);
+
+nsIRDFService* nsRDFResource::gRDFService = nullptr;
+nsrefcnt nsRDFResource::gRDFServiceRefCnt = 0;
+
+////////////////////////////////////////////////////////////////////////////////
+
+nsRDFResource::nsRDFResource(void)
+    : mDelegates(nullptr)
+{
+}
+
+nsRDFResource::~nsRDFResource(void)
+{
+    // Release all of the delegate objects
+    while (mDelegates) {
+        DelegateEntry* doomed = mDelegates;
+        mDelegates = mDelegates->mNext;
+        delete doomed;
+    }
+
+    if (!gRDFService)
+        return;
+
+    gRDFService->UnregisterResource(this);
+
+    if (--gRDFServiceRefCnt == 0)
+        NS_RELEASE(gRDFService);
+}
+
+NS_IMPL_ISUPPORTS(nsRDFResource, nsIRDFResource, nsIRDFNode)
+
+////////////////////////////////////////////////////////////////////////////////
+// nsIRDFNode methods:
+
+NS_IMETHODIMP
+nsRDFResource::EqualsNode(nsIRDFNode* aNode, bool* aResult)
+{
+    NS_PRECONDITION(aNode != nullptr, "null ptr");
+    if (! aNode)
+        return NS_ERROR_NULL_POINTER;
+
+    nsresult rv;
+    nsIRDFResource* resource;
+    rv = aNode->QueryInterface(NS_GET_IID(nsIRDFResource), (void**)&resource);
+    if (NS_SUCCEEDED(rv)) {
+        *aResult = (static_cast<nsIRDFResource*>(this) == resource);
+        NS_RELEASE(resource);
+        return NS_OK;
+    }
+    if (rv == NS_NOINTERFACE) {
+        *aResult = false;
+        return NS_OK;
+    }
+
+    return rv;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// nsIRDFResource methods:
+
+NS_IMETHODIMP
+nsRDFResource::Init(const char* aURI)
+{
+    NS_PRECONDITION(aURI != nullptr, "null ptr");
+    if (! aURI)
+        return NS_ERROR_NULL_POINTER;
+
+    mURI = aURI;
+
+    if (gRDFServiceRefCnt++ == 0) {
+        nsresult rv = CallGetService(kRDFServiceCID, &gRDFService);
+        if (NS_FAILED(rv)) return rv;
+    }
+
+    // don't replace an existing resource with the same URI automatically
+    return gRDFService->RegisterResource(this, true);
+}
+
+NS_IMETHODIMP
+nsRDFResource::GetValue(char* *aURI)
+{
+    NS_ASSERTION(aURI, "Null out param.");
+
+    *aURI = ToNewCString(mURI);
+
+    if (!*aURI)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsRDFResource::GetValueUTF8(nsACString& aResult)
+{
+    aResult = mURI;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsRDFResource::GetValueConst(const char** aURI)
+{
+    *aURI = mURI.get();
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsRDFResource::EqualsString(const char* aURI, bool* aResult)
+{
+    NS_PRECONDITION(aURI != nullptr, "null ptr");
+    if (! aURI)
+        return NS_ERROR_NULL_POINTER;
+
+    NS_PRECONDITION(aResult, "null ptr");
+
+    *aResult = mURI.Equals(aURI);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsRDFResource::GetDelegate(const char* aKey, REFNSIID aIID, void** aResult)
+{
+    NS_PRECONDITION(aKey != nullptr, "null ptr");
+    if (! aKey)
+        return NS_ERROR_NULL_POINTER;
+
+    nsresult rv;
+    *aResult = nullptr;
+
+    DelegateEntry* entry = mDelegates;
+    while (entry) {
+        if (entry->mKey.Equals(aKey)) {
+            rv = entry->mDelegate->QueryInterface(aIID, aResult);
+            return rv;
+        }
+
+        entry = entry->mNext;
+    }
+
+    // Construct a ContractID of the form "@mozilla.org/rdf/delegate/[key]/[scheme];1
+    nsAutoCString contractID(NS_RDF_DELEGATEFACTORY_CONTRACTID_PREFIX);
+    contractID.Append(aKey);
+    contractID.AppendLiteral("&scheme=");
+
+    int32_t i = mURI.FindChar(':');
+    contractID += StringHead(mURI, i);
+
+    nsCOMPtr<nsIRDFDelegateFactory> delegateFactory =
+             do_CreateInstance(contractID.get(), &rv);
+    if (NS_FAILED(rv)) return rv;
+
+    rv = delegateFactory->CreateDelegate(this, aKey, aIID, aResult);
+    if (NS_FAILED(rv)) return rv;
+
+    // Okay, we've successfully created a delegate. Let's remember it.
+    entry = new DelegateEntry;
+    if (! entry) {
+        NS_RELEASE(*reinterpret_cast<nsISupports**>(aResult));
+        return NS_ERROR_OUT_OF_MEMORY;
+    }
+
+    entry->mKey      = aKey;
+    entry->mDelegate = do_QueryInterface(*reinterpret_cast<nsISupports**>(aResult), &rv);
+    if (NS_FAILED(rv)) {
+        NS_ERROR("nsRDFResource::GetDelegate(): can't QI to nsISupports!");
+
+        delete entry;
+        NS_RELEASE(*reinterpret_cast<nsISupports**>(aResult));
+        return NS_ERROR_FAILURE;
+    }
+
+    entry->mNext     = mDelegates;
+
+    mDelegates = entry;
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsRDFResource::ReleaseDelegate(const char* aKey)
+{
+    NS_PRECONDITION(aKey != nullptr, "null ptr");
+    if (! aKey)
+        return NS_ERROR_NULL_POINTER;
+
+    DelegateEntry* entry = mDelegates;
+    DelegateEntry** link = &mDelegates;
+
+    while (entry) {
+        if (entry->mKey.Equals(aKey)) {
+            *link = entry->mNext;
+            delete entry;
+            return NS_OK;
+        }
+
+        link = &(entry->mNext);
+        entry = entry->mNext;
+    }
+
+    NS_WARNING("nsRDFResource::ReleaseDelegate() no delegate found");
+    return NS_OK;
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////

rdf/base/nsRDFResource.h

@@ -0,0 +1,59 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsRDFResource_h__
+#define nsRDFResource_h__
+
+#include "nsCOMPtr.h"
+#include "nsIRDFNode.h"
+#include "nsIRDFResource.h"
+#include "nscore.h"
+#include "nsString.h"
+#include "rdf.h"
+
+class nsIRDFService;
+
+/**
+ * This simple base class implements nsIRDFResource, and can be used as a
+ * superclass for more sophisticated resource implementations.
+ */
+class nsRDFResource : public nsIRDFResource {
+public:
+
+    NS_DECL_THREADSAFE_ISUPPORTS
+
+    // nsIRDFNode methods:
+    NS_IMETHOD EqualsNode(nsIRDFNode* aNode, bool* aResult) override;
+
+    // nsIRDFResource methods:
+    NS_IMETHOD Init(const char* aURI) override;
+    NS_IMETHOD GetValue(char* *aURI) override;
+    NS_IMETHOD GetValueUTF8(nsACString& aResult) override;
+    NS_IMETHOD GetValueConst(const char** aURI) override;
+    NS_IMETHOD EqualsString(const char* aURI, bool* aResult) override;
+    NS_IMETHOD GetDelegate(const char* aKey, REFNSIID aIID, void** aResult) override;
+    NS_IMETHOD ReleaseDelegate(const char* aKey) override;
+
+    // nsRDFResource methods:
+    nsRDFResource(void);
+
+protected:
+    virtual ~nsRDFResource(void);
+    static nsIRDFService* gRDFService;
+    static nsrefcnt gRDFServiceRefCnt;
+
+protected:
+    nsCString mURI;
+
+    struct DelegateEntry {
+        nsCString             mKey;
+        nsCOMPtr<nsISupports> mDelegate;
+        DelegateEntry*        mNext;
+    };
+
+    DelegateEntry* mDelegates;
+};
+
+#endif // nsRDFResource_h__

rdf/base/nsRDFService.h

@@ -0,0 +1,66 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsRDFService_h__
+#define nsRDFService_h__
+
+#include "nsIRDFService.h"
+#include "nsWeakReference.h"
+#include "nsIFactory.h"
+#include "nsCOMPtr.h"
+#include "PLDHashTable.h"
+#include "nsString.h"
+
+struct PLHashTable;
+class nsIRDFLiteral;
+class nsIRDFInt;
+class nsIRDFDate;
+class BlobImpl;
+
+class RDFServiceImpl final : public nsIRDFService,
+                             public nsSupportsWeakReference
+{
+protected:
+    PLHashTable* mNamedDataSources;
+    PLDHashTable mResources;
+    PLDHashTable mLiterals;
+    PLDHashTable mInts;
+    PLDHashTable mDates;
+    PLDHashTable mBlobs;
+
+    nsCString mLastURIPrefix;
+    nsCOMPtr<nsIFactory> mLastFactory;
+    nsCOMPtr<nsIFactory> mDefaultResourceFactory;
+
+    RDFServiceImpl();
+    nsresult Init();
+    virtual ~RDFServiceImpl();
+
+public:
+    static RDFServiceImpl *gRDFService NS_VISIBILITY_HIDDEN;
+    static nsresult CreateSingleton(nsISupports* aOuter,
+                                    const nsIID& aIID, void **aResult);
+
+    // nsISupports
+    NS_DECL_ISUPPORTS
+
+    // nsIRDFService
+    NS_DECL_NSIRDFSERVICE
+
+    // Implementation methods
+    nsresult RegisterLiteral(nsIRDFLiteral* aLiteral);
+    nsresult UnregisterLiteral(nsIRDFLiteral* aLiteral);
+    nsresult RegisterInt(nsIRDFInt* aInt);
+    nsresult UnregisterInt(nsIRDFInt* aInt);
+    nsresult RegisterDate(nsIRDFDate* aDate);
+    nsresult UnregisterDate(nsIRDFDate* aDate);
+    nsresult RegisterBlob(BlobImpl* aBlob);
+    nsresult UnregisterBlob(BlobImpl* aBlob);
+
+    nsresult GetDataSource(const char *aURI, bool aBlock, nsIRDFDataSource **aDataSource );
+};
+
+#endif // nsRDFService_h__

rdf/base/nsRDFXMLParser.cpp

@@ -0,0 +1,137 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsRDFXMLParser.h"
+
+#include "mozilla/Encoding.h"
+#include "nsIComponentManager.h"
+#include "nsIParser.h"
+#include "nsCharsetSource.h"
+#include "nsIRDFContentSink.h"
+#include "nsParserCIID.h"
+#include "nsStringStream.h"
+#include "nsNetUtil.h"
+#include "NullPrincipal.h"
+
+static NS_DEFINE_CID(kParserCID, NS_PARSER_CID);
+
+NS_IMPL_ISUPPORTS(nsRDFXMLParser, nsIRDFXMLParser)
+
+nsresult
+nsRDFXMLParser::Create(nsISupports* aOuter, REFNSIID aIID, void** aResult)
+{
+    if (aOuter)
+        return NS_ERROR_NO_AGGREGATION;
+
+    nsRDFXMLParser* result = new nsRDFXMLParser();
+    if (! result)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    nsresult rv;
+    NS_ADDREF(result);
+    rv = result->QueryInterface(aIID, aResult);
+    NS_RELEASE(result);
+    return rv;
+}
+
+nsRDFXMLParser::nsRDFXMLParser()
+{
+}
+
+nsRDFXMLParser::~nsRDFXMLParser()
+{
+}
+
+NS_IMETHODIMP
+nsRDFXMLParser::ParseAsync(nsIRDFDataSource* aSink, nsIURI* aBaseURI, nsIStreamListener** aResult)
+{
+    nsresult rv;
+
+    nsCOMPtr<nsIRDFContentSink> sink =
+        do_CreateInstance("@mozilla.org/rdf/content-sink;1", &rv);
+
+    if (NS_FAILED(rv)) return rv;
+
+    rv = sink->Init(aBaseURI);
+    if (NS_FAILED(rv)) return rv;
+
+    // We set the content sink's data source directly to our in-memory
+    // store. This allows the initial content to be generated "directly".
+    rv = sink->SetDataSource(aSink);
+    if (NS_FAILED(rv)) return rv;
+
+    nsCOMPtr<nsIParser> parser = do_CreateInstance(kParserCID, &rv);
+    if (NS_FAILED(rv)) return rv;
+
+    parser->SetDocumentCharset(UTF_8_ENCODING,
+                               kCharsetFromDocTypeDefault);
+    parser->SetContentSink(sink);
+
+    rv = parser->Parse(aBaseURI);
+    if (NS_FAILED(rv)) return rv;
+
+    return CallQueryInterface(parser, aResult);
+}
+
+NS_IMETHODIMP
+nsRDFXMLParser::ParseString(nsIRDFDataSource* aSink, nsIURI* aBaseURI, const nsACString& aString)
+{
+    nsresult rv;
+
+    nsCOMPtr<nsIRDFContentSink> sink =
+        do_CreateInstance("@mozilla.org/rdf/content-sink;1", &rv);
+
+    if (NS_FAILED(rv)) return rv;
+
+    rv = sink->Init(aBaseURI);
+    if (NS_FAILED(rv)) return rv;
+
+    // We set the content sink's data source directly to our in-memory
+    // store. This allows the initial content to be generated "directly".
+    rv = sink->SetDataSource(aSink);
+    if (NS_FAILED(rv)) return rv;
+
+    nsCOMPtr<nsIParser> parser = do_CreateInstance(kParserCID, &rv);
+    if (NS_FAILED(rv)) return rv;
+
+    parser->SetDocumentCharset(UTF_8_ENCODING,
+                               kCharsetFromOtherComponent);
+    parser->SetContentSink(sink);
+
+    rv = parser->Parse(aBaseURI);
+    if (NS_FAILED(rv)) return rv;
+
+    nsCOMPtr<nsIStreamListener> listener =
+        do_QueryInterface(parser);
+
+    if (! listener)
+        return NS_ERROR_FAILURE;
+
+    nsCOMPtr<nsIInputStream> stream;
+    rv = NS_NewCStringInputStream(getter_AddRefs(stream), aString);
+    if (NS_FAILED(rv)) return rv;
+
+    nsCOMPtr<nsIPrincipal> nullPrincipal = NullPrincipal::CreateWithoutOriginAttributes();
+
+    // The following channel is never openend, so it does not matter what
+    // securityFlags we pass; let's follow the principle of least privilege.
+    nsCOMPtr<nsIChannel> channel;
+    nsCOMPtr<nsIInputStream> tmpStream = stream;
+    rv = NS_NewInputStreamChannel(getter_AddRefs(channel),
+                                  aBaseURI,
+                                  tmpStream.forget(),
+                                  nullPrincipal,
+                                  nsILoadInfo::SEC_REQUIRE_SAME_ORIGIN_DATA_IS_BLOCKED,
+                                  nsIContentPolicy::TYPE_OTHER,
+                                  NS_LITERAL_CSTRING("text/xml"));
+    if (NS_FAILED(rv)) return rv;
+
+    listener->OnStartRequest(channel, nullptr);
+    listener->OnDataAvailable(channel, nullptr, stream, 0, aString.Length());
+    listener->OnStopRequest(channel, nullptr, NS_OK);
+
+    return NS_OK;
+}

rdf/base/nsRDFXMLParser.h

@@ -0,0 +1,31 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsRDFParser_h__
+#define nsRDFParser_h__
+
+#include "nsCOMPtr.h"
+#include "nsString.h"
+#include "nsIRDFXMLParser.h"
+#include "nsIRDFDataSource.h"
+
+/**
+ * A helper class that is used to parse RDF/XML.
+ */
+class nsRDFXMLParser : public nsIRDFXMLParser {
+public:
+    static nsresult
+    Create(nsISupports* aOuter, REFNSIID aIID, void** aResult);
+
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIRDFXMLPARSER
+
+protected:
+    nsRDFXMLParser();
+    virtual ~nsRDFXMLParser();
+};
+
+#endif // nsRDFParser_h__

rdf/base/nsRDFXMLSerializer.h

@@ -0,0 +1,117 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsRDFXMLSerializer_h__
+#define nsRDFXMLSerializer_h__
+
+#include "nsIRDFLiteral.h"
+#include "nsIRDFXMLSerializer.h"
+#include "nsIRDFXMLSource.h"
+#include "nsNameSpaceMap.h"
+#include "nsString.h"
+
+#include "nsDataHashtable.h"
+#include "rdfITripleVisitor.h"
+
+class nsIOutputStream;
+class nsIRDFContainerUtils;
+
+/**
+ * A helper class that can serialize RDF/XML from a
+ * datasource. Implements both nsIRDFXMLSerializer and
+ * nsIRDFXMLSource.
+ */
+class nsRDFXMLSerializer : public nsIRDFXMLSerializer,
+                           public nsIRDFXMLSource
+{
+public:
+    static nsresult
+    Create(nsISupports* aOuter, REFNSIID aIID, void** aResult);
+
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIRDFXMLSERIALIZER
+    NS_DECL_NSIRDFXMLSOURCE
+
+protected:
+    nsRDFXMLSerializer();
+    virtual ~nsRDFXMLSerializer();
+
+    // Implementation methods
+    nsresult
+    RegisterQName(nsIRDFResource* aResource);
+    nsresult
+    GetQName(nsIRDFResource* aResource, nsCString& aQName);
+    already_AddRefed<nsAtom>
+    EnsureNewPrefix();
+
+    nsresult
+    SerializeInlineAssertion(nsIOutputStream* aStream,
+                             nsIRDFResource* aResource,
+                             nsIRDFResource* aProperty,
+                             nsIRDFLiteral* aValue);
+
+    nsresult
+    SerializeChildAssertion(nsIOutputStream* aStream,
+                            nsIRDFResource* aResource,
+                            nsIRDFResource* aProperty,
+                            nsIRDFNode* aValue);
+
+    nsresult
+    SerializeProperty(nsIOutputStream* aStream,
+                      nsIRDFResource* aResource,
+                      nsIRDFResource* aProperty,
+                      bool aInline,
+                      int32_t* aSkipped);
+
+    bool
+    IsContainerProperty(nsIRDFResource* aProperty);
+
+    nsresult
+    SerializeDescription(nsIOutputStream* aStream,
+                         nsIRDFResource* aResource);
+
+    nsresult
+    SerializeMember(nsIOutputStream* aStream,
+                    nsIRDFResource* aContainer,
+                    nsIRDFNode* aMember);
+
+    nsresult
+    SerializeContainer(nsIOutputStream* aStream,
+                       nsIRDFResource* aContainer);
+
+    nsresult
+    SerializePrologue(nsIOutputStream* aStream);
+
+    nsresult
+    SerializeEpilogue(nsIOutputStream* aStream);
+
+    nsresult
+    CollectNamespaces();
+
+    bool
+    IsA(nsIRDFDataSource* aDataSource, nsIRDFResource* aResource, nsIRDFResource* aType);
+
+    nsCOMPtr<nsIRDFDataSource> mDataSource;
+    nsNameSpaceMap mNameSpaces;
+    nsCString mBaseURLSpec;
+
+    // hash mapping resources to utf8-encoded QNames
+    nsDataHashtable<nsISupportsHashKey, nsCString> mQNames;
+    friend class QNameCollector;
+
+    uint32_t mPrefixID;
+
+    static int32_t gRefCnt;
+    static nsIRDFResource* kRDF_instanceOf;
+    static nsIRDFResource* kRDF_type;
+    static nsIRDFResource* kRDF_nextVal;
+    static nsIRDFResource* kRDF_Bag;
+    static nsIRDFResource* kRDF_Seq;
+    static nsIRDFResource* kRDF_Alt;
+    static nsIRDFContainerUtils* gRDFC;
+};
+
+#endif // nsRDFXMLSerializer_h__

rdf/base/rdf.h

@@ -0,0 +1,57 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+/*
+
+  A catch-all header file for miscellaneous RDF stuff. Currently
+  contains error codes and vocabulary macros.
+
+ */
+
+#ifndef rdf_h___
+#define rdf_h___
+
+#include "nsError.h"
+
+/**
+ * The following macros are to aid in vocabulary definition.  They
+ * creates const char*'s for "kURI[prefix]_[name]", appropriate
+ * complete namespace qualification on the URI, e.g.,
+ *
+ * #define RDF_NAMESPACE_URI "http://www.w3.org/TR/WD-rdf-syntax#"
+ * DEFINE_RDF_ELEMENT(RDF_NAMESPACE_URI, RDF, ID);
+ *
+ * will define:
+ *
+ * kURIRDF_ID to be "http://www.w3.org/TR/WD-rdf-syntax#ID"
+ */
+
+#define DEFINE_RDF_VOCAB(ns, prefix, name) \
+static const char kURI##prefix##_##name[] = ns #name
+
+/**
+ * Core RDF vocabularies that we use to define semantics
+ */
+
+#define RDF_NAMESPACE_URI  "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+#define WEB_NAMESPACE_URI  "http://home.netscape.com/WEB-rdf#"
+#define NC_NAMESPACE_URI   "http://home.netscape.com/NC-rdf#"
+
+/* ContractID prefixes for RDF DLL registration. */
+#define NS_RDF_CONTRACTID                           "@mozilla.org/rdf"
+#define NS_RDF_DATASOURCE_CONTRACTID                NS_RDF_CONTRACTID "/datasource;1"
+#define NS_RDF_DATASOURCE_CONTRACTID_PREFIX         NS_RDF_DATASOURCE_CONTRACTID "?name="
+#define NS_RDF_RESOURCE_FACTORY_CONTRACTID          "@mozilla.org/rdf/resource-factory;1"
+#define NS_RDF_RESOURCE_FACTORY_CONTRACTID_PREFIX   NS_RDF_RESOURCE_FACTORY_CONTRACTID "?name="
+#define NS_RDF_INFER_DATASOURCE_CONTRACTID_PREFIX   NS_RDF_CONTRACTID "/infer-datasource;1?engine="
+
+// contract ID is in the form
+// @mozilla.org/rdf/delegate-factory;1?key=<key>&scheme=<scheme>
+#define NS_RDF_DELEGATEFACTORY_CONTRACTID    "@mozilla.org/rdf/delegate-factory;1"
+#define NS_RDF_DELEGATEFACTORY_CONTRACTID_PREFIX    NS_RDF_DELEGATEFACTORY_CONTRACTID "?key="
+
+/*@}*/
+
+#endif /* rdf_h___ */

rdf/base/rdfIDataSource.idl

@@ -0,0 +1,38 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+interface rdfITripleVisitor;
+
+/**
+ * Interface used in RDF to describe data sources.
+ *
+ * @status PLASMA
+ */
+
+[scriptable, uuid(ebce86bd-1568-4a34-a808-9ccf9cde8087)]
+interface rdfIDataSource : nsISupports
+{
+    /**
+     * Visit all the subject resources in the datasource. The order is
+     * intederminate and may change from one invocation to the next.
+     * The subjects will be in the aSubject argument in calls into
+     * aVisitor, aPredicate and aObject will be null.
+     * @note Implementations may throw NS_ERROR_NOT_IMPLEMENTED for
+     * this method, but in this case RDF serializations of this
+     * datasource will not be possible.
+     */
+    void visitAllSubjects(in rdfITripleVisitor aVisitor);
+
+    /**
+     * Visit all the triples in the datasource. The order is
+     * intederminate and may change from one invocation to the next.
+     * @note Implementations may throw NS_ERROR_NOT_IMPLEMENTED for
+     * this method, but in this case RDF serializations of this
+     * datasource will not be possible.
+     */
+    void visitAllTriples(in rdfITripleVisitor aVisitor);
+};

rdf/base/rdfITripleVisitor.idl

@@ -0,0 +1,31 @@
+/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsISupports.idl"
+
+interface nsIRDFResource;
+interface nsIRDFNode;
+
+/**
+ * Interface used in RDF to enumerate triples.
+ * Also used by rdfIDataSource::getAllSubjects, then aPredicate,
+ * aObject and aTruthValue are ignored.
+ *
+ * @status PLASMA
+ */
+
+[scriptable, function, uuid(aafea151-c271-4505-9978-a100d292800c)]
+interface rdfITripleVisitor : nsISupports
+{
+    /**
+     * Callback function for returning query results.
+     *
+     * @param aSubject, aPredicate, aObject describe the (sub-)arc
+     * @returnCode NS_RDF_STOP_VISIT to stop iterating over the query result.
+     *             Any error code will stop the iteration as well.
+     */
+    void visit(in nsIRDFNode aSubject, in nsIRDFResource aPredicate,
+               in nsIRDFNode aObject, in boolean aTruthValue);
+};

rdf/base/rdfutil.cpp

@@ -0,0 +1,110 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+
+  Implementations for a bunch of useful RDF utility routines.  Many of
+  these will eventually be exported outside of RDF.DLL via the
+  nsIRDFService interface.
+
+  TO DO
+
+  1) Make this so that it doesn't permanently leak the RDF service
+     object.
+
+  2) Make container functions thread-safe. They currently don't ensure
+     that the RDF:nextVal property is maintained safely.
+
+ */
+
+#include "nsCOMPtr.h"
+#include "nsIRDFDataSource.h"
+#include "nsIRDFNode.h"
+#include "nsIRDFService.h"
+#include "nsIServiceManager.h"
+#include "nsIURL.h"
+#include "nsIIOService.h"
+#include "nsIURL.h"
+#include "nsRDFCID.h"
+#include "nsString.h"
+#include "nsUnicharUtils.h"
+#include "rdfutil.h"
+#include "prtime.h"
+
+////////////////////////////////////////////////////////////////////////
+
+nsresult
+rdf_MakeRelativeRef(const nsACString& aBaseURI, nsCString& aURI)
+{
+    // This implementation is extremely simple: e.g., it can't compute
+    // relative paths, or anything fancy like that. If the context URI
+    // is not a prefix of the URI in question, we'll just bail.
+    uint32_t prefixLen = aBaseURI.Length();
+    if (prefixLen != 0 && StringBeginsWith(aURI, aBaseURI)) {
+        if (prefixLen < aURI.Length() && aURI.CharAt(prefixLen) == '/')
+            ++prefixLen; // chop the leading slash so it's not `absolute'
+
+        aURI.Cut(0, prefixLen);
+    }
+
+    return NS_OK;
+}
+
+void
+rdf_FormatDate(PRTime aTime, nsACString &aResult)
+{
+    // Outputs Unixish date in GMT plus usecs; e.g.,
+    //   Wed Jan  9 19:15:13 2002 +002441
+    //
+    PRExplodedTime t;
+    PR_ExplodeTime(aTime, PR_GMTParameters, &t);
+
+    char buf[256];
+    PR_FormatTimeUSEnglish(buf, sizeof buf, "%a %b %d %H:%M:%S %Y", &t);
+    aResult.Append(buf);
+
+    // usecs
+    aResult.AppendLiteral(" +");
+    int32_t usec = t.tm_usec;
+    for (int32_t digit = 100000; digit > 1; digit /= 10) {
+        aResult.Append(char('0' + (usec / digit)));
+        usec %= digit;
+    }
+    aResult.Append(char('0' + usec));
+}
+
+PRTime
+rdf_ParseDate(const nsACString &aTime)
+{
+    PRTime t;
+    PR_ParseTimeString(PromiseFlatCString(aTime).get(), true, &t);
+
+    int32_t usec = 0;
+
+    nsACString::const_iterator begin, digit, end;
+    aTime.BeginReading(begin);
+    aTime.EndReading(end);
+
+    // Walk backwards until we find a `+', run out of string, or a
+    // non-numeric character.
+    digit = end;
+    while (--digit != begin && *digit != '+') {
+        if (*digit < '0' || *digit > '9')
+            break;
+    }
+
+    if (digit != begin && *digit == '+') {
+        // There's a usec field specified (or, at least, something
+        // that looks close enough. Parse it, and add it to the time.
+        while (++digit != end) {
+            usec *= 10;
+            usec += *digit - '0';
+        }
+
+        t += usec;
+    }
+
+    return t;
+}

rdf/base/rdfutil.h

@@ -0,0 +1,38 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+
+/*
+
+  A bunch of useful RDF utility routines.  Many of these will
+  eventually be exported outside of RDF.DLL via the nsIRDFService
+  interface.
+
+  TO DO
+
+  1) Move the anonymous resource stuff to nsIRDFService?
+
+  2) All that's left is rdf_PossiblyMakeRelative() and
+     -Absolute(). Maybe those go on nsIRDFService, too.
+
+ */
+
+#ifndef rdfutil_h__
+#define rdfutil_h__
+
+#include "nsStringFwd.h"
+
+nsresult
+rdf_MakeRelativeRef(const nsACString& aBaseURI, nsCString& aURI);
+
+void
+rdf_FormatDate(PRTime aTime, nsACString &aResult);
+
+PRTime
+rdf_ParseDate(const nsACString &aTime);
+
+#endif // rdfutil_h__
+
+

rdf/build/moz.build

@@ -0,0 +1,20 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+EXPORTS += [
+    'nsRDFCID.h',
+]
+
+SOURCES += [
+    'nsRDFModule.cpp',
+]
+
+FINAL_LIBRARY = 'xul'
+
+LOCAL_INCLUDES += [
+    '/rdf/base',
+    '/rdf/datasource',
+]

rdf/build/nsRDFCID.h

@@ -0,0 +1,76 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+
+  XPCOM Class IDs for RDF objects that can be constructed via the RDF
+  factory.
+
+ */
+
+#ifndef nsRDFCID_h__
+#define nsRDFCID_h__
+
+// {0F78DA56-8321-11d2-8EAC-00805F29F370}
+#define NS_RDFDEFAULTRESOURCE_CID \
+{ 0xf78da56, 0x8321, 0x11d2, { 0x8e, 0xac, 0x0, 0x80, 0x5f, 0x29, 0xf3, 0x70 } }
+
+// {BFD05264-834C-11d2-8EAC-00805F29F370}
+#define NS_RDFSERVICE_CID \
+{ 0xbfd05264, 0x834c, 0x11d2, { 0x8e, 0xac, 0x0, 0x80, 0x5f, 0x29, 0xf3, 0x70 } }
+
+// {BFD0526D-834C-11d2-8EAC-00805F29F370}
+#define NS_RDFINMEMORYDATASOURCE_CID \
+{ 0xbfd0526d, 0x834c, 0x11d2, { 0x8e, 0xac, 0x0, 0x80, 0x5f, 0x29, 0xf3, 0x70 } }
+
+// {E638D760-8687-11d2-B530-000000000001}
+#define NS_RDFFILESYSTEMDATASOURCE_CID \
+{ 0xe638d760, 0x8687, 0x11d2, { 0xb5, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x01 } }
+
+// {6bd1d807-1c67-11d3-9820-ed1b357eb3c4}
+#define NS_RDFSEARCHDATASOURCE_CID \
+{ 0x6bd1d807, 0x1c67, 0x11d3, { 0x98, 0x20, 0xed, 0x1b, 0x35, 0x7e, 0xb3, 0xc4 } }
+
+// {E638D760-8687-11d2-B530-000000000002}
+#define NS_RDFFINDDATASOURCE_CID \
+{ 0xe638d760, 0x8687, 0x11d2, { 0xb5, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x02 } }
+
+// {E638D761-8687-11d2-B530-000000000000}
+#define NS_RDFCOMPOSITEDATASOURCE_CID \
+{ 0xe638d761, 0x8687, 0x11d2, { 0xb5, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } }
+
+// {7BAF62E0-8E61-11d2-8EB1-00805F29F370}
+#define NS_RDFXMLDATASOURCE_CID \
+{ 0x7baf62e0, 0x8e61, 0x11d2, { 0x8e, 0xb1, 0x0, 0x80, 0x5f, 0x29, 0xf3, 0x70 } }
+
+// {0958B101-9ADA-11d2-8EBC-00805F29F370}
+#define NS_RDFCONTENTSINK_CID \
+{ 0x958b101, 0x9ada, 0x11d2, { 0x8e, 0xbc, 0x0, 0x80, 0x5f, 0x29, 0xf3, 0x70 } }
+
+// {1EAAFD60-D596-11d2-80BE-006097B76B8E}
+#define NS_RDFHISTORYDATASOURCE_CID \
+{ 0x1eaafd60, 0xd596, 0x11d2, { 0x80, 0xbe, 0x0, 0x60, 0x97, 0xb7, 0x6b, 0x8e } }
+
+// {D4214E92-FB94-11d2-BDD8-00104BDE6048}
+#define NS_RDFCONTAINERUTILS_CID \
+{ 0xd4214e92, 0xfb94, 0x11d2, { 0xbd, 0xd8, 0x0, 0x10, 0x4b, 0xde, 0x60, 0x48 } }
+
+// {D4214E93-FB94-11d2-BDD8-00104BDE6048}
+#define NS_RDFCONTAINER_CID \
+{ 0xd4214e93, 0xfb94, 0x11d2, { 0xbd, 0xd8, 0x0, 0x10, 0x4b, 0xde, 0x60, 0x48 } }
+
+// {0032d852-1dd2-11b2-95f7-e0a1910ed2da}
+#define NS_RDFXMLSERIALIZER_CID \
+{ 0x0032d852, 0x1dd2, 0x11b2, { 0x95, 0xf7, 0xe0, 0xa1, 0x91, 0x0e, 0xd2, 0xda } }
+
+// {a4048e94-1dd1-11b2-a676-8a06c086cc7d}
+#define NS_RDFXMLPARSER_CID \
+{ 0xa4048e94, 0x1dd1, 0x11b2, { 0xa6, 0x76, 0x8a, 0x06, 0xc0, 0x86, 0xcc, 0x7d } }
+
+// {0a5cd734-eb65-4d14-88a0-9f0bb2aba206}
+#define NS_RDFNTRIPLES_SERIALIZER_CID \
+{ 0x0a5cd734, 0xeb65, 0x4d14, { 0x88, 0xa0, 0x9f, 0x0b, 0xb2, 0xab, 0xa2, 0x06 } }
+
+#endif // nsRDFCID_h__

rdf/build/nsRDFModule.cpp

@@ -0,0 +1,120 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include "nsCOMPtr.h"
+#include "mozilla/ModuleUtils.h"
+
+#include "nsIFactory.h"
+#include "nsRDFService.h"
+#include "nsIRDFContainer.h"
+#include "nsIRDFContainerUtils.h"
+#include "nsIRDFCompositeDataSource.h"
+#include "nsIRDFContentSink.h"
+#include "nsISupports.h"
+#include "nsRDFBaseDataSources.h"
+#include "nsRDFBuiltInDataSources.h"
+#include "nsRDFCID.h"
+#include "nsIComponentManager.h"
+#include "rdf.h"
+#include "nsIServiceManager.h"
+#include "nsILocalStore.h"
+#include "nsRDFXMLParser.h"
+#include "nsRDFXMLSerializer.h"
+
+//----------------------------------------------------------------------
+
+// Functions used to create new instances of a given object by the
+// generic factory.
+
+#define MAKE_CTOR(_func,_new,_ifname)                                \
+static nsresult                                                      \
+CreateNew##_func(nsISupports* aOuter, REFNSIID aIID, void **aResult) \
+{                                                                    \
+    if (!aResult) {                                                  \
+        return NS_ERROR_INVALID_POINTER;                             \
+    }                                                                \
+    if (aOuter) {                                                    \
+        *aResult = nullptr;                                           \
+        return NS_ERROR_NO_AGGREGATION;                              \
+    }                                                                \
+    nsI##_ifname* inst;                                              \
+    nsresult rv = NS_New##_new(&inst);                               \
+    if (NS_FAILED(rv)) {                                             \
+        *aResult = nullptr;                                           \
+        return rv;                                                   \
+    }                                                                \
+    rv = inst->QueryInterface(aIID, aResult);                        \
+    if (NS_FAILED(rv)) {                                             \
+        *aResult = nullptr;                                           \
+    }                                                                \
+    NS_RELEASE(inst);             /* get rid of extra refcnt */      \
+    return rv;                                                       \
+}
+
+extern nsresult
+NS_NewDefaultResource(nsIRDFResource** aResult);
+
+MAKE_CTOR(RDFXMLDataSource,RDFXMLDataSource,RDFDataSource)
+MAKE_CTOR(RDFCompositeDataSource,RDFCompositeDataSource,RDFCompositeDataSource)
+MAKE_CTOR(RDFContainer,RDFContainer,RDFContainer)
+
+MAKE_CTOR(RDFContainerUtils,RDFContainerUtils,RDFContainerUtils)
+
+MAKE_CTOR(RDFContentSink,RDFContentSink,RDFContentSink)
+MAKE_CTOR(RDFDefaultResource,DefaultResource,RDFResource)
+
+NS_DEFINE_NAMED_CID(NS_RDFCOMPOSITEDATASOURCE_CID);
+NS_DEFINE_NAMED_CID(NS_RDFINMEMORYDATASOURCE_CID);
+NS_DEFINE_NAMED_CID(NS_RDFXMLDATASOURCE_CID);
+NS_DEFINE_NAMED_CID(NS_RDFDEFAULTRESOURCE_CID);
+NS_DEFINE_NAMED_CID(NS_RDFCONTENTSINK_CID);
+NS_DEFINE_NAMED_CID(NS_RDFCONTAINER_CID);
+NS_DEFINE_NAMED_CID(NS_RDFCONTAINERUTILS_CID);
+NS_DEFINE_NAMED_CID(NS_RDFSERVICE_CID);
+NS_DEFINE_NAMED_CID(NS_RDFXMLPARSER_CID);
+NS_DEFINE_NAMED_CID(NS_RDFXMLSERIALIZER_CID);
+NS_DEFINE_NAMED_CID(NS_LOCALSTORE_CID);
+
+
+static const mozilla::Module::CIDEntry kRDFCIDs[] = {
+    { &kNS_RDFCOMPOSITEDATASOURCE_CID, false, nullptr, CreateNewRDFCompositeDataSource },
+    { &kNS_RDFINMEMORYDATASOURCE_CID, false, nullptr, NS_NewRDFInMemoryDataSource },
+    { &kNS_RDFXMLDATASOURCE_CID, false, nullptr, CreateNewRDFXMLDataSource },
+    { &kNS_RDFDEFAULTRESOURCE_CID, false, nullptr, CreateNewRDFDefaultResource },
+    { &kNS_RDFCONTENTSINK_CID, false, nullptr, CreateNewRDFContentSink },
+    { &kNS_RDFCONTAINER_CID, false, nullptr, CreateNewRDFContainer },
+    { &kNS_RDFCONTAINERUTILS_CID, false, nullptr, CreateNewRDFContainerUtils },
+    { &kNS_RDFSERVICE_CID, false, nullptr, RDFServiceImpl::CreateSingleton },
+    { &kNS_RDFXMLPARSER_CID, false, nullptr, nsRDFXMLParser::Create },
+    { &kNS_RDFXMLSERIALIZER_CID, false, nullptr, nsRDFXMLSerializer::Create },
+    { &kNS_LOCALSTORE_CID, false, nullptr, NS_NewLocalStore },
+    { nullptr }
+};
+
+static const mozilla::Module::ContractIDEntry kRDFContracts[] = {
+    { NS_RDF_DATASOURCE_CONTRACTID_PREFIX "composite-datasource", &kNS_RDFCOMPOSITEDATASOURCE_CID },
+    { NS_RDF_DATASOURCE_CONTRACTID_PREFIX "in-memory-datasource", &kNS_RDFINMEMORYDATASOURCE_CID },
+    { NS_RDF_DATASOURCE_CONTRACTID_PREFIX "xml-datasource", &kNS_RDFXMLDATASOURCE_CID },
+    { NS_RDF_RESOURCE_FACTORY_CONTRACTID, &kNS_RDFDEFAULTRESOURCE_CID },
+    { NS_RDF_CONTRACTID "/content-sink;1", &kNS_RDFCONTENTSINK_CID },
+    { NS_RDF_CONTRACTID "/container;1", &kNS_RDFCONTAINER_CID },
+    { NS_RDF_CONTRACTID "/container-utils;1", &kNS_RDFCONTAINERUTILS_CID },
+    { NS_RDF_CONTRACTID "/rdf-service;1", &kNS_RDFSERVICE_CID },
+    { NS_RDF_CONTRACTID "/xml-parser;1", &kNS_RDFXMLPARSER_CID },
+    { NS_RDF_CONTRACTID "/xml-serializer;1", &kNS_RDFXMLSERIALIZER_CID },
+    { NS_LOCALSTORE_CONTRACTID, &kNS_LOCALSTORE_CID },
+    { nullptr }
+};
+
+static const mozilla::Module kRDFModule = {
+    mozilla::Module::kVersion,
+    kRDFCIDs,
+    kRDFContracts,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr
+};
+
+NSMODULE_DEFN(nsRDFModule) = &kRDFModule;

rdf/datasource/moz.build

@@ -0,0 +1,21 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+EXPORTS += [
+    'nsILocalStore.h',
+]
+
+UNIFIED_SOURCES += [
+    'nsLocalStore.cpp',
+]
+
+FINAL_LIBRARY = 'xul'
+
+# "This is a dependency on rdfutil.h: it'll go away once that becomes
+# a first-class XPCOM interface."
+LOCAL_INCLUDES += [
+    '/rdf/base',
+]

rdf/datasource/nsILocalStore.h

@@ -0,0 +1,34 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsILocalStore_h__
+#define nsILocalStore_h__
+
+#include "rdf.h"
+#include "nsISupports.h"
+
+// {DF71C6F1-EC53-11d2-BDCA-000064657374}
+#define NS_ILOCALSTORE_IID \
+{ 0xdf71c6f1, 0xec53, 0x11d2, { 0xbd, 0xca, 0x0, 0x0, 0x64, 0x65, 0x73, 0x74 } }
+
+// {DF71C6F0-EC53-11d2-BDCA-000064657374}
+#define NS_LOCALSTORE_CID \
+{ 0xdf71c6f0, 0xec53, 0x11d2, { 0xbd, 0xca, 0x0, 0x0, 0x64, 0x65, 0x73, 0x74 } }
+
+#define NS_LOCALSTORE_CONTRACTID NS_RDF_DATASOURCE_CONTRACTID_PREFIX "local-store"
+
+class nsILocalStore : public nsISupports
+{
+public:
+    NS_DECLARE_STATIC_IID_ACCESSOR(NS_ILOCALSTORE_IID)
+};
+
+NS_DEFINE_STATIC_IID_ACCESSOR(nsILocalStore, NS_ILOCALSTORE_IID)
+
+extern nsresult
+NS_NewLocalStore(nsISupports* aOuter, REFNSIID aIID, void** aResult);
+
+
+#endif // nsILocalStore_h__

rdf/datasource/nsIRDFFTP.h

@@ -0,0 +1,33 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef	nsIRDFFTP_h__
+#define	nsIRDFFTP_h__
+
+#include "nscore.h"
+#include "nsISupports.h"
+#include "nsIRDFNode.h"
+
+
+
+#define NS_IRDFFTPDATAOURCE_IID \
+{ 0x1222e6f0, 0xa5e3, 0x11d2, { 0x8b, 0x7c, 0x00, 0x80, 0x5f, 0x8a, 0x7d, 0xb7 } }
+
+class nsIRDFFTPDataSource : public nsIRDFDataSource
+{
+public:
+};
+
+
+#define NS_IRDFFTPDATASOURCECALLBACK_IID \
+{ 0x204a1a00, 0xa5e4, 0x11d2, { 0x8b, 0x7c, 0x00, 0x80, 0x5f, 0x8a, 0x7d, 0xb8 } }
+
+class nsIRDFFTPDataSourceCallback : public nsIStreamListener
+{
+public:
+};
+
+
+#endif // nsIRDFFTP_h__

rdf/datasource/nsLocalStore.cpp

@@ -0,0 +1,474 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* vim: set cindent tabstop=4 expandtab shiftwidth=4: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+
+  Implementation for the local store
+
+ */
+
+#include "nsNetUtil.h"
+#include "nsIFile.h"
+#include "nsIURI.h"
+#include "nsIIOService.h"
+#include "nsIOutputStream.h"
+#include "nsIComponentManager.h"
+#include "nsILocalStore.h"
+#include "nsIRDFDataSource.h"
+#include "nsIRDFRemoteDataSource.h"
+#include "nsIRDFService.h"
+#include "nsIServiceManager.h"
+#include "nsRDFCID.h"
+#include "nsString.h"
+#include "plstr.h"
+#include "rdf.h"
+#include "nsCOMPtr.h"
+#include "nsWeakPtr.h"
+#include "nsAppDirectoryServiceDefs.h"
+#include "nsIObserver.h"
+#include "nsIObserverService.h"
+#include "nsWeakReference.h"
+#include "nsCRTGlue.h"
+#include "nsCRT.h"
+#include "nsEnumeratorUtils.h"
+#include "nsCycleCollectionParticipant.h"
+
+////////////////////////////////////////////////////////////////////////
+
+class LocalStoreImpl : public nsILocalStore,
+                       public nsIRDFDataSource,
+                       public nsIRDFRemoteDataSource,
+                       public nsIObserver,
+                       public nsSupportsWeakReference
+{
+protected:
+    nsCOMPtr<nsIRDFDataSource> mInner;
+
+    LocalStoreImpl();
+    virtual ~LocalStoreImpl();
+    nsresult Init();
+    nsresult CreateLocalStore(nsIFile* aFile);
+    nsresult LoadData();
+
+    friend nsresult
+    NS_NewLocalStore(nsISupports* aOuter, REFNSIID aIID, void** aResult);
+
+    nsCOMPtr<nsIRDFService>    mRDFService;
+
+public:
+    // nsISupports interface
+    NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+    NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(LocalStoreImpl, nsILocalStore)
+
+    // nsILocalStore interface
+
+    // nsIRDFDataSource interface. Most of these are just delegated to
+    // the inner, in-memory datasource.
+    NS_IMETHOD GetURI(nsACString& aURI) override;
+
+    NS_IMETHOD GetSource(nsIRDFResource* aProperty,
+                         nsIRDFNode* aTarget,
+                         bool aTruthValue,
+                         nsIRDFResource** aSource) override {
+        return mInner->GetSource(aProperty, aTarget, aTruthValue, aSource);
+    }
+
+    NS_IMETHOD GetSources(nsIRDFResource* aProperty,
+                          nsIRDFNode* aTarget,
+                          bool aTruthValue,
+                          nsISimpleEnumerator** aSources) override {
+        return mInner->GetSources(aProperty, aTarget, aTruthValue, aSources);
+    }
+
+    NS_IMETHOD GetTarget(nsIRDFResource* aSource,
+                         nsIRDFResource* aProperty,
+                         bool aTruthValue,
+                         nsIRDFNode** aTarget) override {
+        return mInner->GetTarget(aSource, aProperty, aTruthValue, aTarget);
+    }
+
+    NS_IMETHOD GetTargets(nsIRDFResource* aSource,
+                          nsIRDFResource* aProperty,
+                          bool aTruthValue,
+                          nsISimpleEnumerator** aTargets) override {
+        return mInner->GetTargets(aSource, aProperty, aTruthValue, aTargets);
+    }
+
+    NS_IMETHOD Assert(nsIRDFResource* aSource,
+                      nsIRDFResource* aProperty,
+                      nsIRDFNode* aTarget,
+                      bool aTruthValue) override {
+        return mInner->Assert(aSource, aProperty, aTarget, aTruthValue);
+    }
+
+    NS_IMETHOD Unassert(nsIRDFResource* aSource,
+                        nsIRDFResource* aProperty,
+                        nsIRDFNode* aTarget) override {
+        return mInner->Unassert(aSource, aProperty, aTarget);
+    }
+
+    NS_IMETHOD Change(nsIRDFResource* aSource,
+                      nsIRDFResource* aProperty,
+                      nsIRDFNode* aOldTarget,
+                      nsIRDFNode* aNewTarget) override {
+        return mInner->Change(aSource, aProperty, aOldTarget, aNewTarget);
+    }
+
+    NS_IMETHOD Move(nsIRDFResource* aOldSource,
+                    nsIRDFResource* aNewSource,
+                    nsIRDFResource* aProperty,
+                    nsIRDFNode* aTarget) override {
+        return mInner->Move(aOldSource, aNewSource, aProperty, aTarget);
+    }
+
+    NS_IMETHOD HasAssertion(nsIRDFResource* aSource,
+                            nsIRDFResource* aProperty,
+                            nsIRDFNode* aTarget,
+                            bool aTruthValue,
+                            bool* hasAssertion) override {
+        return mInner->HasAssertion(aSource, aProperty, aTarget, aTruthValue, hasAssertion);
+    }
+
+    NS_IMETHOD AddObserver(nsIRDFObserver* aObserver) override {
+        return NS_ERROR_NOT_IMPLEMENTED;
+    }
+
+    NS_IMETHOD RemoveObserver(nsIRDFObserver* aObserver) override {
+        return NS_ERROR_NOT_IMPLEMENTED;
+    }
+
+    NS_IMETHOD HasArcIn(nsIRDFNode *aNode, nsIRDFResource *aArc, bool *_retval) override {
+        return mInner->HasArcIn(aNode, aArc, _retval);
+    }
+
+    NS_IMETHOD HasArcOut(nsIRDFResource *aSource, nsIRDFResource *aArc, bool *_retval) override {
+        return mInner->HasArcOut(aSource, aArc, _retval);
+    }
+
+    NS_IMETHOD ArcLabelsIn(nsIRDFNode* aNode,
+                           nsISimpleEnumerator** aLabels) override {
+        return mInner->ArcLabelsIn(aNode, aLabels);
+    }
+
+    NS_IMETHOD ArcLabelsOut(nsIRDFResource* aSource,
+                            nsISimpleEnumerator** aLabels) override {
+        return mInner->ArcLabelsOut(aSource, aLabels);
+    }
+
+    NS_IMETHOD GetAllResources(nsISimpleEnumerator** aResult) override {
+        return mInner->GetAllResources(aResult);
+    }
+
+    NS_IMETHOD GetAllCmds(nsIRDFResource* aSource,
+                              nsISimpleEnumerator/*<nsIRDFResource>*/** aCommands) override;
+
+    NS_IMETHOD IsCommandEnabled(nsISupports* aSources,
+                                nsIRDFResource*   aCommand,
+                                nsISupports* aArguments,
+                                bool* aResult) override;
+
+    NS_IMETHOD DoCommand(nsISupports* aSources,
+                         nsIRDFResource*   aCommand,
+                         nsISupports* aArguments) override;
+
+    NS_IMETHOD BeginUpdateBatch() override {
+        return mInner->BeginUpdateBatch();
+    }
+
+    NS_IMETHOD EndUpdateBatch() override {
+        return mInner->EndUpdateBatch();
+    }
+
+    NS_IMETHOD GetLoaded(bool* _result) override;
+    NS_IMETHOD Init(const char *uri) override;
+    NS_IMETHOD Flush() override;
+    NS_IMETHOD FlushTo(const char *aURI) override;
+    NS_IMETHOD Refresh(bool sync) override;
+
+    // nsIObserver
+    NS_DECL_NSIOBSERVER
+};
+
+////////////////////////////////////////////////////////////////////////
+
+
+LocalStoreImpl::LocalStoreImpl(void)
+{
+}
+
+LocalStoreImpl::~LocalStoreImpl(void)
+{
+    if (mRDFService)
+        mRDFService->UnregisterDataSource(this);
+}
+
+
+nsresult
+NS_NewLocalStore(nsISupports* aOuter, REFNSIID aIID, void** aResult)
+{
+    NS_PRECONDITION(aOuter == nullptr, "no aggregation");
+    if (aOuter)
+        return NS_ERROR_NO_AGGREGATION;
+
+    NS_PRECONDITION(aResult != nullptr, "null ptr");
+    if (! aResult)
+        return NS_ERROR_NULL_POINTER;
+
+    LocalStoreImpl* impl = new LocalStoreImpl();
+    if (! impl)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    NS_ADDREF(impl);
+
+    nsresult rv;
+    rv = impl->Init();
+    if (NS_SUCCEEDED(rv)) {
+        // Set up the result pointer
+        rv = impl->QueryInterface(aIID, aResult);
+    }
+
+    NS_RELEASE(impl);
+    return rv;
+}
+
+NS_IMPL_CYCLE_COLLECTION(LocalStoreImpl, mInner)
+NS_IMPL_CYCLE_COLLECTING_ADDREF(LocalStoreImpl)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(LocalStoreImpl)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(LocalStoreImpl)
+    NS_INTERFACE_MAP_ENTRY(nsILocalStore)
+    NS_INTERFACE_MAP_ENTRY(nsIRDFDataSource)
+    NS_INTERFACE_MAP_ENTRY(nsIRDFRemoteDataSource)
+    NS_INTERFACE_MAP_ENTRY(nsIObserver)
+    NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
+    NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsILocalStore)
+NS_INTERFACE_MAP_END
+
+// nsILocalStore interface
+
+// nsIRDFDataSource interface
+
+NS_IMETHODIMP
+LocalStoreImpl::GetLoaded(bool* _result)
+{
+	nsCOMPtr<nsIRDFRemoteDataSource> remote = do_QueryInterface(mInner);
+    NS_ASSERTION(remote != nullptr, "not an nsIRDFRemoteDataSource");
+	if (! remote)
+        return NS_ERROR_UNEXPECTED;
+
+    return remote->GetLoaded(_result);
+}
+
+
+NS_IMETHODIMP
+LocalStoreImpl::Init(const char *uri)
+{
+	return(NS_OK);
+}
+
+NS_IMETHODIMP
+LocalStoreImpl::Flush()
+{
+	nsCOMPtr<nsIRDFRemoteDataSource> remote = do_QueryInterface(mInner);
+    // FIXME Bug 340242: Temporarily make this a warning rather than an
+    // assertion until we sort out the ordering of how we write
+    // everything to the localstore, flush it, and disconnect it when
+    // we're getting profile-change notifications.
+    NS_WARNING_ASSERTION(remote != nullptr, "not an nsIRDFRemoteDataSource");
+	if (! remote)
+        return NS_ERROR_UNEXPECTED;
+
+    return remote->Flush();
+}
+
+NS_IMETHODIMP
+LocalStoreImpl::FlushTo(const char *aURI)
+{
+  // Do not ever implement this (security)
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+LocalStoreImpl::Refresh(bool sync)
+{
+	nsCOMPtr<nsIRDFRemoteDataSource> remote = do_QueryInterface(mInner);
+    NS_ASSERTION(remote != nullptr, "not an nsIRDFRemoteDataSource");
+	if (! remote)
+        return NS_ERROR_UNEXPECTED;
+
+    return remote->Refresh(sync);
+}
+
+nsresult
+LocalStoreImpl::Init()
+{
+    nsresult rv;
+
+    rv = LoadData();
+    if (NS_FAILED(rv)) return rv;
+
+    // register this as a named data source with the RDF service
+    mRDFService = do_GetService(NS_RDF_CONTRACTID "/rdf-service;1", &rv);
+    if (NS_FAILED(rv)) return rv;
+
+    mRDFService->RegisterDataSource(this, false);
+
+    // Register as an observer of profile changes
+    nsCOMPtr<nsIObserverService> obs =
+        do_GetService("@mozilla.org/observer-service;1");
+
+    if (obs) {
+        obs->AddObserver(this, "profile-before-change", true);
+        obs->AddObserver(this, "profile-do-change", true);
+    }
+
+    return NS_OK;
+}
+
+nsresult
+LocalStoreImpl::CreateLocalStore(nsIFile* aFile)
+{
+    nsresult rv;
+
+    rv = aFile->Create(nsIFile::NORMAL_FILE_TYPE, 0666);
+    if (NS_FAILED(rv)) return rv;
+
+    nsCOMPtr<nsIOutputStream> outStream;
+    rv = NS_NewLocalFileOutputStream(getter_AddRefs(outStream), aFile);
+    if (NS_FAILED(rv)) return rv;
+
+    const char defaultRDF[] =
+        "<?xml version=\"1.0\"?>\n" \
+        "<RDF:RDF xmlns:RDF=\"" RDF_NAMESPACE_URI "\"\n" \
+        "         xmlns:NC=\""  NC_NAMESPACE_URI "\">\n" \
+        "  <!-- Empty -->\n" \
+        "</RDF:RDF>\n";
+
+    uint32_t count;
+    rv = outStream->Write(defaultRDF, sizeof(defaultRDF)-1, &count);
+    if (NS_FAILED(rv)) return rv;
+
+    if (count != sizeof(defaultRDF)-1)
+        return NS_ERROR_UNEXPECTED;
+
+    // Okay, now see if the file exists _for real_. If it's still
+    // not there, it could be that the profile service gave us
+    // back a read-only directory. Whatever.
+    bool fileExistsFlag = false;
+    aFile->Exists(&fileExistsFlag);
+    if (!fileExistsFlag)
+        return NS_ERROR_UNEXPECTED;
+
+    return NS_OK;
+}
+
+nsresult
+LocalStoreImpl::LoadData()
+{
+    nsresult rv;
+
+    // Look for localstore.rdf in the current profile
+    // directory. Bomb if we can't find it.
+
+    nsCOMPtr<nsIFile> aFile;
+    rv = NS_GetSpecialDirectory(NS_APP_LOCALSTORE_50_FILE, getter_AddRefs(aFile));
+    if (NS_FAILED(rv)) return rv;
+
+    bool fileExistsFlag = false;
+    (void)aFile->Exists(&fileExistsFlag);
+    if (!fileExistsFlag) {
+        // if file doesn't exist, create it
+        rv = CreateLocalStore(aFile);
+        if (NS_FAILED(rv)) return rv;
+    }
+
+    mInner = do_CreateInstance(NS_RDF_DATASOURCE_CONTRACTID_PREFIX "xml-datasource", &rv);
+    if (NS_FAILED(rv)) return rv;
+
+    nsCOMPtr<nsIRDFRemoteDataSource> remote = do_QueryInterface(mInner, &rv);
+    if (NS_FAILED(rv)) return rv;
+
+    nsCOMPtr<nsIURI> aURI;
+    rv = NS_NewFileURI(getter_AddRefs(aURI), aFile);
+    if (NS_FAILED(rv)) return rv;
+
+    nsAutoCString spec;
+    rv = aURI->GetSpec(spec);
+    if (NS_FAILED(rv)) return rv;
+
+    rv = remote->Init(spec.get());
+    if (NS_FAILED(rv)) return rv;
+
+    // Read the datasource synchronously.
+    rv = remote->Refresh(true);
+
+    if (NS_FAILED(rv)) {
+        // Load failed, delete and recreate a fresh localstore
+        aFile->Remove(true);
+        rv = CreateLocalStore(aFile);
+        if (NS_FAILED(rv)) return rv;
+
+        rv = remote->Refresh(true);
+    }
+
+    return rv;
+}
+
+
+NS_IMETHODIMP
+LocalStoreImpl::GetURI(nsACString& aURI)
+{
+    aURI.AssignLiteral("rdf:local-store");
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+LocalStoreImpl::GetAllCmds(nsIRDFResource* aSource,
+                               nsISimpleEnumerator/*<nsIRDFResource>*/** aCommands)
+{
+	return(NS_NewEmptyEnumerator(aCommands));
+}
+
+NS_IMETHODIMP
+LocalStoreImpl::IsCommandEnabled(nsISupports* aSources,
+                                 nsIRDFResource*   aCommand,
+                                 nsISupports* aArguments,
+                                 bool* aResult)
+{
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+LocalStoreImpl::DoCommand(nsISupports* aSources,
+                          nsIRDFResource*   aCommand,
+                          nsISupports* aArguments)
+{
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+LocalStoreImpl::Observe(nsISupports *aSubject, const char *aTopic, const char16_t *someData)
+{
+    nsresult rv = NS_OK;
+
+    if (!nsCRT::strcmp(aTopic, "profile-before-change")) {
+        // Write out the old datasource's contents.
+        if (mInner) {
+            nsCOMPtr<nsIRDFRemoteDataSource> remote = do_QueryInterface(mInner);
+            if (remote)
+                remote->Flush();
+        }
+
+        // Create an in-memory datasource for use while we're
+        // profile-less.
+        mInner = do_CreateInstance(NS_RDF_DATASOURCE_CONTRACTID_PREFIX "in-memory-datasource");
+    }
+    else if (!nsCRT::strcmp(aTopic, "profile-do-change")) {
+        rv = LoadData();
+    }
+    return rv;
+}

rdf/datasource/nsRDFBuiltInDataSources.h

@@ -0,0 +1,27 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+
+  This header file just contains prototypes for the factory methods
+  for "builtin" data sources that are included in rdf.dll.
+
+  Each of these data sources is exposed to the external world via its
+  CID in ../include/nsRDFCID.h.
+
+ */
+
+#ifndef nsBuiltinDataSources_h__
+#define nsBuiltinDataSources_h__
+
+#include "nsError.h"
+
+class nsIRDFDataSource;
+
+// in nsFileSystemDataSource.cpp
+nsresult NS_NewRDFFileSystemDataSource(nsIRDFDataSource** result);
+
+#endif // nsBuiltinDataSources_h__
+

rdf/moz.build

@@ -0,0 +1,12 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+with Files('**'):
+    BUG_COMPONENT = ('Core', 'RDF')
+
+DIRS += ['base', 'datasource', 'build']
+TEST_DIRS += ['tests']
+

rdf/tests/moz.build

@@ -0,0 +1,7 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+XPCSHELL_TESTS_MANIFESTS += ['unit/xpcshell.ini']

rdf/tests/unit/sample.rdf

@@ -0,0 +1,9 @@
+<?xml version="1.0"?>
+
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+         xmlns:dc="http://purl.org/dc/elements/1.1/">
+
+  <rdf:Description about="urn:mozilla:sample-data"
+    dc:title="Sample" />
+
+</rdf:RDF>

rdf/tests/unit/test_rdfredirect.js

@@ -0,0 +1,92 @@
+ChromeUtils.import("resource://testing-common/httpd.js");
+
+function getRDFService()
+{
+  return Cc["@mozilla.org/rdf/rdf-service;1"].
+    getService(Ci.nsIRDFService);
+}
+
+var server1, server2;
+
+function run_test()
+{
+  var samplefile = do_get_file('sample.rdf');
+
+  server1 = new HttpServer();
+  server1.registerPathHandler("/sample-xs.rdf", xsRedirect);
+  server1.registerPathHandler("/sample-local.rdf", localRedirect);
+  server1.registerFile('/sample.rdf', samplefile);
+  server1.start(4444);
+
+  server2 = new HttpServer();
+  server2.registerFile('/sample.rdf', samplefile);
+  server2.start(4445);
+
+  do_test_pending();
+
+  new rdfLoadObserver('http://localhost:4444/sample.rdf', true);
+  new rdfLoadObserver('http://localhost:4445/sample.rdf', true);
+  new rdfLoadObserver('http://localhost:4444/sample-xs.rdf', false);
+  new rdfLoadObserver('http://localhost:4444/sample-local.rdf', true);
+}
+
+var gPending = 0;
+
+function rdfLoadObserver(uri, shouldPass)
+{
+  this.shouldPass = shouldPass;
+  this.uri = uri;
+
+  ++gPending;
+
+  var rdfService = getRDFService();
+  this.ds = rdfService.GetDataSource(uri).
+    QueryInterface(Ci.nsIRDFXMLSink);
+  this.ds.addXMLSinkObserver(this);
+}
+
+rdfLoadObserver.prototype =
+{
+  onBeginLoad : function() { },
+  onInterrupt : function() { },
+  onResume : function() { },
+  onEndLoad : function() {
+    print("Testing results of loading " + this.uri);
+
+    var rdfs = getRDFService();
+    var res = rdfs.GetResource("urn:mozilla:sample-data");
+    var arc = rdfs.GetResource("http://purl.org/dc/elements/1.1/title");
+    var answer = this.ds.GetTarget(res, arc, true);
+    if (answer !== null) {
+      Assert.ok(this.shouldPass);
+      Assert.ok(answer instanceof Ci.nsIRDFLiteral);
+      Assert.equal(answer.Value, "Sample");
+    }
+    else {
+      Assert.ok(!this.shouldPass);
+    }
+
+    gPending -= 1;
+
+    this.ds.removeXMLSinkObserver(this);
+
+    if (gPending == 0) {
+      do_test_pending();
+      server1.stop(do_test_finished);
+      server2.stop(do_test_finished);
+    }
+  },
+  onError : function() { }
+}
+
+function xsRedirect(metadata, response)
+{
+  response.setStatusLine(metadata.httpVersion, 301, "Moved Permanently");
+  response.setHeader("Location", "http://localhost:4445/sample.rdf", false);
+}
+
+function localRedirect(metadata, response)
+{
+  response.setStatusLine(metadata.httpVersion, 301, "Moved Permanently");
+  response.setHeader("Location", "http://localhost:4444/sample.rdf", false);
+}

rdf/tests/unit/xpcshell.ini

@@ -0,0 +1,5 @@
+[DEFAULT]
+head =
+support-files = sample.rdf
+
+[test_rdfredirect.js]

toolkit/components/build/nsToolkitCompsModule.cpp

@@ -20,6 +20,7 @@
 #include "nsAlertsService.h"
 
 #include "DownloadPlatform.h"
+#include "rdf.h"
 
 #include "nsTypeAheadFind.h"
 

toolkit/components/utils/simpleServices.js

@@ -21,11 +21,6 @@ ChromeUtils.defineModuleGetter(this, "NetUtil",
 ChromeUtils.defineModuleGetter(this, "Services",
                                "resource://gre/modules/Services.jsm");
 
-XPCOMUtils.defineLazyServiceGetter(this, "catMan", "@mozilla.org/categorymanager;1",
-                                   "nsICategoryManager");
-XPCOMUtils.defineLazyServiceGetter(this, "streamConv", "@mozilla.org/streamConverters;1",
-                                   "nsIStreamConverterService");
-
 /*
  * This class provides a stream filter for locale messages in CSS files served
  * by the moz-extension: protocol handler.
@@ -116,32 +111,4 @@ AddonLocalizationConverter.prototype = {
   },
 };
 
-function HttpIndexViewer() {
+this.NSGetFactory = XPCOMUtils.generateNSGetFactory([AddonLocalizationConverter]);
-}
-
-HttpIndexViewer.prototype = {
-  classID: Components.ID("{742ad274-34c5-43d1-a8b7-293eaf8962d6}"),
-  QueryInterface: ChromeUtils.generateQI([Ci.nsIDocumentLoaderFactory]),
-
-  createInstance(aCommand, aChannel, aLoadGroup, aContentType, aContainer,
-                 aExtraInfo, aDocListenerResult) {
-    aChannel.contentType = "text/html";
-
-    let contract = catMan.getCategoryEntry("Gecko-Content-Viewers", "text/html");
-    let factory = Cc[contract].getService(Ci.nsIDocumentLoaderFactory);
-
-    let listener = {};
-    let res = factory.createInstance("view", aChannel, aLoadGroup,
-                                     "text/html", aContainer, aExtraInfo,
-                                     listener);
-
-    aDocListenerResult.value =
-      streamConv.asyncConvertData("application/http-index-format",
-                                  "text/html", listener.value, null);
-
-    return res;
-  },
-};
-
-this.NSGetFactory = XPCOMUtils.generateNSGetFactory([AddonLocalizationConverter,
-                                                     HttpIndexViewer]);

toolkit/components/utils/utils.manifest

@@ -2,7 +2,3 @@ component {dfd07380-6083-11e4-9803-0800200c9a66} simpleServices.js
 contract @mozilla.org/addons/remote-tag-service;1 {dfd07380-6083-11e4-9803-0800200c9a66}
 component {ded150e3-c92e-4077-a396-0dba9953e39f} simpleServices.js
 contract @mozilla.org/streamconv;1?from=application/vnd.mozilla.webext.unlocalized&to=text/css {ded150e3-c92e-4077-a396-0dba9953e39f}
-
-component {742ad274-34c5-43d1-a8b7-293eaf8962d6} simpleServices.js
-contract @mozilla.org/content-viewsers/http-index-format {742ad274-34c5-43d1-a8b7-293eaf8962d6}
-category Gecko-Content-Viewers application/http-index-format @mozilla.org/content-viewsers/http-index-format

toolkit/toolkit.mozbuild

@@ -88,6 +88,10 @@ DIRS += [
     '/extensions/permissions',
 ]
 
+DIRS += [
+    '/rdf',
+]
+
 if CONFIG['MOZ_WEBRTC'] and CONFIG['COMPILE_ENVIRONMENT']:
     DIRS += [
         '/media/webrtc',
@@ -131,6 +135,7 @@ DIRS += [
     '/tools/code-coverage',
     '/tools/power',
     '/tools/profiler',
+    '/xpfe/components',
 ]
 
 if CONFIG['MOZ_ENABLE_XREMOTE']:

xpfe/components/build/moz.build

@@ -0,0 +1,18 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+with Files("**"):
+    BUG_COMPONENT = ("Core", "Window Management")
+
+SOURCES += [
+    'nsModule.cpp',
+]
+
+FINAL_LIBRARY = 'xul'
+
+LOCAL_INCLUDES += [
+    '../directory',
+]

xpfe/components/build/nsModule.cpp

@@ -0,0 +1,44 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "mozilla/ModuleUtils.h"
+#include "nsDirectoryViewer.h"
+#include "rdf.h"
+#include "nsRDFCID.h"
+#include "nsCURILoader.h"
+
+// Factory constructors
+NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsHTTPIndex, Init)
+NS_GENERIC_FACTORY_CONSTRUCTOR(nsDirectoryViewerFactory)
+
+NS_DEFINE_NAMED_CID(NS_DIRECTORYVIEWERFACTORY_CID);
+NS_DEFINE_NAMED_CID(NS_HTTPINDEX_SERVICE_CID);
+
+static const mozilla::Module::CIDEntry kXPFECIDs[] = {
+    { &kNS_DIRECTORYVIEWERFACTORY_CID, false, nullptr, nsDirectoryViewerFactoryConstructor },
+    { &kNS_HTTPINDEX_SERVICE_CID, false, nullptr, nsHTTPIndexConstructor },
+    { nullptr }
+};
+
+static const mozilla::Module::ContractIDEntry kXPFEContracts[] = {
+    { "@mozilla.org/xpfe/http-index-format-factory-constructor", &kNS_DIRECTORYVIEWERFACTORY_CID },
+    { NS_HTTPINDEX_SERVICE_CONTRACTID, &kNS_HTTPINDEX_SERVICE_CID },
+    { NS_HTTPINDEX_DATASOURCE_CONTRACTID, &kNS_HTTPINDEX_SERVICE_CID },
+    { nullptr }
+};
+
+static const mozilla::Module::CategoryEntry kXPFECategories[] = {
+    { "Gecko-Content-Viewers", "application/http-index-format", "@mozilla.org/xpfe/http-index-format-factory-constructor" },
+    { nullptr }
+};
+
+static const mozilla::Module kXPFEModule = {
+    mozilla::Module::kVersion,
+    kXPFECIDs,
+    kXPFEContracts,
+    kXPFECategories
+};
+
+NSMODULE_DEFN(application) = &kXPFEModule;

xpfe/components/directory/moz.build

@@ -0,0 +1,23 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+with Files("**"):
+    BUG_COMPONENT = ("Core", "Window Management")
+
+XPIDL_SOURCES += [
+    'nsIHTTPIndex.idl',
+]
+
+XPIDL_MODULE = 'directory'
+
+SOURCES += [
+    'nsDirectoryViewer.cpp',
+]
+
+FINAL_LIBRARY = 'xul'
+
+if CONFIG['CC_TYPE'] in ('clang', 'gcc'):
+    CXXFLAGS += ['-Wno-error=shadow']

xpfe/components/directory/nsDirectoryViewer.h

@@ -0,0 +1,126 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef nsdirectoryviewer__h____
+#define nsdirectoryviewer__h____
+
+#include "nsCOMPtr.h"
+#include "nsIStreamListener.h"
+#include "nsIContentViewer.h"
+#include "nsIHTTPIndex.h"
+#include "nsIRDFService.h"
+#include "nsIRDFDataSource.h"
+#include "nsIRDFLiteral.h"
+#include "nsIDocumentLoaderFactory.h"
+#include "nsITimer.h"
+#include "nsString.h"
+#include "nsIDirIndexListener.h"
+#include "nsIFTPChannel.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIURI.h"
+
+class nsIMutableArray;
+
+class nsDirectoryViewerFactory : public nsIDocumentLoaderFactory
+{
+public:
+    nsDirectoryViewerFactory();
+
+    // nsISupports interface
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIDOCUMENTLOADERFACTORY
+
+protected:
+    virtual ~nsDirectoryViewerFactory();
+};
+
+class nsHTTPIndex final : public nsIHTTPIndex,
+                          public nsIRDFDataSource,
+                          public nsIStreamListener,
+                          public nsIDirIndexListener,
+                          public nsIInterfaceRequestor,
+                          public nsIFTPEventSink
+{
+private:
+
+    // note: these are NOT statics due to the native of nsHTTPIndex
+    // where it may or may not be treated as a singleton
+
+    nsCOMPtr<nsIRDFResource>     kNC_Child;
+    nsCOMPtr<nsIRDFResource>     kNC_Comment;
+    nsCOMPtr<nsIRDFResource>     kNC_Loading;
+    nsCOMPtr<nsIRDFResource>     kNC_URL;
+    nsCOMPtr<nsIRDFResource>     kNC_Description;
+    nsCOMPtr<nsIRDFResource>     kNC_ContentLength;
+    nsCOMPtr<nsIRDFResource>     kNC_LastModified;
+    nsCOMPtr<nsIRDFResource>     kNC_ContentType;
+    nsCOMPtr<nsIRDFResource>     kNC_FileType;
+    nsCOMPtr<nsIRDFResource>     kNC_IsContainer;
+    nsCOMPtr<nsIRDFLiteral>      kTrueLiteral;
+    nsCOMPtr<nsIRDFLiteral>      kFalseLiteral;
+
+    nsCOMPtr<nsIRDFService>      mDirRDF;
+
+protected:
+    // We grab a reference to the content viewer container (which
+    // indirectly owns us) so that we can insert ourselves as a global
+    // in the script context _after_ the XUL doc has been embedded into
+    // content viewer. We'll know that this has happened once we receive
+    // an OnStartRequest() notification
+
+    nsCOMPtr<nsIRDFDataSource>   mInner;
+    nsCOMPtr<nsIMutableArray>    mConnectionList;
+    nsCOMPtr<nsIMutableArray>    mNodeList;
+    nsCOMPtr<nsITimer>           mTimer;
+    nsCOMPtr<nsIDirIndexParser>  mParser;
+    nsCString mBaseURL;
+    nsCString                    mEncoding;
+    bool                         mBindToGlobalObject;
+    nsIInterfaceRequestor*       mRequestor; // WEAK
+    nsCOMPtr<nsIRDFResource>     mDirectory;
+
+    explicit nsHTTPIndex(nsIInterfaceRequestor* aRequestor);
+    nsresult CommonInit(void);
+    nsresult Init(nsIURI* aBaseURL);
+    void        GetDestination(nsIRDFResource* r, nsACString& dest);
+    bool        isWellknownContainerURI(nsIRDFResource *r);
+    nsresult    AddElement(nsIRDFResource *parent, nsIRDFResource *prop,
+                           nsIRDFNode *child);
+
+    static void FireTimer(nsITimer* aTimer, void* aClosure);
+
+    virtual ~nsHTTPIndex();
+
+public:
+    nsHTTPIndex();
+    nsresult Init(void);
+
+    static nsresult Create(nsIURI* aBaseURI, nsIInterfaceRequestor* aContainer,
+                           nsIHTTPIndex** aResult);
+
+    // nsIHTTPIndex interface
+    NS_DECL_NSIHTTPINDEX
+
+    // NSIRDFDataSource interface
+    NS_DECL_NSIRDFDATASOURCE
+
+    NS_DECL_NSIREQUESTOBSERVER
+    NS_DECL_NSISTREAMLISTENER
+
+    NS_DECL_NSIDIRINDEXLISTENER
+    NS_DECL_NSIINTERFACEREQUESTOR
+    NS_DECL_NSIFTPEVENTSINK
+
+    // nsISupports interface
+    NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+    NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsHTTPIndex, nsIHTTPIndex)
+};
+
+// {82776710-5690-11d3-BE36-00104BDE6048}
+#define NS_DIRECTORYVIEWERFACTORY_CID \
+{ 0x82776710, 0x5690, 0x11d3, { 0xbe, 0x36, 0x0, 0x10, 0x4b, 0xde, 0x60, 0x48 } }
+
+#endif // nsdirectoryviewer__h____

xpfe/components/directory/nsIHTTPIndex.idl

@@ -0,0 +1,50 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+
+  The interface to an HTTP index
+
+*/
+
+#include "nsISupports.idl"
+
+interface nsIStreamListener;
+interface nsIRDFDataSource;
+interface nsIRDFNode;
+interface nsIRDFResource;
+
+[scriptable, uuid(6F2BDBD0-58C3-11d3-BE36-00104BDE6048)]
+interface nsIHTTPIndex : nsISupports
+{
+    /**
+     * The base URL of the HTTP index
+     */
+    readonly attribute string BaseURL;
+
+    /**
+     * The RDF datasource that contains the HTTP index information.
+     */
+    readonly attribute nsIRDFDataSource DataSource;
+
+    /**
+     * The charset to use for decoding FTP filenames
+     */
+    attribute string encoding;
+};
+
+%{C++
+
+// {{2587e382-1324-11d4-a652-eadbb2be3484}
+#define NS_HTTPINDEX_SERVICE_CID \
+{ 0x2587e382, 0x1324, 0x11d4, { 0xa6, 0x52, 0xea, 0xdb, 0xb2, 0xbe, 0x34, 0x84 } }
+
+#define NS_HTTPINDEX_SERVICE_CONTRACTID \
+    "@mozilla.org/browser/httpindex-service;1"
+
+#define NS_HTTPINDEX_DATASOURCE_CONTRACTID \
+    "@mozilla.org/rdf/datasource;1?name=httpindex"
+
+%}

xpfe/components/moz.build

@@ -0,0 +1,14 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+with Files("**"):
+    BUG_COMPONENT = ("Core", "Window Management")
+
+DIRS += [
+    'directory',
+    'build',
+]
+