diff --git a/mozilla/content/xul/templates/src/nsXULTemplateBuilder.cpp b/mozilla/content/xul/templates/src/nsXULTemplateBuilder.cpp
index 0c73f8e7670..b8f304cc51c 100644
--- a/mozilla/content/xul/templates/src/nsXULTemplateBuilder.cpp
+++ b/mozilla/content/xul/templates/src/nsXULTemplateBuilder.cpp
@@ -756,7 +756,9 @@ RDFGenericBuilderImpl::OnSetAttribute(nsIDOMElement* aElement, const nsString& a
         }
 
         if ((rv == NS_CONTENT_ATTR_NO_VALUE) || (rv == NS_CONTENT_ATTR_NOT_THERE) ||
-            ((rv == NS_CONTENT_ATTR_HAS_VALUE) && (! attrValue.EqualsIgnoreCase(aValue)))) {
+            ((rv == NS_CONTENT_ATTR_HAS_VALUE) && (! attrValue.EqualsIgnoreCase(aValue))) ||
+            PR_TRUE // XXX just always allow this to fire.
+            ) {
             // Okay, it's really changing.
 
             // This is a "transient" property, so we _don't_ go to the
diff --git a/mozilla/rdf/base/public/nsIRDFNode.h b/mozilla/rdf/base/public/nsIRDFNode.h
index f89560a1a30..dddfb39c9c5 100644
--- a/mozilla/rdf/base/public/nsIRDFNode.h
+++ b/mozilla/rdf/base/public/nsIRDFNode.h
@@ -29,7 +29,7 @@
 #include "nscore.h"
 #include "rdf.h"
 #include "nsISupports.h"
-
+#include "prtime.h"
 // {0F78DA50-8321-11d2-8EAC-00805F29F370}
 #define NS_IRDFNODE_IID \
 { 0xf78da50, 0x8321, 0x11d2, { 0x8e, 0xac, 0x0, 0x80, 0x5f, 0x29, 0xf3, 0x70 } }
@@ -57,12 +57,6 @@ class NS_RDF nsIRDFNode : public nsISupports {
 public:
     static const nsIID& GetIID() { static nsIID iid = NS_IRDFNODE_IID; return iid; }
 
-    /**
-     * Called by nsIRDFService after constructing a resource object to
-     * initialize it's URI.
-     */
-    NS_IMETHOD Init(const char* uri) = 0;
-
     /**
      * Determine if two nodes are identical
      */
@@ -82,6 +76,12 @@ class NS_RDF nsIRDFResource : public nsIRDFNode {
 public:
     static const nsIID& GetIID() { static nsIID iid = NS_IRDFRESOURCE_IID; return iid; }
 
+    /**
+     * Called by nsIRDFService after constructing a resource object to
+     * initialize it's URI.
+     */
+    NS_IMETHOD Init(const char* uri) = 0;
+
     /**
      * Get the 8-bit string value of the node.
      */
@@ -118,6 +118,44 @@ public:
     NS_IMETHOD EqualsLiteral(const nsIRDFLiteral* literal, PRBool* result) const = 0;
 };
 
+// {E13A24E1-C77A-11d2-80BE-006097B76B8E}
+#define NS_IRDFDATE_IID \
+{ 0xe13a24e1, 0xc77a, 0x11d2, { 0x80, 0xbe, 0x0, 0x60, 0x97, 0xb7, 0x6b, 0x8e } };
+
+
+class nsIRDFDate : public nsIRDFNode {
+public:
+    static const nsIID& IID() { static nsIID iid = NS_IRDFDATE_IID; return iid; }
+
+    /**
+     * Get the PRTime value of the node.
+     */
+    NS_IMETHOD GetValue(PRTime *value) const = 0;
+
+    /**
+     * Determine if two ints are identical.
+     */
+    NS_IMETHOD EqualsDate(const nsIRDFDate* literal, PRBool* result) const = 0;
+};
+
+// {E13A24E3-C77A-11d2-80BE-006097B76B8E}
+#define NS_IRDFINT_IID \
+{ 0xe13a24e3, 0xc77a, 0x11d2, { 0x80, 0xbe, 0x0, 0x60, 0x97, 0xb7, 0x6b, 0x8e } };
+
+class nsIRDFInt : public nsIRDFNode {
+public:
+    static const nsIID& IID() { static nsIID iid = NS_IRDFINT_IID; return iid; }
+
+    /**
+     * Get the int32 value of the node.
+     */
+    NS_IMETHOD GetValue(int32 *value) const = 0;
+
+    /**
+     * Determine if two ints are identical.
+     */
+    NS_IMETHOD EqualsInt(const nsIRDFInt* literal, PRBool* result) const = 0;
+};
 
 
 #endif // nsIRDFNode_h__
diff --git a/mozilla/rdf/base/public/nsIRDFService.h b/mozilla/rdf/base/public/nsIRDFService.h
index 294e1c68930..ded747a1ae0 100644
--- a/mozilla/rdf/base/public/nsIRDFService.h
+++ b/mozilla/rdf/base/public/nsIRDFService.h
@@ -37,10 +37,14 @@
 
 #include "nscore.h"
 #include "nsISupports.h"
+#include "prtime.h"
 class nsIRDFDataBase;
 class nsIRDFDataSource;
 class nsIRDFLiteral;
 class nsIRDFResource;
+class nsIRDFResourceFactory;
+class nsIRDFDate;
+class nsIRDFInt;
 
 // {BFD05261-834C-11d2-8EAC-00805F29F370}
 #define NS_IRDFSERVICE_IID \
@@ -56,9 +60,11 @@ public:
     /**
      * Construct an RDF resource from a single-byte URI. <tt>nsIRDFSerivce</tt>
      * caches resources that are in-use, so multiple calls to <tt>GetResource()</tt>
-     * for the same <tt>uri</tt> will return identical pointers.
+     * for the same <tt>uri</tt> will return identical pointers. FindResource
+     * is used to find out whether there already exists a resource corresponding to that url.
      */
     NS_IMETHOD GetResource(const char* uri, nsIRDFResource** resource) = 0;
+    NS_IMETHOD FindResource(const char* uri, nsIRDFResource** resource, PRBool* found) = 0;
 
     /**
      * Construct an RDF resource from a Unicode URI. This is provided
@@ -74,6 +80,18 @@ public:
     NS_IMETHOD GetLiteral(const PRUnichar* value, nsIRDFLiteral** literal) = 0;
 
     /**
+
+     * Construct an RDF literal from a PRTime.
+     */
+    NS_IMETHOD GetDateLiteral(const PRTime value, nsIRDFDate** date) = 0;
+
+    /**
+     * Construct an RDF literal from an int.
+     */
+    NS_IMETHOD GetIntLiteral(const int32 value, nsIRDFInt** intLiteral) = 0;
+
+    /**
+
      * Registers a resource with the RDF system, making it unique w.r.t.
      * GetResource.
      *
@@ -100,6 +118,7 @@ public:
     NS_IMETHOD RegisterResource(nsIRDFResource* aResource, PRBool replace = PR_FALSE) = 0;
 
     /**
+
      * 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
diff --git a/mozilla/rdf/base/public/rdf.h b/mozilla/rdf/base/public/rdf.h
index 5c83472b201..5ab75189c94 100644
--- a/mozilla/rdf/base/public/rdf.h
+++ b/mozilla/rdf/base/public/rdf.h
@@ -66,6 +66,9 @@ static const char* kTag##prefix##_##name = #name
 #define NS_ERROR_RDF_CURSOR_EMPTY       NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_RDF, 1)
 #define NS_ERROR_RDF_NO_VALUE           NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_RDF, 2)
 
+
+
+
 /* ProgID prefixes for RDF DLL registration. */
 #define NS_RDF_PROGID                           "component:||netscape|rdf"
 #define NS_RDF_DATASOURCE_PROGID                NS_RDF_PROGID "|datasource"
@@ -73,6 +76,7 @@ static const char* kTag##prefix##_##name = #name
 #define NS_RDF_RESOURCE_FACTORY_PROGID          "component:||netscape|rdf|resource-factory"
 #define NS_RDF_RESOURCE_FACTORY_PROGID_PREFIX   NS_RDF_RESOURCE_FACTORY_PROGID "?name#"
 
+
 /*@}*/
 
 #ifdef _IMPL_NS_RDF
diff --git a/mozilla/rdf/base/src/nsRDFService.cpp b/mozilla/rdf/base/src/nsRDFService.cpp
index a45e3a5571a..4df0c07756e 100644
--- a/mozilla/rdf/base/src/nsRDFService.cpp
+++ b/mozilla/rdf/base/src/nsRDFService.cpp
@@ -25,6 +25,8 @@
 
   1) Implement the CreateDataBase() methods.
 
+  2) Cache date and int literals.
+
  */
 
 #include "nsIAtom.h"
@@ -69,6 +71,8 @@ static NS_DEFINE_CID(kRDFDefaultResourceCID,     NS_RDFDEFAULTRESOURCE_CID);
 
 static NS_DEFINE_IID(kIRDFServiceIID,         NS_IRDFSERVICE_IID);
 static NS_DEFINE_IID(kIRDFLiteralIID,         NS_IRDFLITERAL_IID);
+static NS_DEFINE_IID(kIRDFDateIID,         NS_IRDFDATE_IID);
+static NS_DEFINE_IID(kIRDFIntIID,         NS_IRDFINT_IID);
 static NS_DEFINE_IID(kIRDFResourceIID,        NS_IRDFRESOURCE_IID);
 static NS_DEFINE_IID(kIRDFNodeIID,            NS_IRDFNODE_IID);
 static NS_DEFINE_IID(kISupportsIID,           NS_ISUPPORTS_IID);
@@ -97,8 +101,11 @@ public:
 
     // nsIRDFService
     NS_IMETHOD GetResource(const char* uri, nsIRDFResource** resource);
+    NS_IMETHOD FindResource(const char* uri, nsIRDFResource** resource, PRBool *found);
     NS_IMETHOD GetUnicodeResource(const PRUnichar* uri, nsIRDFResource** resource);
     NS_IMETHOD GetLiteral(const PRUnichar* value, nsIRDFLiteral** literal);
+    NS_IMETHOD GetDateLiteral(const PRTime value, nsIRDFDate** date) ;
+    NS_IMETHOD GetIntLiteral(const int32 value, nsIRDFInt** intLiteral);
     NS_IMETHOD RegisterResource(nsIRDFResource* aResource, PRBool replace = PR_FALSE);
     NS_IMETHOD UnregisterResource(nsIRDFResource* aResource);
     NS_IMETHOD RegisterDataSource(nsIRDFDataSource* dataSource, PRBool replace = PR_FALSE);
@@ -131,7 +138,6 @@ public:
     NS_DECL_ISUPPORTS
 
     // nsIRDFNode
-    NS_IMETHOD Init(const char* uri);
     NS_IMETHOD EqualsNode(nsIRDFNode* node, PRBool* result) const;
 
     // nsIRDFLiteral
@@ -175,15 +181,6 @@ LiteralImpl::QueryInterface(REFNSIID iid, void** result)
     return NS_NOINTERFACE;
 }
 
-NS_IMETHODIMP
-LiteralImpl::Init(const char* uri)
-{
-    // Literals should always be constructed by calling nsIRDFService::GetLiteral,
-    // so this method should never get called.
-    NS_NOTREACHED("RDF LiteralImpl::Init");
-    return NS_ERROR_FAILURE;
-}
-
 NS_IMETHODIMP
 LiteralImpl::EqualsNode(nsIRDFNode* node, PRBool* result) const
 {
@@ -230,6 +227,203 @@ LiteralImpl::EqualsLiteral(const nsIRDFLiteral* literal, PRBool* result) const
     return NS_OK;
 }
 
+
+////////////////////////////////////////////////////////////////////////
+// DateImpl
+//
+
+class DateImpl : public nsIRDFDate {
+public:
+    DateImpl(const PRTime s);
+    virtual ~DateImpl(void);
+
+    // nsISupports
+    NS_DECL_ISUPPORTS
+
+    // nsIRDFNode
+    NS_IMETHOD EqualsNode(nsIRDFNode* node, PRBool* result) const;
+
+    // nsIRDFDate
+    NS_IMETHOD GetValue(PRTime *value) const;
+    NS_IMETHOD EqualsDate(const nsIRDFDate* date, PRBool* result) const;
+
+private:
+    PRTime mValue;
+};
+
+
+DateImpl::DateImpl(const PRTime s)
+    : mValue(s)
+{
+    NS_INIT_REFCNT();
+}
+
+DateImpl::~DateImpl(void)
+{
+}
+
+NS_IMPL_ADDREF(DateImpl);
+NS_IMPL_RELEASE(DateImpl);
+
+nsresult
+DateImpl::QueryInterface(REFNSIID iid, void** result)
+{
+    if (! result)
+        return NS_ERROR_NULL_POINTER;
+
+    *result = nsnull;
+    if (iid.Equals(kIRDFDateIID) ||
+        iid.Equals(kIRDFNodeIID) ||
+        iid.Equals(kISupportsIID)) {
+        *result = NS_STATIC_CAST(nsIRDFDate*, this);
+        AddRef();
+        return NS_OK;
+    }
+    return NS_NOINTERFACE;
+}
+
+NS_IMETHODIMP
+DateImpl::EqualsNode(nsIRDFNode* node, PRBool* result) const
+{
+    nsresult rv;
+    nsIRDFDate* date;
+    if (NS_SUCCEEDED(node->QueryInterface(kIRDFDateIID, (void**) &date))) {
+        rv = EqualsDate(date, result);
+        NS_RELEASE(date);
+    }
+    else {
+        *result = PR_FALSE;
+        rv = NS_OK;
+    }
+    return rv;
+}
+
+NS_IMETHODIMP
+DateImpl::GetValue(PRTime *value) const
+{
+    NS_ASSERTION(value, "null ptr");
+    if (! value)
+        return NS_ERROR_NULL_POINTER;
+
+    *value = mValue;
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+DateImpl::EqualsDate(const nsIRDFDate* date, PRBool* result) const
+{
+    NS_ASSERTION(date && result, "null ptr");
+    if (!date || !result)
+        return NS_ERROR_NULL_POINTER;
+
+    nsresult rv;
+    PRTime p;
+    if (NS_FAILED(rv = date->GetValue(&p)))
+        return rv;
+
+    *result = LL_EQ(p, mValue);
+    return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////
+// IntImpl
+//
+
+class IntImpl : public nsIRDFInt {
+public:
+    IntImpl(const int32 s);
+    virtual ~IntImpl(void);
+
+    // nsISupports
+    NS_DECL_ISUPPORTS
+
+    // nsIRDFNode
+    NS_IMETHOD EqualsNode(nsIRDFNode* node, PRBool* result) const;
+
+    // nsIRDFInt
+    NS_IMETHOD GetValue(int32 *value) const;
+    NS_IMETHOD EqualsInt(const nsIRDFInt* value, PRBool* result) const;
+
+private:
+    int32 mValue;
+};
+
+
+IntImpl::IntImpl(const int32 s)
+    : mValue(s)
+{
+    NS_INIT_REFCNT();
+}
+
+IntImpl::~IntImpl(void)
+{
+}
+
+NS_IMPL_ADDREF(IntImpl);
+NS_IMPL_RELEASE(IntImpl);
+
+nsresult
+IntImpl::QueryInterface(REFNSIID iid, void** result)
+{
+    if (! result)
+        return NS_ERROR_NULL_POINTER;
+
+    *result = nsnull;
+    if (iid.Equals(kIRDFIntIID) ||
+        iid.Equals(kIRDFNodeIID) ||
+        iid.Equals(kISupportsIID)) {
+        *result = NS_STATIC_CAST(nsIRDFInt*, this);
+        AddRef();
+        return NS_OK;
+    }
+    return NS_NOINTERFACE;
+}
+
+NS_IMETHODIMP
+IntImpl::EqualsNode(nsIRDFNode* node, PRBool* result) const
+{
+    nsresult rv;
+    nsIRDFInt* intValue;
+    if (NS_SUCCEEDED(node->QueryInterface(kIRDFIntIID, (void**) &intValue))) {
+        rv = EqualsInt(intValue, result);
+        NS_RELEASE(intValue);
+    }
+    else {
+        *result = PR_FALSE;
+        rv = NS_OK;
+    }
+    return rv;
+}
+
+NS_IMETHODIMP
+IntImpl::GetValue(int32 *value) const
+{
+    NS_ASSERTION(value, "null ptr");
+    if (! value)
+        return NS_ERROR_NULL_POINTER;
+
+    *value = mValue;
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+IntImpl::EqualsInt(const nsIRDFInt* intValue, PRBool* result) const
+{
+    NS_ASSERTION(intValue && result, "null ptr");
+    if (!intValue || !result)
+        return NS_ERROR_NULL_POINTER;
+
+    nsresult rv;
+    int32 p;
+    if (NS_FAILED(rv = intValue->GetValue(&p)))
+        return rv;
+
+    *result = (p == mValue);
+    return NS_OK;
+}
+
 ////////////////////////////////////////////////////////////////////////
 // ServiceImpl
 
@@ -443,6 +637,21 @@ ServiceImpl::GetResource(const char* aURI, nsIRDFResource** aResource)
     return rv;
 }
 
+NS_IMETHODIMP
+ServiceImpl::FindResource(const char* uri, nsIRDFResource** resource, PRBool *found)
+{
+    nsIRDFResource* result =
+        NS_STATIC_CAST(nsIRDFResource*, PL_HashTableLookup(mResources, uri));
+
+    if (result) {
+        *resource = result;
+        *found = 1;
+    } else {
+        *found = 0;
+    }
+    return NS_OK;
+}
+
 NS_IMETHODIMP
 ServiceImpl::GetUnicodeResource(const PRUnichar* aURI, nsIRDFResource** aResource)
 {
@@ -495,6 +704,32 @@ ServiceImpl::GetLiteral(const PRUnichar* aValue, nsIRDFLiteral** aLiteral)
     return NS_OK;
 }
 
+NS_IMETHODIMP
+ServiceImpl::GetDateLiteral(const PRTime time, nsIRDFDate** literal)
+{
+    // XXX how do we cache these? should they live in their own hashtable?
+    DateImpl* result = new DateImpl(time);
+    if (! result)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    *literal = result;
+    NS_ADDREF(result);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+ServiceImpl::GetIntLiteral(const int32 value, nsIRDFInt** literal)
+{
+    // XXX how do we cache these? should they live in their own hashtable?
+    IntImpl* result = new IntImpl(value);
+    if (! result)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    *literal = result;
+    NS_ADDREF(result);
+    return NS_OK;
+}
+
 NS_IMETHODIMP
 ServiceImpl::RegisterResource(nsIRDFResource* aResource, PRBool replace)
 {
diff --git a/mozilla/rdf/base/src/rdfutil.h b/mozilla/rdf/base/src/rdfutil.h
index 84252381716..e7346557196 100644
--- a/mozilla/rdf/base/src/rdfutil.h
+++ b/mozilla/rdf/base/src/rdfutil.h
@@ -36,6 +36,7 @@ class nsIRDFArcsOutCursor;
 class nsIRDFAssertionCursor;
 class nsIRDFCursor;
 class nsIRDFDataSource;
+class nsIRDFResource;
 class nsIRDFNode;
 class nsIRDFResource;
 class nsString;
@@ -235,7 +236,7 @@ NS_NewEmptyRDFArcsInCursor(nsIRDFArcsInCursor** result);
 PR_EXTERN(nsresult)
 NS_NewEmptyRDFArcsOutCursor(nsIRDFArcsOutCursor** result);
 
-
+PR_EXTERN(void) SHTtest ();
 // XXX need to move nsEmptyCursor stuff here.
                        
 #endif // rdfutil_h__
diff --git a/mozilla/rdf/build/Makefile.in b/mozilla/rdf/build/Makefile.in
index 99df5b53ad8..35d55b98928 100644
--- a/mozilla/rdf/build/Makefile.in
+++ b/mozilla/rdf/build/Makefile.in
@@ -73,3 +73,4 @@ install:: $(TARGETS)
 	$(INSTALL) $(srcdir)/../resources/bookmarks.xul $(DIST)/bin/res/rdf
 	$(INSTALL) $(srcdir)/../resources/bookmarks.css $(DIST)/bin/res/rdf
 	$(INSTALL) $(srcdir)/../resources/bookmarks.html $(DIST)/bin/res/rdf
+	$(INSTALL) $(srcdir)/../resources/History/h1.hst $(DIST)/bin/res/rdf/History
diff --git a/mozilla/rdf/build/makefile.win b/mozilla/rdf/build/makefile.win
index 92197e4d870..9d979f74cf1 100644
--- a/mozilla/rdf/build/makefile.win
+++ b/mozilla/rdf/build/makefile.win
@@ -74,6 +74,8 @@ install:: $(DLL)
 	$(MAKE_INSTALL) ..\resources\bookmarks.xul $(DIST)\bin\res\rdf
 	$(MAKE_INSTALL) ..\resources\bookmarks.css $(DIST)\bin\res\rdf
 	$(MAKE_INSTALL) ..\resources\bookmarks.html $(DIST)\bin\res\rdf
+	$(MAKE_INSTALL) ..\resources\History\h1.hst $(DIST)\bin\res\rdf\History
+
 
 
 
diff --git a/mozilla/rdf/build/nsRDFCID.h b/mozilla/rdf/build/nsRDFCID.h
index dca282b540a..14d0b1748cd 100644
--- a/mozilla/rdf/build/nsRDFCID.h
+++ b/mozilla/rdf/build/nsRDFCID.h
@@ -94,4 +94,8 @@
 #define NS_XULDOCUMENT_CID \
 { 0x541afcb2, 0xa9a3, 0x11d2, { 0x8e, 0xc5, 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 } }
+
 #endif // nsRDFCID_h__
diff --git a/mozilla/rdf/build/nsRDFFactory.cpp b/mozilla/rdf/build/nsRDFFactory.cpp
index d6b2d897c51..d54103fb3a5 100644
--- a/mozilla/rdf/build/nsRDFFactory.cpp
+++ b/mozilla/rdf/build/nsRDFFactory.cpp
@@ -43,21 +43,22 @@ static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
 static NS_DEFINE_IID(kIFactoryIID,  NS_IFACTORY_IID);
 
 static NS_DEFINE_CID(kRDFBookmarkDataSourceCID,  NS_RDFBOOKMARKDATASOURCE_CID);
-static NS_DEFINE_CID(kRDFFileSystemDataSourceCID,NS_RDFFILESYSTEMDATASOURCE_CID);
 static NS_DEFINE_CID(kRDFCompositeDataSourceCID, NS_RDFCOMPOSITEDATASOURCE_CID);
 static NS_DEFINE_CID(kRDFContentSinkCID,         NS_RDFCONTENTSINK_CID);
+static NS_DEFINE_CID(kRDFDefaultResourceCID,     NS_RDFDEFAULTRESOURCE_CID);
+static NS_DEFINE_CID(kRDFFileSystemDataSourceCID,NS_RDFFILESYSTEMDATASOURCE_CID);
 static NS_DEFINE_CID(kRDFHTMLBuilderCID,         NS_RDFHTMLBUILDER_CID);
+static NS_DEFINE_CID(kRDFHistoryDataSourceCID,   NS_RDFHISTORYDATASOURCE_CID);
 static NS_DEFINE_CID(kRDFInMemoryDataSourceCID,  NS_RDFINMEMORYDATASOURCE_CID);
-static NS_DEFINE_CID(kRDFServiceCID,             NS_RDFSERVICE_CID);
 static NS_DEFINE_CID(kRDFMenuBuilderCID,         NS_RDFMENUBUILDER_CID);
+static NS_DEFINE_CID(kRDFServiceCID,             NS_RDFSERVICE_CID);
 static NS_DEFINE_CID(kRDFToolbarBuilderCID,      NS_RDFTOOLBARBUILDER_CID);
 static NS_DEFINE_CID(kRDFTreeBuilderCID,         NS_RDFTREEBUILDER_CID);
 static NS_DEFINE_CID(kRDFXMLDataSourceCID,       NS_RDFXMLDATASOURCE_CID);
 static NS_DEFINE_CID(kRDFXULBuilderCID,          NS_RDFXULBUILDER_CID);
 static NS_DEFINE_CID(kXULContentSinkCID,         NS_XULCONTENTSINK_CID);
-static NS_DEFINE_CID(kXULDataSourceCID,		 NS_XULDATASOURCE_CID);
+static NS_DEFINE_CID(kXULDataSourceCID,	         NS_XULDATASOURCE_CID);
 static NS_DEFINE_CID(kXULDocumentCID,            NS_XULDOCUMENT_CID);
-static NS_DEFINE_CID(kRDFDefaultResourceCID,     NS_RDFDEFAULTRESOURCE_CID);
 static NS_DEFINE_CID(kXULSortServiceCID,         NS_XULSORTSERVICE_CID);
 
 class RDFFactoryImpl : public nsIFactory
@@ -140,7 +141,7 @@ RDFFactoryImpl::CreateInstance(nsISupports *aOuter,
     *aResult = nsnull;
 
     nsresult rv;
-    PRBool wasRefCounted = PR_TRUE;
+
     nsISupports *inst = nsnull;
     if (mClassID.Equals(kRDFServiceCID)) {
         if (NS_FAILED(rv = NS_NewRDFService((nsIRDFService**) &inst)))
@@ -171,6 +172,10 @@ RDFFactoryImpl::CreateInstance(nsISupports *aOuter,
         if (NS_FAILED(rv = NS_NewRDFCompositeDataSource((nsIRDFCompositeDataSource**) &inst)))
             return rv;
     }
+    else if (mClassID.Equals(kRDFHistoryDataSourceCID)) {
+        if (NS_FAILED(rv = NS_NewRDFHistoryDataSource((nsIRDFDataSource**) &inst)))
+            return rv;
+    }
     else if (mClassID.Equals(kXULDocumentCID)) {
         if (NS_FAILED(rv = NS_NewXULDocument((nsIRDFDocument**) &inst)))
             return rv;
@@ -218,13 +223,12 @@ RDFFactoryImpl::CreateInstance(nsISupports *aOuter,
     if (! inst)
         return NS_ERROR_OUT_OF_MEMORY;
 
-    if (NS_FAILED(rv = inst->QueryInterface(aIID, aResult)))
-        // We didn't get the right interface, so clean up
-        delete inst;
-
-    if (wasRefCounted)
-        NS_IF_RELEASE(inst);
+    if (NS_FAILED(rv = inst->QueryInterface(aIID, aResult))) {
+        // We didn't get the right interface.
+        NS_ERROR("didn't support the interface you wanted");
+    }
 
+    NS_IF_RELEASE(inst);
     return rv;
 }
 
@@ -276,6 +280,10 @@ NSRegisterSelf(nsISupports* serviceMgr, const char* aPath)
                                          "RDF File System Data Source",
                                          NS_RDF_DATASOURCE_PROGID_PREFIX "files",
                                          aPath, PR_TRUE, PR_TRUE);
+    rv = nsRepository::RegisterComponent(kRDFHistoryDataSourceCID,  
+                                         "RDF History Data Source",
+                                         NS_RDF_DATASOURCE_PROGID_PREFIX "history",
+                                         aPath, PR_TRUE, PR_TRUE);
     rv = nsRepository::RegisterComponent(kRDFCompositeDataSourceCID, 
                                          "RDF Composite Data Source",
                                          NS_RDF_DATASOURCE_PROGID_PREFIX "composite-datasource",
@@ -352,6 +360,7 @@ NSUnregisterSelf(nsISupports* serviceMgr, const char* aPath)
 
     rv = nsRepository::UnregisterComponent(kRDFBookmarkDataSourceCID,  aPath);
     rv = nsRepository::UnregisterComponent(kRDFFileSystemDataSourceCID,aPath);
+    rv = nsRepository::UnregisterComponent(kRDFHistoryDataSourceCID,   aPath);
     rv = nsRepository::UnregisterComponent(kRDFCompositeDataSourceCID, aPath);
     rv = nsRepository::UnregisterComponent(kRDFInMemoryDataSourceCID,  aPath);
     rv = nsRepository::UnregisterComponent(kRDFXMLDataSourceCID,       aPath);
diff --git a/mozilla/rdf/content/src/nsRDFGenericBuilder.cpp b/mozilla/rdf/content/src/nsRDFGenericBuilder.cpp
index 0c73f8e7670..b8f304cc51c 100644
--- a/mozilla/rdf/content/src/nsRDFGenericBuilder.cpp
+++ b/mozilla/rdf/content/src/nsRDFGenericBuilder.cpp
@@ -756,7 +756,9 @@ RDFGenericBuilderImpl::OnSetAttribute(nsIDOMElement* aElement, const nsString& a
         }
 
         if ((rv == NS_CONTENT_ATTR_NO_VALUE) || (rv == NS_CONTENT_ATTR_NOT_THERE) ||
-            ((rv == NS_CONTENT_ATTR_HAS_VALUE) && (! attrValue.EqualsIgnoreCase(aValue)))) {
+            ((rv == NS_CONTENT_ATTR_HAS_VALUE) && (! attrValue.EqualsIgnoreCase(aValue))) ||
+            PR_TRUE // XXX just always allow this to fire.
+            ) {
             // Okay, it's really changing.
 
             // This is a "transient" property, so we _don't_ go to the
diff --git a/mozilla/rdf/content/src/nsRDFTreeBuilder.cpp b/mozilla/rdf/content/src/nsRDFTreeBuilder.cpp
index 5a08ab1c98c..87419ba051a 100644
--- a/mozilla/rdf/content/src/nsRDFTreeBuilder.cpp
+++ b/mozilla/rdf/content/src/nsRDFTreeBuilder.cpp
@@ -360,8 +360,8 @@ RDFTreeBuilderImpl::AddWidgetItem(nsIContent* aElement,
             return rv;
         }
 
-        // Ignore ordinal properties
-        if (rdf_IsOrdinalProperty(property))
+        // Ignore properties that are used to indicate "tree-ness"
+        if (IsWidgetProperty(aElement, property))
             continue;
 
         PRInt32 nameSpaceID;
diff --git a/mozilla/rdf/content/src/nsXULTemplateBuilder.cpp b/mozilla/rdf/content/src/nsXULTemplateBuilder.cpp
index 0c73f8e7670..b8f304cc51c 100644
--- a/mozilla/rdf/content/src/nsXULTemplateBuilder.cpp
+++ b/mozilla/rdf/content/src/nsXULTemplateBuilder.cpp
@@ -756,7 +756,9 @@ RDFGenericBuilderImpl::OnSetAttribute(nsIDOMElement* aElement, const nsString& a
         }
 
         if ((rv == NS_CONTENT_ATTR_NO_VALUE) || (rv == NS_CONTENT_ATTR_NOT_THERE) ||
-            ((rv == NS_CONTENT_ATTR_HAS_VALUE) && (! attrValue.EqualsIgnoreCase(aValue)))) {
+            ((rv == NS_CONTENT_ATTR_HAS_VALUE) && (! attrValue.EqualsIgnoreCase(aValue))) ||
+            PR_TRUE // XXX just always allow this to fire.
+            ) {
             // Okay, it's really changing.
 
             // This is a "transient" property, so we _don't_ go to the
diff --git a/mozilla/rdf/datasource/public/MANIFEST b/mozilla/rdf/datasource/public/MANIFEST
index c1f19f50bf1..336f55ea291 100644
--- a/mozilla/rdf/datasource/public/MANIFEST
+++ b/mozilla/rdf/datasource/public/MANIFEST
@@ -1,2 +1,3 @@
+nsIRDFHistory.h
 nsIRDFFileSystem.h
 nsIXULContentSink.h
diff --git a/mozilla/rdf/datasource/public/Makefile.in b/mozilla/rdf/datasource/public/Makefile.in
index 26e9d429f9e..16b46252b26 100644
--- a/mozilla/rdf/datasource/public/Makefile.in
+++ b/mozilla/rdf/datasource/public/Makefile.in
@@ -25,8 +25,9 @@ include $(DEPTH)/config/autoconf.mk
 MODULE = rdf
 
 EXPORTS =				\
-	nsIXULContentSink.h		\
 	nsIRDFFileSystem.h		\
+	nsIRDFHistory.h			\
+	nsIXULContentSink.h		\
         $(NULL)
 
 EXPORTS := $(addprefix $(srcdir)/, $(EXPORTS))
diff --git a/mozilla/rdf/datasource/public/makefile.win b/mozilla/rdf/datasource/public/makefile.win
index a6a8fa5ee61..885be07a5d7 100644
--- a/mozilla/rdf/datasource/public/makefile.win
+++ b/mozilla/rdf/datasource/public/makefile.win
@@ -21,8 +21,9 @@ MODULE=rdf
 DEPTH=..\..\..
 
 EXPORTS	= \
-        nsIXULContentSink.h \
-	nsIRDFFileSystem.h \
+	nsIRDFFileSystem.h      \
+	nsIRDFHistory.h         \
+        nsIXULContentSink.h     \
 	$(NULL)
 
 include <$(DEPTH)/config/rules.mak>
diff --git a/mozilla/rdf/datasource/public/nsIRDFHistory.h b/mozilla/rdf/datasource/public/nsIRDFHistory.h
index 2b44825bb48..caadf48e64b 100644
--- a/mozilla/rdf/datasource/public/nsIRDFHistory.h
+++ b/mozilla/rdf/datasource/public/nsIRDFHistory.h
@@ -24,20 +24,21 @@
 
 // {115CE051-A59D-11d2-80B6-006097B76B8E}
 #define NS_IRDFWEBPAGE_IID \
-{ 0x115ce051, 0xa59d, 0x11d2, { 0x80, 0xb6, 0x0, 0x60, 0x97, 0xb7, 0x6b, 0x8e } };
+{ 0x115ce051, 0xa59d, 0x11d2, { 0x80, 0xb6, 0x0, 0x60, 0x97, 0xb7, 0x6b, 0x8e } }
 
 // {1A880051-A59D-11d2-80B6-006097B76B8E}
 #define NS_IRDFHISTORYDATASOURCE_IID \
-{ 0x1a880051, 0xa59d, 0x11d2, { 0x80, 0xb6, 0x0, 0x60, 0x97, 0xb7, 0x6b, 0x8e } };
+{ 0x1a880051, 0xa59d, 0x11d2, { 0x80, 0xb6, 0x0, 0x60, 0x97, 0xb7, 0x6b, 0x8e } }
 
 
 class nsIRDFHistoryDataSource : public nsIRDFDataSource {
 public:
+    static const nsIID& GetIID() { static nsIID iid = NS_IRDFHISTORYDATASOURCE_IID; return iid; }
 
     /**
      * Add the specified item to history
      */
-    NS_IMETHOD AddPage (const char* uri) = 0;
+    NS_IMETHOD AddPage (const char* uri, const char* referer, PRTime date) = 0;
 
     /**
      * Set the title of the page
@@ -52,5 +53,19 @@ public:
     /**
      * Get the uri's last visit date
      */
-    NS_IMETHOD LastVisitDate (const char* uri, unit32 *date) = 0;
+    NS_IMETHOD LastVisitDate (const char* uri, uint32 *date) = 0;
+
+    /** 
+     * Get the preferred completion 
+     */
+    NS_IMETHOD CompleteURL (const char* prefix, char** preferredCompletion) = 0;
 };
+
+#endif nsIRDFHistory_h
+
+
+
+
+
+
+
diff --git a/mozilla/rdf/datasource/src/Makefile.in b/mozilla/rdf/datasource/src/Makefile.in
index f6b8ca6e184..3caccee17dd 100644
--- a/mozilla/rdf/datasource/src/Makefile.in
+++ b/mozilla/rdf/datasource/src/Makefile.in
@@ -29,6 +29,7 @@ LIBRARY_NAME = rdfdatasource_s
 CPPSRCS =				\
         nsBookmarkDataSource.cpp	\
         nsFileSystemDataSource.cpp	\
+	nsHistoryDataSource.cpp		\
 	nsXULContentSink.cpp		\
 	nsXULDataSource.cpp		\
 	$(NULL)
diff --git a/mozilla/rdf/datasource/src/makefile.win b/mozilla/rdf/datasource/src/makefile.win
index 95665abd1f7..e9eea90627e 100644
--- a/mozilla/rdf/datasource/src/makefile.win
+++ b/mozilla/rdf/datasource/src/makefile.win
@@ -21,6 +21,7 @@ LIBRARY_NAME=rdfdatasource_s
 
 CPP_OBJS=\
         .\$(OBJDIR)\nsBookmarkDataSource.obj    \
+        .\$(OBJDIR)\nsHistoryDataSource.obj    \
         .\$(OBJDIR)\nsFileSystemDataSource.obj  \
         .\$(OBJDIR)\nsXULContentSink.obj        \
         .\$(OBJDIR)\nsXULDataSource.obj         \
diff --git a/mozilla/rdf/datasource/src/nsFileSystemDataSource.cpp b/mozilla/rdf/datasource/src/nsFileSystemDataSource.cpp
index d4f38ca15d7..586a3a94cdc 100644
--- a/mozilla/rdf/datasource/src/nsFileSystemDataSource.cpp
+++ b/mozilla/rdf/datasource/src/nsFileSystemDataSource.cpp
@@ -82,6 +82,19 @@ DEFINE_RDF_VOCAB(RDF_NAMESPACE_URI, RDF, Seq);
 static	nsIRDFService		*gRDFService = nsnull;
 static	FileSystemDataSource	*gFileSystemDataSource = nsnull;
 
+PRInt32 FileSystemDataSource::gRefCnt;
+
+nsIRDFResource		*FileSystemDataSource::kNC_FileSystemRoot;
+nsIRDFResource		*FileSystemDataSource::kNC_Child;
+nsIRDFResource		*FileSystemDataSource::kNC_Name;
+nsIRDFResource		*FileSystemDataSource::kNC_URL;
+nsIRDFResource		*FileSystemDataSource::kNC_Columns;
+nsIRDFResource		*FileSystemDataSource::kNC_Folder;
+
+nsIRDFResource		*FileSystemDataSource::kRDF_InstanceOf;
+nsIRDFResource		*FileSystemDataSource::kRDF_type;
+nsIRDFResource		*FileSystemDataSource::kRDF_Seq;
+
 
 
 static PRBool
@@ -124,46 +137,62 @@ FileSystemDataSource::FileSystemDataSource(void)
 	: mURI(nsnull),
 	  mObservers(nsnull)
 {
-	NS_INIT_REFCNT();
-	nsresult rv = nsServiceManager::GetService(kRDFServiceCID,
-		kIRDFServiceIID, (nsISupports**) &gRDFService);
-	PR_ASSERT(NS_SUCCEEDED(rv));
-	gFileSystemDataSource = this;
+    NS_INIT_REFCNT();
+
+    if (gRefCnt++ == 0) {
+        nsresult rv = nsServiceManager::GetService(kRDFServiceCID,
+                                                   kIRDFServiceIID,
+                                                   (nsISupports**) &gRDFService);
+
+        PR_ASSERT(NS_SUCCEEDED(rv));
+
+	gRDFService->GetResource(kURINC_FileSystemRoot, &kNC_FileSystemRoot);
+	gRDFService->GetResource(kURINC_child, &kNC_Child);
+	gRDFService->GetResource(kURINC_Name, &kNC_Name);
+	gRDFService->GetResource(kURINC_URL, &kNC_URL);
+	gRDFService->GetResource(kURINC_Folder, &kNC_Folder);
+
+	gRDFService->GetResource(kURIRDF_instanceOf, &kRDF_InstanceOf);
+	gRDFService->GetResource(kURIRDF_type, &kRDF_type);
+	gRDFService->GetResource(kURIRDF_Seq, &kRDF_Seq);
+
+        gFileSystemDataSource = this;
+    }
 }
 
 
 
 FileSystemDataSource::~FileSystemDataSource (void)
 {
-	gRDFService->UnregisterDataSource(this);
+    gRDFService->UnregisterDataSource(this);
 
-	PL_strfree(mURI);
-	if (nsnull != mObservers)
+    PL_strfree(mURI);
+    if (nsnull != mObservers)
 	{
-		for (PRInt32 i = mObservers->Count(); i >= 0; --i)
+            for (PRInt32 i = mObservers->Count(); i >= 0; --i)
 		{
-			nsIRDFObserver* obs = (nsIRDFObserver*) mObservers->ElementAt(i);
-			NS_RELEASE(obs);
+                    nsIRDFObserver* obs = (nsIRDFObserver*) mObservers->ElementAt(i);
+                    NS_RELEASE(obs);
 		}
-		delete mObservers;
-		mObservers = nsnull;
+            delete mObservers;
+            mObservers = nsnull;
 	}
 
-	nsrefcnt	refcnt;
-	NS_RELEASE2(kNC_FileSystemRoot, refcnt);
-	NS_RELEASE2(kNC_Child, refcnt);
-	NS_RELEASE2(kNC_Name, refcnt);
-	NS_RELEASE2(kNC_URL, refcnt);
-//	NS_RELEASE2(kNC_Columns, refcnt);
-	NS_RELEASE2(kNC_Folder, refcnt);
+    if (--gRefCnt == 0) {
+        NS_RELEASE(kNC_FileSystemRoot);
+        NS_RELEASE(kNC_Child);
+        NS_RELEASE(kNC_Name);
+        NS_RELEASE(kNC_URL);
+        NS_RELEASE(kNC_Folder);
 
-	NS_RELEASE2(kRDF_InstanceOf, refcnt);
-	NS_RELEASE2(kRDF_type, refcnt);
-	NS_RELEASE2(kRDF_Seq, refcnt);
+        NS_RELEASE(kRDF_InstanceOf);
+        NS_RELEASE(kRDF_type);
+        NS_RELEASE(kRDF_Seq);
 
-	gFileSystemDataSource = nsnull;
-	nsServiceManager::ReleaseService(kRDFServiceCID, gRDFService);
-	gRDFService = nsnull;
+        gFileSystemDataSource = nsnull;
+        nsServiceManager::ReleaseService(kRDFServiceCID, gRDFService);
+        gRDFService = nsnull;
+    }
 }
 
 
@@ -181,18 +210,6 @@ FileSystemDataSource::Init(const char *uri)
 	if ((mURI = PL_strdup(uri)) == nsnull)
 		return rv;
 
-	gRDFService->GetResource(kURINC_FileSystemRoot, &kNC_FileSystemRoot);
-	gRDFService->GetResource(kURINC_child, &kNC_Child);
-	gRDFService->GetResource(kURINC_Name, &kNC_Name);
-	gRDFService->GetResource(kURINC_URL, &kNC_URL);
-//	gRDFService->GetResource(kURINC_Columns, &kNC_Columns);
-	gRDFService->GetResource(kURINC_Folder, &kNC_Folder);
-
-	gRDFService->GetResource(kURIRDF_instanceOf, &kRDF_InstanceOf);
-	gRDFService->GetResource(kURIRDF_type, &kRDF_type);
-	gRDFService->GetResource(kURIRDF_Seq, &kRDF_Seq);
-
-
 	//   if (NS_FAILED(rv = AddColumns()))
 	//       return rv;
 
@@ -623,7 +640,7 @@ FileSystemCursor::FileSystemCursor(nsIRDFResource *source,
 	  mTarget(nsnull),
 	  mValue(nsnull)
 {
-//	NS_INIT_REFCNT();
+	NS_INIT_REFCNT();
 	NS_ADDREF(mSource);
 	NS_ADDREF(mProperty);
 }
@@ -654,6 +671,7 @@ FileSystemCursor::Advance(void)
 	NS_IF_RELEASE(mValue);
 	mTarget = mValue = (nsIRDFNode *)mArray->ElementAt(mCount++);
 	NS_ADDREF(mValue);
+    NS_ADDREF(mTarget);
 	return NS_OK;
 }
 
diff --git a/mozilla/rdf/datasource/src/nsFileSystemDataSource.h b/mozilla/rdf/datasource/src/nsFileSystemDataSource.h
index 1cf2c87abed..da02319a40c 100644
--- a/mozilla/rdf/datasource/src/nsFileSystemDataSource.h
+++ b/mozilla/rdf/datasource/src/nsFileSystemDataSource.h
@@ -77,16 +77,19 @@ private:
 	char			*mURI;
 	nsVoidArray		*mObservers;
 
-	nsIRDFResource		*kNC_FileSystemRoot;
-	nsIRDFResource		*kNC_Child;
-	nsIRDFResource		*kNC_Name;
-	nsIRDFResource		*kNC_URL;
-	nsIRDFResource		*kNC_Columns;
-	nsIRDFResource		*kNC_Folder;
+    static PRInt32 gRefCnt;
 
-	nsIRDFResource		*kRDF_InstanceOf;
-	nsIRDFResource		*kRDF_type;
-	nsIRDFResource		*kRDF_Seq;
+    // pseudo-constants
+	static nsIRDFResource		*kNC_FileSystemRoot;
+	static nsIRDFResource		*kNC_Child;
+	static nsIRDFResource		*kNC_Name;
+	static nsIRDFResource		*kNC_URL;
+	static nsIRDFResource		*kNC_Columns;
+	static nsIRDFResource		*kNC_Folder;
+
+	static nsIRDFResource		*kRDF_InstanceOf;
+	static nsIRDFResource		*kRDF_type;
+	static nsIRDFResource		*kRDF_Seq;
 
 public:
 
diff --git a/mozilla/rdf/datasource/src/nsHistoryDataSource.cpp b/mozilla/rdf/datasource/src/nsHistoryDataSource.cpp
index 764aa4c84e8..7dc697e854c 100644
--- a/mozilla/rdf/datasource/src/nsHistoryDataSource.cpp
+++ b/mozilla/rdf/datasource/src/nsHistoryDataSource.cpp
@@ -29,15 +29,15 @@
 #include "nsVoidArray.h"  // XXX introduces dependency on raptorbase
 #include "nsRDFCID.h"
 #include "rdfutil.h"
-#include "nsIRDFMail.h"
+#include "nsIRDFHistory.h"
 #include "nsIRDFService.h"
 #include "plhash.h"
 #include "plstr.h"
 #include "prmem.h"
 #include "prprf.h"
 #include "prio.h"
+#include "prtime.h"
 
-#include "nsMailDataSource.h"
 
 ////////////////////////////////////////////////////////////////////////
 // Interface IDs
@@ -48,10 +48,9 @@ static NS_DEFINE_IID(kIRDFAssertionCursorIID,      NS_IRDFASSERTIONCURSOR_IID);
 static NS_DEFINE_IID(kIRDFCursorIID,               NS_IRDFCURSOR_IID);
 static NS_DEFINE_IID(kIRDFDataSourceIID,           NS_IRDFDATASOURCE_IID);
 static NS_DEFINE_IID(kIRDFLiteralIID,              NS_IRDFLITERAL_IID);
-static NS_DEFINE_IID(kIRDFHistoryDataSourceIID,    NS_IRDFHISTORYDATAOURCE_IID);
+static NS_DEFINE_IID(kIRDFHistoryDataSourceIID,    NS_IRDFHISTORYDATASOURCE_IID);
 static NS_DEFINE_IID(kIRDFNodeIID,                 NS_IRDFNODE_IID);
 static NS_DEFINE_IID(kIRDFResourceIID,             NS_IRDFRESOURCE_IID);
-static NS_DEFINE_IID(kIRDFResourceFactoryIID,      NS_IRDFRESOURCEFACTORY_IID);
 static NS_DEFINE_IID(kIRDFServiceIID,              NS_IRDFSERVICE_IID);
 static NS_DEFINE_IID(kISupportsIID,                NS_ISUPPORTS_IID);
 static NS_DEFINE_CID(kRDFServiceCID,               NS_RDFSERVICE_CID);
@@ -61,25 +60,74 @@ static NS_DEFINE_CID(kRDFInMemoryDataSourceCID,    NS_RDFINMEMORYDATASOURCE_CID)
 // RDF property & resource declarations
 
 static const char kURIHistoryRoot[]  = "HistoryRoot";
+static nsIRDFService* gRDFService = nsnull;
+
+
+DEFINE_RDF_VOCAB(RDF_NAMESPACE_URI, RDF, instanceOf);
 
 DEFINE_RDF_VOCAB(NC_NAMESPACE_URI, NC, child);
 DEFINE_RDF_VOCAB(NC_NAMESPACE_URI, NC, Name);
 DEFINE_RDF_VOCAB(NC_NAMESPACE_URI, NC, Folder);
-DEFINE_RDF_VOCAB(NC_NAMESPACE_URI, NC, Column);
-DEFINE_RDF_VOCAB(NC_NAMESPACE_URI, NC, Columns);
 DEFINE_RDF_VOCAB(NC_NAMESPACE_URI, NC, Title);
+DEFINE_RDF_VOCAB(NC_NAMESPACE_URI, NC, Page);
+DEFINE_RDF_VOCAB(NC_NAMESPACE_URI, NC, Date);
+DEFINE_RDF_VOCAB(NC_NAMESPACE_URI, NC, Referer);
 
 DEFINE_RDF_VOCAB(WEB_NAMESPACE_URI, WEB, LastVisitDate);
 DEFINE_RDF_VOCAB(WEB_NAMESPACE_URI, WEB, LastModifiedDate);
 
+typedef struct _HistoryEntry {
+    PRTime date;
+    char* url;
+    char* referer;
+} HistoryEntry;
 
+typedef HistoryEntry* HE;
 
-class nsHistoryDataSource : public nsIHistoryDataSource {
-    nsIRDFDataSource** mInner;
+static PLHashNumber
+rdf_HashPointer(const void* key)
+{
+    return (PLHashNumber) key;
+}
+
+class nsHistoryDataSource : public nsIRDFHistoryDataSource {
+protected:
+    nsIRDFDataSource*  mInner;
     nsVoidArray        mFiles;
-    
+    char*              mCurrentFilePath;
+    FILE*              mCurrentFile;
+    nsVoidArray        mPendingWrites; 
+    PLHashTable*       mLastVisitDateHash; 
+    PRExplodedTime     mSessionTime;
+
+    nsIRDFResource*    mResourcePage;
+    nsIRDFResource*    mResourceDate;    
+    nsIRDFResource*    mResourceTitle;
+    nsIRDFResource*    mResourceReferer;
+    nsIRDFResource*    mResourceChild;
+    nsIRDFResource*    mResourceHistoryBySite;
+
+    nsresult ReadHistory(void);
+    nsresult ReadOneHistoryFile(const char* uri);
+    nsresult AddPageToGraph(char* url, char* title, char* referer,  PRTime date);
+    nsresult AddToDateHierarchy (PRTime date, nsIRDFResource* resource) ;
+    nsresult getSiteOfURL(char* url, nsIRDFResource** resource) ;
+
 public:
+    // nsISupports
+    NS_DECL_ISUPPORTS
+
+    nsHistoryDataSource(void) {
+        NS_INIT_REFCNT();
+    }
+
+    virtual ~nsHistoryDataSource(void) {
+        NS_RELEASE(mInner);
+        nsServiceManager::ReleaseService(kRDFServiceCID, gRDFService);
+    }
+
     NS_IMETHOD Init(const char* uri) ;
+
     NS_IMETHOD GetURI(const char* *uri) {
         return mInner->GetURI(uri);
     }
@@ -159,4 +207,298 @@ public:
         return mInner->DoCommand(aCommand, aCommandTarget);
     }
 
+    NS_IMETHOD GetURI(const char* *uri) const {
+        return mInner->GetURI(uri);
+    }
+
+    NS_IMETHOD GetAllResources(nsIRDFResourceCursor** aCursor) {
+        return mInner->GetAllResources(aCursor);
+    }
+
+    NS_IMETHOD AddPage (const char* uri, const char* referer, PRTime time);
+
+    NS_IMETHOD SetPageTitle (const char* uri, PRUnichar* title) ;
+
+    NS_IMETHOD RemovePage (nsIRDFResource* page) {
+        return NS_OK;
+    }
+
+    NS_IMETHOD LastVisitDate (const char* uri, uint32 *date) {
+        nsIRDFResource* res;
+        PRBool found = 0;
+        *date = 0;
+        gRDFService->FindResource(uri, &res, &found);
+        if (found) *date = (uint32)PL_HashTableLookup(mLastVisitDateHash, res);    
+        return NS_OK;
+    }
+
+    nsresult UpdateLastVisitDate (nsIRDFResource* res, uint32 date) {
+        uint32 edate = (uint32) PL_HashTableLookup(mLastVisitDateHash, res);    
+        if (edate && (edate > date)) return NS_OK;
+        PL_HashTableAdd(mLastVisitDateHash, res, (void*)date);
+        return NS_OK;
+    }
+
+    NS_IMETHOD CompleteURL (const char* prefix, char** preferredCompletion) {
+        return NS_OK;
+    }
+
 };
+
+NS_IMPL_ADDREF(nsHistoryDataSource);
+NS_IMPL_RELEASE(nsHistoryDataSource);
+
+NS_IMETHODIMP
+nsHistoryDataSource::QueryInterface(REFNSIID aIID, void** aResult)
+{
+    NS_PRECONDITION(aResult != nsnull, "null ptr");
+    if (! aResult)
+        return NS_ERROR_NULL_POINTER;
+
+    if (aIID.Equals(nsIRDFHistoryDataSource::GetIID()) ||
+        aIID.Equals(nsIRDFDataSource::GetIID()) ||
+        aIID.Equals(nsISupports::GetIID())) {
+        *aResult = NS_STATIC_CAST(nsIRDFHistoryDataSource*, this);
+        NS_ADDREF(this);
+        return NS_OK;
+    }
+    else {
+        *aResult = nsnull;
+        return NS_NOINTERFACE;
+    }
+}
+
+NS_IMETHODIMP
+nsHistoryDataSource::Init(const char* uri)
+{
+    nsresult rv;
+    if (NS_FAILED(rv = nsRepository::CreateInstance(kRDFInMemoryDataSourceCID,
+                                                    nsnull, kIRDFDataSourceIID,
+                                                    (void**) &mInner)))
+        return rv;
+
+    if (NS_FAILED(rv = mInner->Init(uri)))
+        return rv;
+
+
+    rv = nsServiceManager::GetService(kRDFServiceCID,
+                                               kIRDFServiceIID,
+                                               (nsISupports**) &gRDFService);
+
+    PR_ASSERT(NS_SUCCEEDED(rv));
+
+    // register this as a named data source with the RDF service
+    gRDFService->RegisterDataSource(this);
+    
+    gRDFService->GetResource(kURINC_Page,    &mResourcePage);
+    gRDFService->GetResource(kURINC_Date,    &mResourceDate);
+    gRDFService->GetResource(kURINC_Name,   &mResourceTitle);
+    gRDFService->GetResource(kURINC_Referer, &mResourceReferer);
+    gRDFService->GetResource(kURINC_child,   &mResourceChild);
+    gRDFService->GetResource("NC:HistoryBySite",   &mResourceHistoryBySite);
+
+    mLastVisitDateHash = PL_NewHashTable(400, rdf_HashPointer,
+                                         PL_CompareValues,
+                                         PL_CompareValues,
+                                         nsnull, nsnull);
+ 
+    PR_ExplodeTime(PR_Now(), PR_LocalTimeParameters, &mSessionTime);
+    
+    if (NS_FAILED(rv = ReadHistory()))
+        return rv;
+
+    if (!mCurrentFile) {
+        char fileurl[256];
+        PR_snprintf(fileurl, sizeof(fileurl), "res\\rdf\\History\\%i.hst",  PR_Now());
+    }
+    return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsHistoryDataSource::AddPage (const char* uri, const char* referer, PRTime time) {
+    HE he = (HE) PR_Malloc(sizeof(HistoryEntry));
+    he->date = time;
+    he->url = (char*) uri;
+    he->referer = (char*) referer;
+    mPendingWrites.AppendElement(he);
+    return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsHistoryDataSource::SetPageTitle (const char* uri, PRUnichar* title) {
+    for (PRInt32 i = mPendingWrites.Count() - 1; i >= 0; --i) {
+        HE wr = (HE) mPendingWrites.ElementAt(i);
+        if (strcmp(wr->url, uri) == 0) {
+            char timeBuffer[256];
+            PRExplodedTime etime;
+            PR_ExplodeTime(wr->date, PR_LocalTimeParameters, &etime);
+            PR_FormatTimeUSEnglish(timeBuffer, 256, "%a %b %d %H:%M:%S %Y", &etime);
+            fprintf(mCurrentFile, "%s\t%s\t%s\t%s\n", wr->url, title, wr->referer, timeBuffer);
+            mPendingWrites.RemoveElement(wr);
+            AddPageToGraph(wr->url,  (char*) title, wr->referer,  PR_Now()) ;
+            PR_Free(wr);
+            return NS_OK;
+        }    
+    }
+    return NS_OK;
+}
+
+
+
+PRBool
+endsWith (const char* pattern, const char* uuid)
+{
+  short l1 = strlen(pattern);
+  short l2 = strlen(uuid);
+  short index;
+  if (l2 < l1) return false;  
+  for (index = 1; index <= l1; index++) {
+    if (pattern[l1-index] != uuid[l2-index]) return false;
+  }  
+  return true;
+}
+
+nsresult
+nsHistoryDataSource::ReadHistory(void)
+{
+    nsresult rv = NS_ERROR_FAILURE;
+    char fileurl[256];
+    PRInt32 n = PR_SKIP_BOTH;
+    PRDirEntry	*de;
+    PRDir* dir;
+    PR_snprintf(fileurl, sizeof(fileurl), "res\\rdf\\History");
+    dir =  PR_OpenDir(fileurl);
+    while ((dir != NULL) && ((de = PR_ReadDir(dir, (PRDirFlags)(n++))) != NULL)) {
+        if (endsWith(".hst", de->name)) ReadOneHistoryFile(de->name);
+    }
+    if (dir) PR_CloseDir(dir);
+    return NS_OK;
+}
+
+
+nsresult
+nsHistoryDataSource::ReadOneHistoryFile(const char* fileName)
+{
+    nsresult rv = NS_ERROR_FAILURE;
+    char fileurl[256];
+    FILE* f;
+    PR_snprintf(fileurl, sizeof(fileurl), "res\\rdf\\History\\%s", fileName);
+    if ((f = fopen(fileurl, "rw")) != nsnull) {
+        char* buffer = (char*) PR_Malloc(1024 * 4);
+        int n = 0;
+        char *title, *url, *referer, *date;
+        PRTime time;
+        PRTime fileTime = LL_ZERO;
+        while (fgets(buffer, 1024 * 4, f) != 0) {
+            // url<tab>title<tab>referer<tab>date
+            url = buffer;
+			buffer[strlen(buffer)-1] = '\0';
+            title = strchr(buffer, '\t') + 1;
+            *(title - 1) = '\0';
+            referer = strchr(title, '\t') + 1;
+            *(referer - 1) = '\0';
+            date = strchr(referer, '\t') + 1;         
+			*(date -1 ) = '\0';
+            PR_ParseTimeString (date, 0, &time);
+            if (LL_IS_ZERO(fileTime)) { 
+                PRExplodedTime etime;
+                fileTime = time;
+                PR_ExplodeTime(time, PR_LocalTimeParameters, &etime);
+                if (etime.tm_yday == mSessionTime.tm_yday) mCurrentFile = f;
+            }
+            AddPageToGraph(url, title, referer,  time);
+        }        
+        PR_Free(buffer);  
+		if (f != mCurrentFile) fclose(f);
+    }
+    return rv;
+}
+
+nsresult 
+nsHistoryDataSource::getSiteOfURL(char* url, nsIRDFResource** resource) {
+    char* str = strstr(url, "://");
+    char buff[256];
+	 nsIRDFLiteral  *titleLiteral;
+    PRBool foundp;
+    if (!str) return NS_ERROR_FAILURE;
+    str = str + 3;
+    if (str[0] == '/') str++;
+    char* estr = strchr(str, '/');
+    if (!estr) estr = str + strlen(str);
+    if ((estr - str) > 256) return NS_ERROR_FAILURE;
+	memset(buff, '\0', 256);
+    static const char kHistoryURLPrefix[] = "hst:site?";
+    strcpy(buff, kHistoryURLPrefix);
+    strncat(buff, str, (estr-str));
+    if (NS_OK != gRDFService->FindResource(buff, resource, &foundp)) return NS_ERROR_FAILURE;
+    if (foundp) return NS_OK;
+    if (NS_OK != gRDFService->GetResource(buff, resource)) return NS_ERROR_FAILURE;
+    mInner->Assert(mResourceHistoryBySite,  mResourceChild, *resource, 1);
+    nsAutoString ptitle(buff + sizeof(kHistoryURLPrefix) - 1);	
+    gRDFService->GetLiteral(ptitle, &titleLiteral);
+	mInner->Assert(*resource, mResourceTitle, titleLiteral, 1);
+    return NS_OK;
+}
+
+nsresult 
+nsHistoryDataSource::AddPageToGraph(char* url, char* title, 
+                                    char* referer,  PRTime date) {
+    char* histURL = (char*) PR_Malloc(strlen(url) + 7);    
+    nsIRDFResource *pageResource, *refererResource, *histResource, *siteResource;    
+    nsIRDFLiteral  *titleLiteral;
+    nsIRDFDate     *dateLiteral;
+    PR_snprintf(histURL, strlen(histURL), "hst://%s", url);
+    nsresult rv = getSiteOfURL(url, &siteResource);
+    if (rv != NS_OK) return rv;
+    gRDFService->GetResource(url, &pageResource);
+    gRDFService->GetResource(histURL, &histResource);
+    gRDFService->GetResource(referer, &refererResource);
+    gRDFService->GetDateLiteral(date, &dateLiteral);
+    nsAutoString ptitle(title);
+    gRDFService->GetLiteral(ptitle, &titleLiteral);
+    mInner->Assert(histResource,  mResourcePage, pageResource, 1);
+    mInner->Assert(histResource,  mResourceDate, dateLiteral, 1);
+    mInner->Assert(pageResource,  mResourceTitle, titleLiteral, 1);
+    mInner->Assert(histResource,  mResourceReferer, refererResource, 1);
+    mInner->Assert(siteResource,  mResourceChild, pageResource, 1);
+    AddToDateHierarchy(date, histResource);
+    UpdateLastVisitDate (pageResource, 1/* date */) ;
+    NS_RELEASE(histResource);
+    NS_RELEASE(siteResource);
+    NS_RELEASE(pageResource);
+    NS_RELEASE(refererResource);
+    NS_RELEASE(dateLiteral);
+    NS_RELEASE(titleLiteral);
+    PR_Free(histURL);
+    return NS_OK;
+}
+
+nsresult
+nsHistoryDataSource::AddToDateHierarchy (PRTime date, nsIRDFResource* resource) {
+    return NS_OK;
+}
+
+nsresult
+NS_NewRDFHistoryDataSource(nsIRDFDataSource** result)
+{
+    nsHistoryDataSource* ds = new nsHistoryDataSource();
+
+    if (! ds)
+        return NS_ERROR_NULL_POINTER;
+
+    *result = ds;
+    NS_ADDREF(*result);
+    return NS_OK;
+}
+    
+    
+
+
+
+
+
+
+
+
+
+
diff --git a/mozilla/rdf/datasource/src/nsRDFBuiltInDataSources.h b/mozilla/rdf/datasource/src/nsRDFBuiltInDataSources.h
index f9fd08c8b27..992f9c6da31 100644
--- a/mozilla/rdf/datasource/src/nsRDFBuiltInDataSources.h
+++ b/mozilla/rdf/datasource/src/nsRDFBuiltInDataSources.h
@@ -46,6 +46,9 @@ nsresult NS_NewRDFInMemoryDataSource(nsIRDFDataSource** result);
 // in nsStreamDataSource.cpp
 nsresult NS_NewRDFStreamDataSource(nsIRDFDataSource** result);
 
+// in nsHistoryDataSource.cpp
+nsresult NS_NewRDFHistoryDataSource(nsIRDFDataSource** result);
+
 #endif // nsBuiltinDataSources_h__
 
 
diff --git a/mozilla/rdf/macbuild/rdf.mcp b/mozilla/rdf/macbuild/rdf.mcp
index 9a3be803ac6..6fce35f365e 100644
Binary files a/mozilla/rdf/macbuild/rdf.mcp and b/mozilla/rdf/macbuild/rdf.mcp differ
diff --git a/mozilla/rdf/opendir/query.c b/mozilla/rdf/opendir/query.c
index 68637bd90f8..ef9582954d5 100644
--- a/mozilla/rdf/opendir/query.c
+++ b/mozilla/rdf/opendir/query.c
@@ -73,7 +73,7 @@ parseQuery (char* query, RDF_Resource *root, int *numSegments) {
       freeMem(surl);
       ans[count] = nq;
       if (nquery) {
-		query = nquery+1;
+        query = nquery+1;
       } else break;
     }
     return ans;
@@ -112,7 +112,7 @@ processRDFQuery (char* query) {
       currentValArray = newValArray;
       newValArray = (char**) getMem(4096 * sizeof(RDF_Resource));
     }
-	freeMem(newValArray);
+    freeMem(newValArray);
     if (count > 0) {
       ans = (char**)getMem((count+1) * sizeof(char*));
       memcpy(ans, currentValArray, (count * sizeof(char*)));
diff --git a/mozilla/rdf/resources/History/h1.hst b/mozilla/rdf/resources/History/h1.hst
new file mode 100644
index 00000000000..122330b1f44
--- /dev/null
+++ b/mozilla/rdf/resources/History/h1.hst
@@ -0,0 +1,3 @@
+http://www.netscape.com/	Netscape Home	http://www.mozilla.org	22-AUG-1993 12:59am
+http://www.microsoft.com/	Microsoft Home	http://www.mozilla.org	Friday, August 04, 1995 3:54 PM
+http://www.whatever.com/baz.html	Baz	http://www.netscape.com	20/06/95 21:07
diff --git a/mozilla/rdf/resources/sidebar.xul b/mozilla/rdf/resources/sidebar.xul
index 483eedbf89e..6332a02f2fa 100644
--- a/mozilla/rdf/resources/sidebar.xul
+++ b/mozilla/rdf/resources/sidebar.xul
@@ -57,7 +57,7 @@ function doSort(sortColName)
 
 </html:script>
 
-<xul:tree datasources="rdf:files rdf:bookmarks rdf:mail">
+<xul:tree datasources="rdf:files rdf:bookmarks rdf:mail rdf:history">
   <xul:treecol id="NameColumn" rdf:resource="http://home.netscape.com/NC-rdf#Name"/>
   <xul:treecol id="URLColumn" rdf:resource="http://home.netscape.com/NC-rdf#URL"/>
   <xul:treecol id="LastModColumn" rdf:resource="http://home.netscape.com/WEB-rdf#LastModifiedDate"/>
@@ -98,6 +98,12 @@ function doSort(sortColName)
       <xul:treecell></xul:treecell>
     </xul:treeitem>
 
+    <xul:treeitem id="NC:HistoryBySite">
+      <xul:treecell>History By Site</xul:treecell>
+      <xul:treecell></xul:treecell>
+      <xul:treecell></xul:treecell>
+    </xul:treeitem>
+
   </xul:treebody>
 </xul:tree>
 
diff --git a/mozilla/rdf/util/public/nsRDFResource.h b/mozilla/rdf/util/public/nsRDFResource.h
index f50452ec0c9..bb9702ce7b2 100644
--- a/mozilla/rdf/util/public/nsRDFResource.h
+++ b/mozilla/rdf/util/public/nsRDFResource.h
@@ -33,10 +33,10 @@ public:
     NS_DECL_ISUPPORTS
 
     // nsIRDFNode methods:
-    NS_IMETHOD Init(const char* uri);
     NS_IMETHOD EqualsNode(nsIRDFNode* node, PRBool* result) const;
 
     // nsIRDFResource methods:
+    NS_IMETHOD Init(const char* uri);
     NS_IMETHOD GetValue(const char* *uri) const;
     NS_IMETHOD EqualsResource(const nsIRDFResource* resource, PRBool* result) const;
     NS_IMETHOD EqualsString(const char* uri, PRBool* result) const;