diff options
Diffstat (limited to 'dom/xul/templates/nsXULTemplateBuilder.cpp')
| -rw-r--r-- | dom/xul/templates/nsXULTemplateBuilder.cpp | 2573 |
1 files changed, 2573 insertions, 0 deletions
diff --git a/dom/xul/templates/nsXULTemplateBuilder.cpp b/dom/xul/templates/nsXULTemplateBuilder.cpp new file mode 100644 index 000000000..49fb3335d --- /dev/null +++ b/dom/xul/templates/nsXULTemplateBuilder.cpp @@ -0,0 +1,2573 @@ +/* -*- 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/. */ + +/* + + Builds content from a datasource using the XUL <template> tag. + + TO DO + + . Fix ContentTagTest's location in the network construction + + To turn on logging for this module, set: + + MOZ_LOG=nsXULTemplateBuilder:5 + + */ + +#include "nsAutoPtr.h" +#include "nsCOMPtr.h" +#include "nsCRT.h" +#include "nsIContent.h" +#include "nsIDOMElement.h" +#include "nsIDOMNode.h" +#include "nsIDOMDocument.h" +#include "nsIDOMXULElement.h" +#include "nsIDocument.h" +#include "nsBindingManager.h" +#include "nsIDOMNodeList.h" +#include "nsIObserverService.h" +#include "nsIRDFCompositeDataSource.h" +#include "nsIRDFInferDataSource.h" +#include "nsIRDFContainerUtils.h" +#include "nsIXULDocument.h" +#include "nsIXULTemplateBuilder.h" +#include "nsIXULBuilderListener.h" +#include "nsIRDFRemoteDataSource.h" +#include "nsIRDFService.h" +#include "nsIScriptContext.h" +#include "nsIScriptGlobalObject.h" +#include "nsIServiceManager.h" +#include "nsISimpleEnumerator.h" +#include "nsIMutableArray.h" +#include "nsIURL.h" +#include "nsIXPConnect.h" +#include "nsContentCID.h" +#include "nsNameSpaceManager.h" +#include "nsRDFCID.h" +#include "nsXULContentUtils.h" +#include "nsString.h" +#include "nsTArray.h" +#include "nsXPIDLString.h" +#include "nsWhitespaceTokenizer.h" +#include "nsGkAtoms.h" +#include "nsXULElement.h" +#include "jsapi.h" +#include "mozilla/Logging.h" +#include "rdf.h" +#include "PLDHashTable.h" +#include "plhash.h" +#include "nsDOMClassInfoID.h" +#include "nsPIDOMWindow.h" +#include "nsIConsoleService.h" +#include "nsNetUtil.h" +#include "nsXULTemplateBuilder.h" +#include "nsXULTemplateQueryProcessorRDF.h" +#include "nsXULTemplateQueryProcessorXML.h" +#include "nsXULTemplateQueryProcessorStorage.h" +#include "nsContentUtils.h" +#include "ChildIterator.h" +#include "mozilla/dom/ScriptSettings.h" +#include "nsGlobalWindow.h" + +using namespace mozilla::dom; +using namespace mozilla; + +//---------------------------------------------------------------------- +// +// nsXULTemplateBuilder +// + +nsrefcnt nsXULTemplateBuilder::gRefCnt = 0; +nsIRDFService* nsXULTemplateBuilder::gRDFService; +nsIRDFContainerUtils* nsXULTemplateBuilder::gRDFContainerUtils; +nsIScriptSecurityManager* nsXULTemplateBuilder::gScriptSecurityManager; +nsIPrincipal* nsXULTemplateBuilder::gSystemPrincipal; +nsIObserverService* nsXULTemplateBuilder::gObserverService; + +LazyLogModule gXULTemplateLog("nsXULTemplateBuilder"); + +#define NS_QUERY_PROCESSOR_CONTRACTID_PREFIX "@mozilla.org/xul/xul-query-processor;1?name=" + +//---------------------------------------------------------------------- +// +// nsXULTemplateBuilder methods +// + +nsXULTemplateBuilder::nsXULTemplateBuilder(void) + : mQueriesCompiled(false), + mFlags(0), + mTop(nullptr), + mObservedDocument(nullptr) +{ + MOZ_COUNT_CTOR(nsXULTemplateBuilder); +} + +void +nsXULTemplateBuilder::DestroyMatchMap() +{ + for (auto iter = mMatchMap.Iter(); !iter.Done(); iter.Next()) { + nsTemplateMatch*& match = iter.Data(); + // delete all the matches in the list + while (match) { + nsTemplateMatch* next = match->mNext; + nsTemplateMatch::Destroy(match, true); + match = next; + } + + iter.Remove(); + } +} + +nsXULTemplateBuilder::~nsXULTemplateBuilder(void) +{ + Uninit(true); + + if (--gRefCnt == 0) { + NS_IF_RELEASE(gRDFService); + NS_IF_RELEASE(gRDFContainerUtils); + NS_IF_RELEASE(gSystemPrincipal); + NS_IF_RELEASE(gScriptSecurityManager); + NS_IF_RELEASE(gObserverService); + } + + MOZ_COUNT_DTOR(nsXULTemplateBuilder); +} + + +nsresult +nsXULTemplateBuilder::InitGlobals() +{ + nsresult rv; + + if (gRefCnt++ == 0) { + // Initialize the global shared reference to the service + // manager and get some shared resource objects. + NS_DEFINE_CID(kRDFServiceCID, NS_RDFSERVICE_CID); + rv = CallGetService(kRDFServiceCID, &gRDFService); + if (NS_FAILED(rv)) + return rv; + + NS_DEFINE_CID(kRDFContainerUtilsCID, NS_RDFCONTAINERUTILS_CID); + rv = CallGetService(kRDFContainerUtilsCID, &gRDFContainerUtils); + if (NS_FAILED(rv)) + return rv; + + rv = CallGetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID, + &gScriptSecurityManager); + if (NS_FAILED(rv)) + return rv; + + rv = gScriptSecurityManager->GetSystemPrincipal(&gSystemPrincipal); + if (NS_FAILED(rv)) + return rv; + + rv = CallGetService(NS_OBSERVERSERVICE_CONTRACTID, &gObserverService); + if (NS_FAILED(rv)) + return rv; + } + + return NS_OK; +} + +void +nsXULTemplateBuilder::StartObserving(nsIDocument* aDocument) +{ + aDocument->AddObserver(this); + mObservedDocument = aDocument; + gObserverService->AddObserver(this, DOM_WINDOW_DESTROYED_TOPIC, false); +} + +void +nsXULTemplateBuilder::StopObserving() +{ + MOZ_ASSERT(mObservedDocument); + mObservedDocument->RemoveObserver(this); + mObservedDocument = nullptr; + gObserverService->RemoveObserver(this, DOM_WINDOW_DESTROYED_TOPIC); +} + +void +nsXULTemplateBuilder::CleanUp(bool aIsFinal) +{ + for (int32_t q = mQuerySets.Length() - 1; q >= 0; q--) { + nsTemplateQuerySet* qs = mQuerySets[q]; + delete qs; + } + + mQuerySets.Clear(); + + DestroyMatchMap(); + + // Setting mQueryProcessor to null will close connections. This would be + // handled by the cycle collector, but we want to close them earlier. + if (aIsFinal) + mQueryProcessor = nullptr; +} + +void +nsXULTemplateBuilder::Uninit(bool aIsFinal) +{ + if (mObservedDocument && aIsFinal) { + StopObserving(); + } + + if (mQueryProcessor) + mQueryProcessor->Done(); + + CleanUp(aIsFinal); + + mRootResult = nullptr; + mRefVariable = nullptr; + mMemberVariable = nullptr; + + mQueriesCompiled = false; +} + +NS_IMPL_CYCLE_COLLECTION_CLASS(nsXULTemplateBuilder) + +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsXULTemplateBuilder) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mDataSource) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mDB) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mCompDB) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mRoot) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mRootResult) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mListeners) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mQueryProcessor) + tmp->DestroyMatchMap(); + for (uint32_t i = 0; i < tmp->mQuerySets.Length(); ++i) { + nsTemplateQuerySet* qs = tmp->mQuerySets[i]; + delete qs; + } + tmp->mQuerySets.Clear(); +NS_IMPL_CYCLE_COLLECTION_UNLINK_END +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsXULTemplateBuilder) + if (tmp->mObservedDocument && !cb.WantAllTraces()) { + // The global observer service holds us alive. + return NS_SUCCESS_INTERRUPTED_TRAVERSE; + } + + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDataSource) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDB) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mCompDB) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRoot) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRootResult) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mListeners) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mQueryProcessor) + + for (auto iter = tmp->mMatchMap.Iter(); !iter.Done(); iter.Next()) { + cb.NoteXPCOMChild(iter.Key()); + nsTemplateMatch* match = iter.UserData(); + while (match) { + cb.NoteXPCOMChild(match->GetContainer()); + cb.NoteXPCOMChild(match->mResult); + match = match->mNext; + } + } + + { + uint32_t i, count = tmp->mQuerySets.Length(); + for (i = 0; i < count; ++i) { + nsTemplateQuerySet *set = tmp->mQuerySets[i]; + cb.NoteXPCOMChild(set->mQueryNode); + cb.NoteXPCOMChild(set->mCompiledQuery); + uint16_t j, rulesCount = set->RuleCount(); + for (j = 0; j < rulesCount; ++j) { + set->GetRuleAt(j)->Traverse(cb); + } + } + } + tmp->Traverse(cb); +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_IMPL_CYCLE_COLLECTING_ADDREF(nsXULTemplateBuilder) +NS_IMPL_CYCLE_COLLECTING_RELEASE(nsXULTemplateBuilder) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsXULTemplateBuilder) + NS_INTERFACE_MAP_ENTRY(nsIXULTemplateBuilder) + NS_INTERFACE_MAP_ENTRY(nsIDocumentObserver) + NS_INTERFACE_MAP_ENTRY(nsIMutationObserver) + NS_INTERFACE_MAP_ENTRY(nsIObserver) + NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIXULTemplateBuilder) + NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(XULTemplateBuilder) +NS_INTERFACE_MAP_END + +//---------------------------------------------------------------------- +// +// nsIXULTemplateBuilder methods +// + +NS_IMETHODIMP +nsXULTemplateBuilder::GetRoot(nsIDOMElement** aResult) +{ + if (mRoot) { + return CallQueryInterface(mRoot, aResult); + } + *aResult = nullptr; + return NS_OK; +} + +NS_IMETHODIMP +nsXULTemplateBuilder::GetDatasource(nsISupports** aResult) +{ + if (mCompDB) + NS_ADDREF(*aResult = mCompDB); + else + NS_IF_ADDREF(*aResult = mDataSource); + return NS_OK; +} + +NS_IMETHODIMP +nsXULTemplateBuilder::SetDatasource(nsISupports* aResult) +{ + mDataSource = aResult; + mCompDB = do_QueryInterface(mDataSource); + + return Rebuild(); +} + +NS_IMETHODIMP +nsXULTemplateBuilder::GetDatabase(nsIRDFCompositeDataSource** aResult) +{ + NS_IF_ADDREF(*aResult = mCompDB); + return NS_OK; +} + +NS_IMETHODIMP +nsXULTemplateBuilder::GetQueryProcessor(nsIXULTemplateQueryProcessor** aResult) +{ + NS_IF_ADDREF(*aResult = mQueryProcessor.get()); + return NS_OK; +} + +NS_IMETHODIMP +nsXULTemplateBuilder::AddRuleFilter(nsIDOMNode* aRule, nsIXULTemplateRuleFilter* aFilter) +{ + if (!aRule || !aFilter) + return NS_ERROR_NULL_POINTER; + + // a custom rule filter may be added, one for each rule. If a new one is + // added, it replaces the old one. Look for the right rule and set its + // filter + + int32_t count = mQuerySets.Length(); + for (int32_t q = 0; q < count; q++) { + nsTemplateQuerySet* queryset = mQuerySets[q]; + + int16_t rulecount = queryset->RuleCount(); + for (int16_t r = 0; r < rulecount; r++) { + nsTemplateRule* rule = queryset->GetRuleAt(r); + + nsCOMPtr<nsIDOMNode> rulenode; + rule->GetRuleNode(getter_AddRefs(rulenode)); + if (aRule == rulenode) { + rule->SetRuleFilter(aFilter); + return NS_OK; + } + } + } + + return NS_OK; +} + +NS_IMETHODIMP +nsXULTemplateBuilder::Rebuild() +{ + int32_t i; + + for (i = mListeners.Count() - 1; i >= 0; --i) { + mListeners[i]->WillRebuild(this); + } + + nsresult rv = RebuildAll(); + + for (i = mListeners.Count() - 1; i >= 0; --i) { + mListeners[i]->DidRebuild(this); + } + + return rv; +} + +NS_IMETHODIMP +nsXULTemplateBuilder::Refresh() +{ + nsresult rv; + + if (!mCompDB) + return NS_ERROR_FAILURE; + + nsCOMPtr<nsISimpleEnumerator> dslist; + rv = mCompDB->GetDataSources(getter_AddRefs(dslist)); + NS_ENSURE_SUCCESS(rv, rv); + + bool hasMore; + nsCOMPtr<nsISupports> next; + nsCOMPtr<nsIRDFRemoteDataSource> rds; + + while(NS_SUCCEEDED(dslist->HasMoreElements(&hasMore)) && hasMore) { + dslist->GetNext(getter_AddRefs(next)); + if (next && (rds = do_QueryInterface(next))) { + rds->Refresh(false); + } + } + + // XXXbsmedberg: it would be kinda nice to install an async nsIRDFXMLSink + // observer and call rebuild() once the load is complete. See bug 254600. + + return NS_OK; +} + +NS_IMETHODIMP +nsXULTemplateBuilder::Init(nsIContent* aElement) +{ + NS_ENSURE_TRUE(aElement, NS_ERROR_NULL_POINTER); + mRoot = aElement; + + nsCOMPtr<nsIDocument> doc = mRoot->GetComposedDoc(); + NS_ASSERTION(doc, "element has no document"); + if (! doc) + return NS_ERROR_UNEXPECTED; + + bool shouldDelay; + nsresult rv = LoadDataSources(doc, &shouldDelay); + + if (NS_SUCCEEDED(rv)) { + StartObserving(doc); + } + + return rv; +} + +NS_IMETHODIMP +nsXULTemplateBuilder::CreateContents(nsIContent* aElement, bool aForceCreation) +{ + return NS_OK; +} + +NS_IMETHODIMP +nsXULTemplateBuilder::HasGeneratedContent(nsIRDFResource* aResource, + nsIAtom* aTag, + bool* aGenerated) +{ + *aGenerated = false; + return NS_OK; +} + +NS_IMETHODIMP +nsXULTemplateBuilder::AddResult(nsIXULTemplateResult* aResult, + nsIDOMNode* aQueryNode) +{ + NS_ENSURE_ARG_POINTER(aResult); + NS_ENSURE_ARG_POINTER(aQueryNode); + + return UpdateResult(nullptr, aResult, aQueryNode); +} + +NS_IMETHODIMP +nsXULTemplateBuilder::RemoveResult(nsIXULTemplateResult* aResult) +{ + NS_ENSURE_ARG_POINTER(aResult); + + return UpdateResult(aResult, nullptr, nullptr); +} + +NS_IMETHODIMP +nsXULTemplateBuilder::ReplaceResult(nsIXULTemplateResult* aOldResult, + nsIXULTemplateResult* aNewResult, + nsIDOMNode* aQueryNode) +{ + NS_ENSURE_ARG_POINTER(aOldResult); + NS_ENSURE_ARG_POINTER(aNewResult); + NS_ENSURE_ARG_POINTER(aQueryNode); + + // just remove the old result and then add a new result separately + + nsresult rv = UpdateResult(aOldResult, nullptr, nullptr); + if (NS_FAILED(rv)) + return rv; + + return UpdateResult(nullptr, aNewResult, aQueryNode); +} + +nsresult +nsXULTemplateBuilder::UpdateResult(nsIXULTemplateResult* aOldResult, + nsIXULTemplateResult* aNewResult, + nsIDOMNode* aQueryNode) +{ + MOZ_LOG(gXULTemplateLog, LogLevel::Info, + ("nsXULTemplateBuilder::UpdateResult %p %p %p", + aOldResult, aNewResult, aQueryNode)); + + if (!mRoot || !mQueriesCompiled) + return NS_OK; + + // get the containers where content may be inserted. If + // GetInsertionLocations returns false, no container has generated + // any content yet so new content should not be generated either. This + // will be false if the result applies to content that is in a closed menu + // or treeitem for example. + + nsAutoPtr<nsCOMArray<nsIContent> > insertionPoints; + bool mayReplace = GetInsertionLocations(aOldResult ? aOldResult : aNewResult, + getter_Transfers(insertionPoints)); + if (! mayReplace) + return NS_OK; + + nsresult rv = NS_OK; + + nsCOMPtr<nsIRDFResource> oldId, newId; + nsTemplateQuerySet* queryset = nullptr; + + if (aOldResult) { + rv = GetResultResource(aOldResult, getter_AddRefs(oldId)); + if (NS_FAILED(rv)) + return rv; + + // Ignore re-entrant builds for content that is currently in our + // activation stack. + if (IsActivated(oldId)) + return NS_OK; + } + + if (aNewResult) { + rv = GetResultResource(aNewResult, getter_AddRefs(newId)); + if (NS_FAILED(rv)) + return rv; + + // skip results that don't have ids + if (! newId) + return NS_OK; + + // Ignore re-entrant builds for content that is currently in our + // activation stack. + if (IsActivated(newId)) + return NS_OK; + + // look for the queryset associated with the supplied query node + nsCOMPtr<nsIContent> querycontent = do_QueryInterface(aQueryNode); + + int32_t count = mQuerySets.Length(); + for (int32_t q = 0; q < count; q++) { + nsTemplateQuerySet* qs = mQuerySets[q]; + if (qs->mQueryNode == querycontent) { + queryset = qs; + break; + } + } + + if (! queryset) + return NS_OK; + } + + if (insertionPoints) { + // iterate over each insertion point and add or remove the result from + // that container + uint32_t count = insertionPoints->Count(); + for (uint32_t t = 0; t < count; t++) { + nsCOMPtr<nsIContent> insertionPoint = insertionPoints->SafeObjectAt(t); + if (insertionPoint) { + rv = UpdateResultInContainer(aOldResult, aNewResult, queryset, + oldId, newId, insertionPoint); + if (NS_FAILED(rv)) + return rv; + } + } + } + else { + // The tree builder doesn't use insertion points, so no insertion + // points will be set. In this case, just update the one result. + rv = UpdateResultInContainer(aOldResult, aNewResult, queryset, + oldId, newId, nullptr); + } + + return NS_OK; +} + +nsresult +nsXULTemplateBuilder::UpdateResultInContainer(nsIXULTemplateResult* aOldResult, + nsIXULTemplateResult* aNewResult, + nsTemplateQuerySet* aQuerySet, + nsIRDFResource* aOldId, + nsIRDFResource* aNewId, + nsIContent* aInsertionPoint) +{ + // This method takes a result that no longer applies (aOldResult) and + // replaces it with a new result (aNewResult). Either may be null + // indicating to just remove a result or add a new one without replacing. + // + // Matches are stored in the hashtable mMatchMap, keyed by result id. If + // there is more than one query, or the same id is found in different + // containers, the values in the hashtable will be a linked list of all + // the matches for that id. The matches are sorted according to the + // queries they are associated with. Matches for earlier queries in the + // template take priority over matches from later queries. The priority + // for a match is determined from the match's QuerySetPriority method. + // The first query has a priority 0, and higher numbers are for later + // queries with successively higher priorities. Thus, a match takes + // precedence if it has a lower priority than another. If there is only + // one query or container, then the match doesn't have any linked items. + // + // Matches are nsTemplateMatch objects. They are wrappers around + // nsIXULTemplateResult result objects and are created with + // nsTemplateMatch::Create below. The aQuerySet argument specifies which + // query the match is associated with. + // + // When a result id exists in multiple containers, the match's mContainer + // field is set to the container it corresponds to. The aInsertionPoint + // argument specifies which container is being updated. Even though they + // are stored in the same linked list as other matches of the same id, the + // matches for different containers are treated separately. They are only + // stored in the same hashtable to avoid a more complex data structure, as + // the use of the same id in multiple containers isn't a common occurance. + // + // Only one match with a given id per container is active at a time. When + // a match is active, content is generated for it. When a match is + // inactive, content is not generated for it. A match becomes active if + // another match with the same id and container with a lower priority + // isn't already active, and the match has a rule or conditions clause + // which evaluates to true. The former is checked by comparing the value + // of the QuerySetPriority method of the match with earlier matches. The + // latter is checked with the DetermineMatchedRule method. + // + // Naturally, if a match with a lower priority is active, it overrides + // the new match, so the new match is hooked up into the match linked + // list as inactive, and no content is generated for it. If a match with a + // higher priority is active, and the new match's conditions evaluate + // to true, then this existing match with the higher priority needs to have + // its generated content removed and replaced with the new match's + // generated content. + // + // Similar situations apply when removing an existing match. If the match + // is active, the existing generated content will need to be removed, and + // a match of higher priority that is revealed may become active and need + // to have content generated. + // + // Content removal and generation is done by the ReplaceMatch method which + // is overridden for the content builder and tree builder to update the + // generated output for each type. + // + // The code below handles all of the various cases and ensures that the + // match lists are maintained properly. + + nsresult rv = NS_OK; + int16_t ruleindex; + nsTemplateRule* matchedrule = nullptr; + + // Indicates that the old match was active and must have its content + // removed + bool oldMatchWasActive = false; + + // acceptedmatch will be set to a new match that has to have new content + // generated for it. If a new match doesn't need to have content + // generated, (because for example, a match with a lower priority + // already applies), then acceptedmatch will be null, but the match will + // be still hooked up into the chain, since it may become active later + // as other results are updated. + nsTemplateMatch* acceptedmatch = nullptr; + + // When aOldResult is specified, removematch will be set to the + // corresponding match. This match needs to be deleted as it no longer + // applies. However, removedmatch will be null when aOldResult is null, or + // when no match was found corresponding to aOldResult. + nsTemplateMatch* removedmatch = nullptr; + + // These will be set when aNewResult is specified indicating to add a + // result, but will end up replacing an existing match. The former + // indicates a match being replaced that was active and had content + // generated for it, while the latter indicates a match that wasn't active + // and just needs to be deleted. Both may point to different matches. For + // example, if the new match becomes active, replacing an inactive match, + // the inactive match will need to be deleted. However, if another match + // with a higher priority is active, the new match will override it, so + // content will need to be generated for the new match and removed for + // this existing active match. + nsTemplateMatch* replacedmatch = nullptr; + nsTemplateMatch* replacedmatchtodelete = nullptr; + + if (aOldResult) { + nsTemplateMatch* firstmatch; + if (mMatchMap.Get(aOldId, &firstmatch)) { + nsTemplateMatch* oldmatch = firstmatch; + nsTemplateMatch* prevmatch = nullptr; + + // look for the right match if there was more than one + while (oldmatch && (oldmatch->mResult != aOldResult)) { + prevmatch = oldmatch; + oldmatch = oldmatch->mNext; + } + + if (oldmatch) { + nsTemplateMatch* findmatch = oldmatch->mNext; + + // Keep a reference so that linked list can be hooked up at + // the end in case an error occurs. + nsTemplateMatch* nextmatch = findmatch; + + if (oldmatch->IsActive()) { + // Indicate that the old match was active so its content + // will be removed later. + oldMatchWasActive = true; + + // The match being removed is the active match, so scan + // through the later matches to determine if one should + // now become the active match. + while (findmatch) { + // only other matches with the same container should + // now match, leave other containers alone + if (findmatch->GetContainer() == aInsertionPoint) { + nsTemplateQuerySet* qs = + mQuerySets[findmatch->QuerySetPriority()]; + + DetermineMatchedRule(aInsertionPoint, findmatch->mResult, + qs, &matchedrule, &ruleindex); + + if (matchedrule) { + rv = findmatch->RuleMatched(qs, + matchedrule, ruleindex, + findmatch->mResult); + if (NS_FAILED(rv)) + return rv; + + acceptedmatch = findmatch; + break; + } + } + + findmatch = findmatch->mNext; + } + } + + if (oldmatch == firstmatch) { + // the match to remove is at the beginning + if (oldmatch->mNext) { + mMatchMap.Put(aOldId, oldmatch->mNext); + } + else { + mMatchMap.Remove(aOldId); + } + } + + if (prevmatch) + prevmatch->mNext = nextmatch; + + removedmatch = oldmatch; + if (mFlags & eLoggingEnabled) + OutputMatchToLog(aOldId, removedmatch, false); + } + } + } + + nsTemplateMatch *newmatch = nullptr; + if (aNewResult) { + // only allow a result to be inserted into containers with a matching tag + nsIAtom* tag = aQuerySet->GetTag(); + if (aInsertionPoint && tag && + tag != aInsertionPoint->NodeInfo()->NameAtom()) + return NS_OK; + + int32_t findpriority = aQuerySet->Priority(); + + newmatch = nsTemplateMatch::Create(findpriority, + aNewResult, aInsertionPoint); + if (!newmatch) + return NS_ERROR_OUT_OF_MEMORY; + + nsTemplateMatch* firstmatch; + if (mMatchMap.Get(aNewId, &firstmatch)) { + bool hasEarlierActiveMatch = false; + + // Scan through the existing matches to find where the new one + // should be inserted. oldmatch will be set to the old match for + // the same query and prevmatch will be set to the match before it. + nsTemplateMatch* prevmatch = nullptr; + nsTemplateMatch* oldmatch = firstmatch; + while (oldmatch) { + // Break out once we've reached a query in the list with a + // lower priority. The new match will be inserted at this + // location so that the match list is sorted by priority. + int32_t priority = oldmatch->QuerySetPriority(); + if (priority > findpriority) { + oldmatch = nullptr; + break; + } + + // look for matches that belong in the same container + if (oldmatch->GetContainer() == aInsertionPoint) { + if (priority == findpriority) + break; + + // If a match with a lower priority is active, the new + // match can't replace it. + if (oldmatch->IsActive()) + hasEarlierActiveMatch = true; + } + + prevmatch = oldmatch; + oldmatch = oldmatch->mNext; + } + + // At this point, oldmatch will either be null, or set to a match + // with the same container and priority. If set, oldmatch will + // need to be replaced by newmatch. + + if (oldmatch) + newmatch->mNext = oldmatch->mNext; + else if (prevmatch) + newmatch->mNext = prevmatch->mNext; + else + newmatch->mNext = firstmatch; + + // hasEarlierActiveMatch will be set to true if a match with a + // lower priority was found. The new match won't replace it in + // this case. If hasEarlierActiveMatch is false, then the new match + // may be become active if it matches one of the rules, and will + // generate output. It's also possible however, that a match with + // the same priority already exists, which means that the new match + // will replace the old one. In this case, oldmatch will be set to + // the old match. The content for the old match must be removed and + // content for the new match generated in its place. + if (! hasEarlierActiveMatch) { + // If the old match was the active match, set replacedmatch to + // indicate that it needs its content removed. + if (oldmatch) { + if (oldmatch->IsActive()) + replacedmatch = oldmatch; + replacedmatchtodelete = oldmatch; + } + + // check if the new result matches the rules + rv = DetermineMatchedRule(aInsertionPoint, newmatch->mResult, + aQuerySet, &matchedrule, &ruleindex); + if (NS_FAILED(rv)) { + nsTemplateMatch::Destroy(newmatch, false); + return rv; + } + + if (matchedrule) { + rv = newmatch->RuleMatched(aQuerySet, + matchedrule, ruleindex, + newmatch->mResult); + if (NS_FAILED(rv)) { + nsTemplateMatch::Destroy(newmatch, false); + return rv; + } + + // acceptedmatch may have been set in the block handling + // aOldResult earlier. If so, we would only get here when + // that match has a higher priority than this new match. + // As only one match can have content generated for it, it + // is OK to set acceptedmatch here to the new match, + // ignoring the other one. + acceptedmatch = newmatch; + + // Clear the matched state of the later results for the + // same container. + nsTemplateMatch* clearmatch = newmatch->mNext; + while (clearmatch) { + if (clearmatch->GetContainer() == aInsertionPoint && + clearmatch->IsActive()) { + clearmatch->SetInactive(); + // Replacedmatch should be null here. If not, it + // means that two matches were active which isn't + // a valid state + NS_ASSERTION(!replacedmatch, + "replaced match already set"); + replacedmatch = clearmatch; + break; + } + clearmatch = clearmatch->mNext; + } + } + else if (oldmatch && oldmatch->IsActive()) { + // The result didn't match the rules, so look for a later + // one. However, only do this if the old match was the + // active match. + newmatch = newmatch->mNext; + while (newmatch) { + if (newmatch->GetContainer() == aInsertionPoint) { + rv = DetermineMatchedRule(aInsertionPoint, newmatch->mResult, + aQuerySet, &matchedrule, &ruleindex); + if (NS_FAILED(rv)) { + nsTemplateMatch::Destroy(newmatch, false); + return rv; + } + + if (matchedrule) { + rv = newmatch->RuleMatched(aQuerySet, + matchedrule, ruleindex, + newmatch->mResult); + if (NS_FAILED(rv)) { + nsTemplateMatch::Destroy(newmatch, false); + return rv; + } + + acceptedmatch = newmatch; + break; + } + } + + newmatch = newmatch->mNext; + } + } + + // put the match in the map if there isn't a previous match + if (! prevmatch) { + mMatchMap.Put(aNewId, newmatch); + } + } + + // hook up the match last in case an error occurs + if (prevmatch) + prevmatch->mNext = newmatch; + } + else { + // The id is not used in the hashtable yet so create a new match + // and add it to the hashtable. + rv = DetermineMatchedRule(aInsertionPoint, aNewResult, + aQuerySet, &matchedrule, &ruleindex); + if (NS_FAILED(rv)) { + nsTemplateMatch::Destroy(newmatch, false); + return rv; + } + + if (matchedrule) { + rv = newmatch->RuleMatched(aQuerySet, matchedrule, + ruleindex, aNewResult); + if (NS_FAILED(rv)) { + nsTemplateMatch::Destroy(newmatch, false); + return rv; + } + + acceptedmatch = newmatch; + } + + mMatchMap.Put(aNewId, newmatch); + } + } + + // The ReplaceMatch method is builder specific and removes the generated + // content for a match. + + // Remove the content for a match that was active and needs to be replaced. + if (replacedmatch) { + rv = ReplaceMatch(replacedmatch->mResult, nullptr, nullptr, + aInsertionPoint); + + if (mFlags & eLoggingEnabled) + OutputMatchToLog(aNewId, replacedmatch, false); + } + + // remove a match that needs to be deleted. + if (replacedmatchtodelete) + nsTemplateMatch::Destroy(replacedmatchtodelete, true); + + // If the old match was active, the content for it needs to be removed. + // If the old match was not active, it shouldn't have had any content, + // so just pass null to ReplaceMatch. If acceptedmatch was set, then + // content needs to be generated for a new match. + if (oldMatchWasActive || acceptedmatch) + rv = ReplaceMatch(oldMatchWasActive ? aOldResult : nullptr, + acceptedmatch, matchedrule, aInsertionPoint); + + // delete the old match that was replaced + if (removedmatch) + nsTemplateMatch::Destroy(removedmatch, true); + + if (mFlags & eLoggingEnabled && newmatch) + OutputMatchToLog(aNewId, newmatch, true); + + return rv; +} + +NS_IMETHODIMP +nsXULTemplateBuilder::ResultBindingChanged(nsIXULTemplateResult* aResult) +{ + // A binding update is used when only the values of the bindings have + // changed, so the same rule still applies. Just synchronize the content. + // The new result will have the new values. + NS_ENSURE_ARG_POINTER(aResult); + + if (!mRoot || !mQueriesCompiled) + return NS_OK; + + return SynchronizeResult(aResult); +} + +NS_IMETHODIMP +nsXULTemplateBuilder::GetRootResult(nsIXULTemplateResult** aResult) +{ + *aResult = mRootResult; + NS_IF_ADDREF(*aResult); + return NS_OK; +} + +NS_IMETHODIMP +nsXULTemplateBuilder::GetResultForId(const nsAString& aId, + nsIXULTemplateResult** aResult) +{ + if (aId.IsEmpty()) + return NS_ERROR_INVALID_ARG; + + nsCOMPtr<nsIRDFResource> resource; + gRDFService->GetUnicodeResource(aId, getter_AddRefs(resource)); + + *aResult = nullptr; + + nsTemplateMatch* match; + if (mMatchMap.Get(resource, &match)) { + // find the active match + while (match) { + if (match->IsActive()) { + *aResult = match->mResult; + NS_IF_ADDREF(*aResult); + break; + } + match = match->mNext; + } + } + + return NS_OK; +} + +NS_IMETHODIMP +nsXULTemplateBuilder::GetResultForContent(nsIDOMElement* aContent, + nsIXULTemplateResult** aResult) +{ + *aResult = nullptr; + return NS_OK; +} + +NS_IMETHODIMP +nsXULTemplateBuilder::AddListener(nsIXULBuilderListener* aListener) +{ + NS_ENSURE_ARG(aListener); + + if (!mListeners.AppendObject(aListener)) + return NS_ERROR_OUT_OF_MEMORY; + + return NS_OK; +} + +NS_IMETHODIMP +nsXULTemplateBuilder::RemoveListener(nsIXULBuilderListener* aListener) +{ + NS_ENSURE_ARG(aListener); + + mListeners.RemoveObject(aListener); + + return NS_OK; +} + +NS_IMETHODIMP +nsXULTemplateBuilder::Observe(nsISupports* aSubject, + const char* aTopic, + const char16_t* aData) +{ + // Uuuuber hack to clean up circular references that the cycle collector + // doesn't know about. See bug 394514. + if (!strcmp(aTopic, DOM_WINDOW_DESTROYED_TOPIC)) { + if (nsCOMPtr<mozIDOMWindow> window = do_QueryInterface(aSubject)) { + nsCOMPtr<nsIDocument> doc = + nsPIDOMWindowInner::From(window)->GetExtantDoc(); + if (doc && doc == mObservedDocument) + NodeWillBeDestroyed(doc); + } + } + return NS_OK; +} +//---------------------------------------------------------------------- +// +// nsIDocumentOberver interface +// + +void +nsXULTemplateBuilder::AttributeChanged(nsIDocument* aDocument, + Element* aElement, + int32_t aNameSpaceID, + nsIAtom* aAttribute, + int32_t aModType, + const nsAttrValue* aOldValue) +{ + if (aElement == mRoot && aNameSpaceID == kNameSpaceID_None) { + // Check for a change to the 'ref' attribute on an atom, in which + // case we may need to nuke and rebuild the entire content model + // beneath the element. + if (aAttribute == nsGkAtoms::ref) + nsContentUtils::AddScriptRunner( + NewRunnableMethod(this, &nsXULTemplateBuilder::RunnableRebuild)); + + // Check for a change to the 'datasources' attribute. If so, setup + // mDB by parsing the new value and rebuild. + else if (aAttribute == nsGkAtoms::datasources) { + nsContentUtils::AddScriptRunner( + NewRunnableMethod(this, &nsXULTemplateBuilder::RunnableLoadAndRebuild)); + } + } +} + +void +nsXULTemplateBuilder::ContentRemoved(nsIDocument* aDocument, + nsIContent* aContainer, + nsIContent* aChild, + int32_t aIndexInContainer, + nsIContent* aPreviousSibling) +{ + if (mRoot && nsContentUtils::ContentIsDescendantOf(mRoot, aChild)) { + RefPtr<nsXULTemplateBuilder> kungFuDeathGrip(this); + + if (mQueryProcessor) + mQueryProcessor->Done(); + + // Pass false to Uninit since content is going away anyway + nsContentUtils::AddScriptRunner( + NewRunnableMethod(this, &nsXULTemplateBuilder::UninitFalse)); + + MOZ_ASSERT(aDocument == mObservedDocument); + StopObserving(); + + nsCOMPtr<nsIXULDocument> xuldoc = do_QueryInterface(aDocument); + if (xuldoc) + xuldoc->SetTemplateBuilderFor(mRoot, nullptr); + + // clear the template state when removing content so that template + // content will be regenerated again if the content is reinserted + nsXULElement *xulcontent = nsXULElement::FromContent(mRoot); + if (xulcontent) + xulcontent->ClearTemplateGenerated(); + + CleanUp(true); + + mDB = nullptr; + mCompDB = nullptr; + mDataSource = nullptr; + } +} + +void +nsXULTemplateBuilder::NodeWillBeDestroyed(const nsINode* aNode) +{ + // The call to RemoveObserver could release the last reference to + // |this|, so hold another reference. + RefPtr<nsXULTemplateBuilder> kungFuDeathGrip(this); + + // Break circular references + if (mQueryProcessor) + mQueryProcessor->Done(); + + mDataSource = nullptr; + mDB = nullptr; + mCompDB = nullptr; + + nsContentUtils::AddScriptRunner( + NewRunnableMethod(this, &nsXULTemplateBuilder::UninitTrue)); +} + + + + +//---------------------------------------------------------------------- +// +// Implementation methods +// + +nsresult +nsXULTemplateBuilder::LoadDataSources(nsIDocument* aDocument, + bool* aShouldDelayBuilding) +{ + NS_PRECONDITION(mRoot != nullptr, "not initialized"); + + nsresult rv; + bool isRDFQuery = false; + + // we'll set these again later, after we create a new composite ds + mDB = nullptr; + mCompDB = nullptr; + mDataSource = nullptr; + + *aShouldDelayBuilding = false; + + nsAutoString datasources; + mRoot->GetAttr(kNameSpaceID_None, nsGkAtoms::datasources, datasources); + + nsAutoString querytype; + mRoot->GetAttr(kNameSpaceID_None, nsGkAtoms::querytype, querytype); + + // create the query processor. The querytype attribute on the root element + // may be used to create one of a specific type. + + // XXX should non-chrome be restricted to specific names? + if (querytype.IsEmpty()) + querytype.AssignLiteral("rdf"); + + if (querytype.EqualsLiteral("rdf")) { + isRDFQuery = true; + mQueryProcessor = new nsXULTemplateQueryProcessorRDF(); + } + else if (querytype.EqualsLiteral("xml")) { + mQueryProcessor = new nsXULTemplateQueryProcessorXML(); + } + else if (querytype.EqualsLiteral("storage")) { + mQueryProcessor = new nsXULTemplateQueryProcessorStorage(); + } + else { + nsAutoCString cid(NS_QUERY_PROCESSOR_CONTRACTID_PREFIX); + AppendUTF16toUTF8(querytype, cid); + mQueryProcessor = do_CreateInstance(cid.get(), &rv); + + if (!mQueryProcessor) { + nsXULContentUtils::LogTemplateError(ERROR_TEMPLATE_INVALID_QUERYPROCESSOR); + return rv; + } + } + + rv = LoadDataSourceUrls(aDocument, datasources, + isRDFQuery, aShouldDelayBuilding); + NS_ENSURE_SUCCESS(rv, rv); + + // Now set the database on the element, so that script writers can + // access it. + nsCOMPtr<nsIXULDocument> xuldoc = do_QueryInterface(aDocument); + if (xuldoc) + xuldoc->SetTemplateBuilderFor(mRoot, this); + + if (!mRoot->IsXULElement()) { + // Hmm. This must be an HTML element. Try to set it as a + // JS property "by hand". + InitHTMLTemplateRoot(); + } + + return NS_OK; +} + +nsresult +nsXULTemplateBuilder::LoadDataSourceUrls(nsIDocument* aDocument, + const nsAString& aDataSources, + bool aIsRDFQuery, + bool* aShouldDelayBuilding) +{ + // Grab the doc's principal... + nsIPrincipal *docPrincipal = aDocument->NodePrincipal(); + + NS_ASSERTION(docPrincipal == mRoot->NodePrincipal(), + "Principal mismatch? Which one to use?"); + + bool isTrusted = false; + nsresult rv = IsSystemPrincipal(docPrincipal, &isTrusted); + NS_ENSURE_SUCCESS(rv, rv); + + // Parse datasources: they are assumed to be a whitespace + // separated list of URIs; e.g., + // + // rdf:bookmarks rdf:history http://foo.bar.com/blah.cgi?baz=9 + // + nsIURI *docurl = aDocument->GetDocumentURI(); + + nsCOMPtr<nsIMutableArray> uriList = do_CreateInstance(NS_ARRAY_CONTRACTID); + if (!uriList) + return NS_ERROR_FAILURE; + + nsAutoString datasources(aDataSources); + uint32_t first = 0; + while (1) { + while (first < datasources.Length() && nsCRT::IsAsciiSpace(datasources.CharAt(first))) + ++first; + + if (first >= datasources.Length()) + break; + + uint32_t last = first; + while (last < datasources.Length() && !nsCRT::IsAsciiSpace(datasources.CharAt(last))) + ++last; + + nsAutoString uriStr; + datasources.Mid(uriStr, first, last - first); + first = last + 1; + + // A special 'dummy' datasource + if (uriStr.EqualsLiteral("rdf:null")) + continue; + + if (uriStr.CharAt(0) == '#') { + // ok, the datasource is certainly a node of the current document + nsCOMPtr<nsIDOMDocument> domdoc = do_QueryInterface(aDocument); + nsCOMPtr<nsIDOMElement> dsnode; + + domdoc->GetElementById(Substring(uriStr, 1), + getter_AddRefs(dsnode)); + + if (dsnode) + uriList->AppendElement(dsnode, false); + continue; + } + + // N.B. that `failure' (e.g., because it's an unknown + // protocol) leaves uriStr unaltered. + NS_MakeAbsoluteURI(uriStr, uriStr, docurl); + + nsCOMPtr<nsIURI> uri; + rv = NS_NewURI(getter_AddRefs(uri), uriStr); + if (NS_FAILED(rv) || !uri) + continue; // Necko will barf if our URI is weird + + // don't add the uri to the list if the document is not allowed to + // load it + if (!isTrusted && NS_FAILED(docPrincipal->CheckMayLoad(uri, true, false))) + continue; + + uriList->AppendElement(uri, false); + } + + nsCOMPtr<nsIDOMNode> rootNode = do_QueryInterface(mRoot); + rv = mQueryProcessor->GetDatasource(uriList, + rootNode, + isTrusted, + this, + aShouldDelayBuilding, + getter_AddRefs(mDataSource)); + NS_ENSURE_SUCCESS(rv, rv); + + if (aIsRDFQuery && mDataSource) { + // check if we were given an inference engine type + nsCOMPtr<nsIRDFInferDataSource> inferDB = do_QueryInterface(mDataSource); + if (inferDB) { + nsCOMPtr<nsIRDFDataSource> ds; + inferDB->GetBaseDataSource(getter_AddRefs(ds)); + if (ds) + mCompDB = do_QueryInterface(ds); + } + + if (!mCompDB) + mCompDB = do_QueryInterface(mDataSource); + + mDB = do_QueryInterface(mDataSource); + } + + if (!mDB && isTrusted) { + gRDFService->GetDataSource("rdf:local-store", getter_AddRefs(mDB)); + } + + return NS_OK; +} + +nsresult +nsXULTemplateBuilder::InitHTMLTemplateRoot() +{ + // Use XPConnect and the JS APIs to whack mDB and this as the + // 'database' and 'builder' properties onto aElement. + nsresult rv; + + nsCOMPtr<nsIDocument> doc = mRoot->GetComposedDoc(); + NS_ASSERTION(doc, "no document"); + if (! doc) + return NS_ERROR_UNEXPECTED; + + nsCOMPtr<nsIScriptGlobalObject> global = + do_QueryInterface(doc->GetWindow()); + if (! global) + return NS_ERROR_UNEXPECTED; + + nsCOMPtr<nsIGlobalObject> innerWin = + do_QueryInterface(doc->GetInnerWindow()); + + // We are going to run script via JS_SetProperty, so we need a script entry + // point, but as this is XUL related it does not appear in the HTML spec. + AutoEntryScript aes(innerWin, "nsXULTemplateBuilder creation", true); + JSContext* jscontext = aes.cx(); + + JS::Rooted<JS::Value> v(jscontext); + rv = nsContentUtils::WrapNative(jscontext, mRoot, mRoot, &v); + NS_ENSURE_SUCCESS(rv, rv); + + JS::Rooted<JSObject*> jselement(jscontext, v.toObjectOrNull()); + + if (mDB) { + // database + JS::Rooted<JS::Value> jsdatabase(jscontext); + rv = nsContentUtils::WrapNative(jscontext, mDB, + &NS_GET_IID(nsIRDFCompositeDataSource), + &jsdatabase); + NS_ENSURE_SUCCESS(rv, rv); + + bool ok = JS_SetProperty(jscontext, jselement, "database", jsdatabase); + NS_ASSERTION(ok, "unable to set database property"); + if (! ok) + return NS_ERROR_FAILURE; + } + + { + // builder + JS::Rooted<JS::Value> jsbuilder(jscontext); + rv = nsContentUtils::WrapNative(jscontext, + static_cast<nsIXULTemplateBuilder*>(this), + &NS_GET_IID(nsIXULTemplateBuilder), + &jsbuilder); + NS_ENSURE_SUCCESS(rv, rv); + + bool ok = JS_SetProperty(jscontext, jselement, "builder", jsbuilder); + if (! ok) + return NS_ERROR_FAILURE; + } + + return NS_OK; +} + +nsresult +nsXULTemplateBuilder::DetermineMatchedRule(nsIContent *aContainer, + nsIXULTemplateResult* aResult, + nsTemplateQuerySet* aQuerySet, + nsTemplateRule** aMatchedRule, + int16_t *aRuleIndex) +{ + // iterate through the rules and look for one that the result matches + int16_t count = aQuerySet->RuleCount(); + for (int16_t r = 0; r < count; r++) { + nsTemplateRule* rule = aQuerySet->GetRuleAt(r); + // If a tag was specified, it must match the tag of the container + // where content is being inserted. + nsIAtom* tag = rule->GetTag(); + if ((!aContainer || !tag || + tag == aContainer->NodeInfo()->NameAtom()) && + rule->CheckMatch(aResult)) { + *aMatchedRule = rule; + *aRuleIndex = r; + return NS_OK; + } + } + + *aRuleIndex = -1; + *aMatchedRule = nullptr; + return NS_OK; +} + +void +nsXULTemplateBuilder::ParseAttribute(const nsAString& aAttributeValue, + void (*aVariableCallback)(nsXULTemplateBuilder*, const nsAString&, void*), + void (*aTextCallback)(nsXULTemplateBuilder*, const nsAString&, void*), + void* aClosure) +{ + nsAString::const_iterator done_parsing; + aAttributeValue.EndReading(done_parsing); + + nsAString::const_iterator iter; + aAttributeValue.BeginReading(iter); + + nsAString::const_iterator mark(iter), backup(iter); + + for (; iter != done_parsing; backup = ++iter) { + // A variable is either prefixed with '?' (in the extended + // syntax) or "rdf:" (in the simple syntax). + bool isvar; + if (*iter == char16_t('?') && (++iter != done_parsing)) { + isvar = true; + } + else if ((*iter == char16_t('r') && (++iter != done_parsing)) && + (*iter == char16_t('d') && (++iter != done_parsing)) && + (*iter == char16_t('f') && (++iter != done_parsing)) && + (*iter == char16_t(':') && (++iter != done_parsing))) { + isvar = true; + } + else { + isvar = false; + } + + if (! isvar) { + // It's not a variable, or we ran off the end of the + // string after the initial variable prefix. Since we may + // have slurped down some characters before realizing that + // fact, back up to the point where we started. + iter = backup; + continue; + } + else if (backup != mark && aTextCallback) { + // Okay, we've found a variable, and there's some vanilla + // text that's been buffered up. Flush it. + (*aTextCallback)(this, Substring(mark, backup), aClosure); + } + + if (*iter == char16_t('?')) { + // Well, it was not really a variable, but "??". We use one + // question mark (the second one, actually) literally. + mark = iter; + continue; + } + + // Construct a substring that is the symbol we need to look up + // in the rule's symbol table. The symbol is terminated by a + // space character, a caret, or the end of the string, + // whichever comes first. + nsAString::const_iterator first(backup); + + char16_t c = 0; + while (iter != done_parsing) { + c = *iter; + if ((c == char16_t(' ')) || (c == char16_t('^'))) + break; + + ++iter; + } + + nsAString::const_iterator last(iter); + + // Back up so we don't consume the terminating character + // *unless* the terminating character was a caret: the caret + // means "concatenate with no space in between". + if (c != char16_t('^')) + --iter; + + (*aVariableCallback)(this, Substring(first, last), aClosure); + mark = iter; + ++mark; + } + + if (backup != mark && aTextCallback) { + // If there's any text left over, then fire the text callback + (*aTextCallback)(this, Substring(mark, backup), aClosure); + } +} + + +struct MOZ_STACK_CLASS SubstituteTextClosure { + SubstituteTextClosure(nsIXULTemplateResult* aResult, nsAString& aString) + : result(aResult), str(aString) {} + + // some datasources are lazily initialized or modified while values are + // being retrieved, causing results to be removed. Due to this, hold a + // strong reference to the result. + nsCOMPtr<nsIXULTemplateResult> result; + nsAString& str; +}; + +nsresult +nsXULTemplateBuilder::SubstituteText(nsIXULTemplateResult* aResult, + const nsAString& aAttributeValue, + nsAString& aString) +{ + // See if it's the special value "..." + if (aAttributeValue.EqualsLiteral("...")) { + aResult->GetId(aString); + return NS_OK; + } + + // Reasonable guess at how big it should be + aString.SetCapacity(aAttributeValue.Length()); + + SubstituteTextClosure closure(aResult, aString); + ParseAttribute(aAttributeValue, + SubstituteTextReplaceVariable, + SubstituteTextAppendText, + &closure); + + return NS_OK; +} + + +void +nsXULTemplateBuilder::SubstituteTextAppendText(nsXULTemplateBuilder* aThis, + const nsAString& aText, + void* aClosure) +{ + // Append aString to the closure's result + SubstituteTextClosure* c = static_cast<SubstituteTextClosure*>(aClosure); + c->str.Append(aText); +} + +void +nsXULTemplateBuilder::SubstituteTextReplaceVariable(nsXULTemplateBuilder* aThis, + const nsAString& aVariable, + void* aClosure) +{ + // Substitute the value for the variable and append to the + // closure's result. + SubstituteTextClosure* c = static_cast<SubstituteTextClosure*>(aClosure); + + nsAutoString replacementText; + + // The symbol "rdf:*" is special, and means "this guy's URI" + if (aVariable.EqualsLiteral("rdf:*")){ + c->result->GetId(replacementText); + } + else { + // Got a variable; get the value it's assigned to + nsCOMPtr<nsIAtom> var = NS_Atomize(aVariable); + c->result->GetBindingFor(var, replacementText); + } + + c->str += replacementText; +} + +bool +nsXULTemplateBuilder::IsTemplateElement(nsIContent* aContent) +{ + return aContent->NodeInfo()->Equals(nsGkAtoms::_template, + kNameSpaceID_XUL); +} + +nsresult +nsXULTemplateBuilder::GetTemplateRoot(nsIContent** aResult) +{ + NS_PRECONDITION(mRoot != nullptr, "not initialized"); + if (! mRoot) + return NS_ERROR_NOT_INITIALIZED; + + // First, check and see if the root has a template attribute. This + // allows a template to be specified "out of line"; e.g., + // + // <window> + // <foo template="MyTemplate">...</foo> + // <template id="MyTemplate">...</template> + // </window> + // + nsAutoString templateID; + mRoot->GetAttr(kNameSpaceID_None, nsGkAtoms::_template, templateID); + + if (! templateID.IsEmpty()) { + nsCOMPtr<nsIDOMDocument> domDoc = do_QueryInterface(mRoot->GetComposedDoc()); + if (! domDoc) + return NS_OK; + + nsCOMPtr<nsIDOMElement> domElement; + domDoc->GetElementById(templateID, getter_AddRefs(domElement)); + + if (domElement) { + nsCOMPtr<nsIContent> content = do_QueryInterface(domElement); + NS_ENSURE_STATE(content && + !nsContentUtils::ContentIsDescendantOf(mRoot, + content)); + content.forget(aResult); + return NS_OK; + } + } + + // If root node has no template attribute, then look for a child + // node which is a template tag. + for (nsIContent* child = mRoot->GetFirstChild(); + child; + child = child->GetNextSibling()) { + + if (IsTemplateElement(child)) { + NS_ADDREF(*aResult = child); + return NS_OK; + } + } + + // Look through the anonymous children as well. Although FlattenedChildIterator + // will find a template element that has been placed in an insertion point, many + // bindings do not have a specific insertion point for the template element, which + // would cause it to not be part of the flattened content tree. The check above to + // check the explicit children as well handles this case. + FlattenedChildIterator iter(mRoot); + for (nsIContent* child = iter.GetNextChild(); child; child = iter.GetNextChild()) { + if (IsTemplateElement(child)) { + NS_ADDREF(*aResult = child); + return NS_OK; + } + } + + *aResult = nullptr; + return NS_OK; +} + +nsresult +nsXULTemplateBuilder::CompileQueries() +{ + nsCOMPtr<nsIContent> tmpl; + GetTemplateRoot(getter_AddRefs(tmpl)); + if (! tmpl) + return NS_OK; + + if (! mRoot) + return NS_ERROR_NOT_INITIALIZED; + + // Determine if there are any special settings we need to observe + mFlags = 0; + + nsAutoString flags; + mRoot->GetAttr(kNameSpaceID_None, nsGkAtoms::flags, flags); + + // if the dont-test-empty flag is set, containers should not be checked to + // see if they are empty. If dont-recurse is set, then don't process the + // template recursively and only show one level of results. The logging + // flag logs errors and results to the console, which is useful when + // debugging templates. + nsWhitespaceTokenizer tokenizer(flags); + while (tokenizer.hasMoreTokens()) { + const nsDependentSubstring& token(tokenizer.nextToken()); + if (token.EqualsLiteral("dont-test-empty")) + mFlags |= eDontTestEmpty; + else if (token.EqualsLiteral("dont-recurse")) + mFlags |= eDontRecurse; + else if (token.EqualsLiteral("logging")) + mFlags |= eLoggingEnabled; + } + + // always enable logging if the debug setting is used + if (MOZ_LOG_TEST(gXULTemplateLog, LogLevel::Debug)) + mFlags |= eLoggingEnabled; + + nsCOMPtr<nsIDOMNode> rootnode = do_QueryInterface(mRoot); + nsresult rv = + mQueryProcessor->InitializeForBuilding(mDataSource, this, rootnode); + if (NS_FAILED(rv)) + return rv; + + // Set the "container" and "member" variables, if the user has specified + // them. The container variable may be specified with the container + // attribute on the <template> and the member variable may be specified + // using the member attribute or the value of the uri attribute inside the + // first action body in the template. If not specified, the container + // variable defaults to '?uri' and the member variable defaults to '?' or + // 'rdf:*' for simple queries. + + // For RDF queries, the container variable may also be set via the + // <content> tag. + + nsAutoString containervar; + tmpl->GetAttr(kNameSpaceID_None, nsGkAtoms::container, containervar); + + if (containervar.IsEmpty()) + mRefVariable = NS_Atomize("?uri"); + else + mRefVariable = NS_Atomize(containervar); + + nsAutoString membervar; + tmpl->GetAttr(kNameSpaceID_None, nsGkAtoms::member, membervar); + + if (membervar.IsEmpty()) + mMemberVariable = nullptr; + else + mMemberVariable = NS_Atomize(membervar); + + nsTemplateQuerySet* queryset = new nsTemplateQuerySet(0); + if (!mQuerySets.AppendElement(queryset)) { + delete queryset; + return NS_ERROR_OUT_OF_MEMORY; + } + + bool canUseTemplate = false; + int32_t priority = 0; + rv = CompileTemplate(tmpl, queryset, false, &priority, &canUseTemplate); + + if (NS_FAILED(rv) || !canUseTemplate) { + for (int32_t q = mQuerySets.Length() - 1; q >= 0; q--) { + nsTemplateQuerySet* qs = mQuerySets[q]; + delete qs; + } + mQuerySets.Clear(); + } + + mQueriesCompiled = true; + + return NS_OK; +} + +nsresult +nsXULTemplateBuilder::CompileTemplate(nsIContent* aTemplate, + nsTemplateQuerySet* aQuerySet, + bool aIsQuerySet, + int32_t* aPriority, + bool* aCanUseTemplate) +{ + NS_ASSERTION(aQuerySet, "No queryset supplied"); + + nsresult rv = NS_OK; + + bool isQuerySetMode = false; + bool hasQuerySet = false, hasRule = false, hasQuery = false; + + for (nsIContent* rulenode = aTemplate->GetFirstChild(); + rulenode; + rulenode = rulenode->GetNextSibling()) { + + mozilla::dom::NodeInfo *ni = rulenode->NodeInfo(); + + // don't allow more queries than can be supported + if (*aPriority == INT16_MAX) + return NS_ERROR_FAILURE; + + // XXXndeakin queryset isn't a good name for this tag since it only + // ever contains one query + if (!aIsQuerySet && ni->Equals(nsGkAtoms::queryset, kNameSpaceID_XUL)) { + if (hasRule || hasQuery) { + nsXULContentUtils::LogTemplateError(ERROR_TEMPLATE_INVALID_QUERYSET); + continue; + } + + isQuerySetMode = true; + + // only create a queryset for those after the first since the + // first one is always created by CompileQueries + if (hasQuerySet) { + aQuerySet = new nsTemplateQuerySet(++*aPriority); + + // once the queryset is appended to the mQuerySets list, it + // will be removed by CompileQueries if an error occurs + if (!mQuerySets.AppendElement(aQuerySet)) { + delete aQuerySet; + return NS_ERROR_OUT_OF_MEMORY; + } + } + + hasQuerySet = true; + + rv = CompileTemplate(rulenode, aQuerySet, true, aPriority, aCanUseTemplate); + if (NS_FAILED(rv)) + return rv; + } + + // once a queryset is used, everything must be a queryset + if (isQuerySetMode) + continue; + + if (ni->Equals(nsGkAtoms::rule, kNameSpaceID_XUL)) { + nsCOMPtr<nsIContent> action; + nsXULContentUtils::FindChildByTag(rulenode, + kNameSpaceID_XUL, + nsGkAtoms::action, + getter_AddRefs(action)); + + if (action){ + nsCOMPtr<nsIAtom> memberVariable = mMemberVariable; + if (!memberVariable) { + memberVariable = DetermineMemberVariable(action); + if (!memberVariable) { + nsXULContentUtils::LogTemplateError(ERROR_TEMPLATE_NO_MEMBERVAR); + continue; + } + } + + if (hasQuery) { + nsCOMPtr<nsIAtom> tag; + DetermineRDFQueryRef(aQuerySet->mQueryNode, + getter_AddRefs(tag)); + if (tag) + aQuerySet->SetTag(tag); + + if (! aQuerySet->mCompiledQuery) { + nsCOMPtr<nsIDOMNode> query(do_QueryInterface(aQuerySet->mQueryNode)); + + rv = mQueryProcessor->CompileQuery(this, query, + mRefVariable, memberVariable, + getter_AddRefs(aQuerySet->mCompiledQuery)); + if (NS_FAILED(rv)) + return rv; + } + + if (aQuerySet->mCompiledQuery) { + rv = CompileExtendedQuery(rulenode, action, memberVariable, + aQuerySet); + if (NS_FAILED(rv)) + return rv; + + *aCanUseTemplate = true; + } + } + else { + // backwards-compatible RDF template syntax where there is + // an <action> node but no <query> node. In this case, + // use the conditions as if it was the query. + + nsCOMPtr<nsIContent> conditions; + nsXULContentUtils::FindChildByTag(rulenode, + kNameSpaceID_XUL, + nsGkAtoms::conditions, + getter_AddRefs(conditions)); + + if (conditions) { + // create a new queryset if one hasn't been created already + if (hasQuerySet) { + aQuerySet = new nsTemplateQuerySet(++*aPriority); + if (!mQuerySets.AppendElement(aQuerySet)) { + delete aQuerySet; + return NS_ERROR_OUT_OF_MEMORY; + } + } + + nsCOMPtr<nsIAtom> tag; + DetermineRDFQueryRef(conditions, getter_AddRefs(tag)); + if (tag) + aQuerySet->SetTag(tag); + + hasQuerySet = true; + + nsCOMPtr<nsIDOMNode> conditionsnode(do_QueryInterface(conditions)); + + aQuerySet->mQueryNode = conditions; + rv = mQueryProcessor->CompileQuery(this, conditionsnode, + mRefVariable, + memberVariable, + getter_AddRefs(aQuerySet->mCompiledQuery)); + if (NS_FAILED(rv)) + return rv; + + if (aQuerySet->mCompiledQuery) { + rv = CompileExtendedQuery(rulenode, action, memberVariable, + aQuerySet); + if (NS_FAILED(rv)) + return rv; + + *aCanUseTemplate = true; + } + } + } + } + else { + if (hasQuery) + continue; + + // a new queryset must always be created in this case + if (hasQuerySet) { + aQuerySet = new nsTemplateQuerySet(++*aPriority); + if (!mQuerySets.AppendElement(aQuerySet)) { + delete aQuerySet; + return NS_ERROR_OUT_OF_MEMORY; + } + } + + hasQuerySet = true; + + rv = CompileSimpleQuery(rulenode, aQuerySet, aCanUseTemplate); + if (NS_FAILED(rv)) + return rv; + } + + hasRule = true; + } + else if (ni->Equals(nsGkAtoms::query, kNameSpaceID_XUL)) { + if (hasQuery) + continue; + + aQuerySet->mQueryNode = rulenode; + hasQuery = true; + } + else if (ni->Equals(nsGkAtoms::action, kNameSpaceID_XUL)) { + // the query must appear before the action + if (! hasQuery) + continue; + + nsCOMPtr<nsIAtom> tag; + DetermineRDFQueryRef(aQuerySet->mQueryNode, getter_AddRefs(tag)); + if (tag) + aQuerySet->SetTag(tag); + + nsCOMPtr<nsIAtom> memberVariable = mMemberVariable; + if (!memberVariable) { + memberVariable = DetermineMemberVariable(rulenode); + if (!memberVariable) { + nsXULContentUtils::LogTemplateError(ERROR_TEMPLATE_NO_MEMBERVAR); + continue; + } + } + + nsCOMPtr<nsIDOMNode> query(do_QueryInterface(aQuerySet->mQueryNode)); + + rv = mQueryProcessor->CompileQuery(this, query, + mRefVariable, memberVariable, + getter_AddRefs(aQuerySet->mCompiledQuery)); + + if (aQuerySet->mCompiledQuery) { + nsTemplateRule* rule = aQuerySet->NewRule(aTemplate, rulenode, aQuerySet); + if (! rule) + return NS_ERROR_OUT_OF_MEMORY; + + rule->SetVars(mRefVariable, memberVariable); + + *aCanUseTemplate = true; + + return NS_OK; + } + } + } + + if (! hasRule && ! hasQuery && ! hasQuerySet) { + // if no rules are specified in the template, then the contents of the + // <template> tag are the one-and-only template. + rv = CompileSimpleQuery(aTemplate, aQuerySet, aCanUseTemplate); + } + + return rv; +} + +nsresult +nsXULTemplateBuilder::CompileExtendedQuery(nsIContent* aRuleElement, + nsIContent* aActionElement, + nsIAtom* aMemberVariable, + nsTemplateQuerySet* aQuerySet) +{ + // Compile an "extended" <template> rule. An extended rule may have + // a <conditions> child, an <action> child, and a <bindings> child. + nsresult rv; + + nsTemplateRule* rule = aQuerySet->NewRule(aRuleElement, aActionElement, aQuerySet); + if (! rule) + return NS_ERROR_OUT_OF_MEMORY; + + nsCOMPtr<nsIContent> conditions; + nsXULContentUtils::FindChildByTag(aRuleElement, + kNameSpaceID_XUL, + nsGkAtoms::conditions, + getter_AddRefs(conditions)); + + // allow the conditions to be placed directly inside the rule + if (!conditions) + conditions = aRuleElement; + + rv = CompileConditions(rule, conditions); + // If the rule compilation failed, then we have to bail. + if (NS_FAILED(rv)) { + aQuerySet->RemoveRule(rule); + return rv; + } + + rule->SetVars(mRefVariable, aMemberVariable); + + // If we've got bindings, add 'em. + nsCOMPtr<nsIContent> bindings; + nsXULContentUtils::FindChildByTag(aRuleElement, + kNameSpaceID_XUL, + nsGkAtoms::bindings, + getter_AddRefs(bindings)); + + // allow bindings to be placed directly inside rule + if (!bindings) + bindings = aRuleElement; + + rv = CompileBindings(rule, bindings); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +already_AddRefed<nsIAtom> +nsXULTemplateBuilder::DetermineMemberVariable(nsIContent* aElement) +{ + // recursively iterate over the children looking for an element + // with uri="?..." + for (nsIContent* child = aElement->GetFirstChild(); + child; + child = child->GetNextSibling()) { + nsAutoString uri; + child->GetAttr(kNameSpaceID_None, nsGkAtoms::uri, uri); + if (!uri.IsEmpty() && uri[0] == char16_t('?')) { + return NS_Atomize(uri); + } + + nsCOMPtr<nsIAtom> result = DetermineMemberVariable(child); + if (result) { + return result.forget(); + } + } + + return nullptr; +} + +void +nsXULTemplateBuilder::DetermineRDFQueryRef(nsIContent* aQueryElement, nsIAtom** aTag) +{ + // check for a tag + nsCOMPtr<nsIContent> content; + nsXULContentUtils::FindChildByTag(aQueryElement, + kNameSpaceID_XUL, + nsGkAtoms::content, + getter_AddRefs(content)); + + if (! content) { + // look for older treeitem syntax as well + nsXULContentUtils::FindChildByTag(aQueryElement, + kNameSpaceID_XUL, + nsGkAtoms::treeitem, + getter_AddRefs(content)); + } + + if (content) { + nsAutoString uri; + content->GetAttr(kNameSpaceID_None, nsGkAtoms::uri, uri); + + if (!uri.IsEmpty()) + mRefVariable = NS_Atomize(uri); + + nsAutoString tag; + content->GetAttr(kNameSpaceID_None, nsGkAtoms::tag, tag); + + if (!tag.IsEmpty()) + *aTag = NS_Atomize(tag).take(); + } +} + +nsresult +nsXULTemplateBuilder::CompileSimpleQuery(nsIContent* aRuleElement, + nsTemplateQuerySet* aQuerySet, + bool* aCanUseTemplate) +{ + // compile a simple query, which is a query with no <query> or + // <conditions>. This means that a default query is used. + nsCOMPtr<nsIDOMNode> query(do_QueryInterface(aRuleElement)); + + nsCOMPtr<nsIAtom> memberVariable; + if (mMemberVariable) + memberVariable = mMemberVariable; + else + memberVariable = NS_Atomize("rdf:*"); + + // since there is no <query> node for a simple query, the query node will + // be either the <rule> node if multiple rules are used, or the <template> node. + aQuerySet->mQueryNode = aRuleElement; + nsresult rv = mQueryProcessor->CompileQuery(this, query, + mRefVariable, memberVariable, + getter_AddRefs(aQuerySet->mCompiledQuery)); + if (NS_FAILED(rv)) + return rv; + + if (! aQuerySet->mCompiledQuery) { + *aCanUseTemplate = false; + return NS_OK; + } + + nsTemplateRule* rule = aQuerySet->NewRule(aRuleElement, aRuleElement, aQuerySet); + if (! rule) + return NS_ERROR_OUT_OF_MEMORY; + + rule->SetVars(mRefVariable, memberVariable); + + nsAutoString tag; + aRuleElement->GetAttr(kNameSpaceID_None, nsGkAtoms::parent, tag); + + if (!tag.IsEmpty()) { + nsCOMPtr<nsIAtom> tagatom = NS_Atomize(tag); + aQuerySet->SetTag(tagatom); + } + + *aCanUseTemplate = true; + + return AddSimpleRuleBindings(rule, aRuleElement); +} + +nsresult +nsXULTemplateBuilder::CompileConditions(nsTemplateRule* aRule, + nsIContent* aCondition) +{ + nsAutoString tag; + aCondition->GetAttr(kNameSpaceID_None, nsGkAtoms::parent, tag); + + if (!tag.IsEmpty()) { + nsCOMPtr<nsIAtom> tagatom = NS_Atomize(tag); + aRule->SetTag(tagatom); + } + + nsTemplateCondition* currentCondition = nullptr; + + for (nsIContent* node = aCondition->GetFirstChild(); + node; + node = node->GetNextSibling()) { + + if (node->NodeInfo()->Equals(nsGkAtoms::where, kNameSpaceID_XUL)) { + nsresult rv = CompileWhereCondition(aRule, node, ¤tCondition); + if (NS_FAILED(rv)) + return rv; + } + } + + return NS_OK; +} + +nsresult +nsXULTemplateBuilder::CompileWhereCondition(nsTemplateRule* aRule, + nsIContent* aCondition, + nsTemplateCondition** aCurrentCondition) +{ + // Compile a <where> condition, which must be of the form: + // + // <where subject="?var1|string" rel="relation" value="?var2|string" /> + // + // The value of rel may be: + // equal - subject must be equal to object + // notequal - subject must not be equal to object + // less - subject must be less than object + // greater - subject must be greater than object + // startswith - subject must start with object + // endswith - subject must end with object + // contains - subject must contain object + // Comparisons are done as strings unless the subject is an integer. + + // subject + nsAutoString subject; + aCondition->GetAttr(kNameSpaceID_None, nsGkAtoms::subject, subject); + if (subject.IsEmpty()) { + nsXULContentUtils::LogTemplateError(ERROR_TEMPLATE_WHERE_NO_SUBJECT); + return NS_OK; + } + + nsCOMPtr<nsIAtom> svar; + if (subject[0] == char16_t('?')) + svar = NS_Atomize(subject); + + nsAutoString relstring; + aCondition->GetAttr(kNameSpaceID_None, nsGkAtoms::rel, relstring); + if (relstring.IsEmpty()) { + nsXULContentUtils::LogTemplateError(ERROR_TEMPLATE_WHERE_NO_RELATION); + return NS_OK; + } + + // object + nsAutoString value; + aCondition->GetAttr(kNameSpaceID_None, nsGkAtoms::value, value); + if (value.IsEmpty()) { + nsXULContentUtils::LogTemplateError(ERROR_TEMPLATE_WHERE_NO_VALUE); + return NS_OK; + } + + // multiple + bool shouldMultiple = + aCondition->AttrValueIs(kNameSpaceID_None, nsGkAtoms::multiple, + nsGkAtoms::_true, eCaseMatters); + + nsCOMPtr<nsIAtom> vvar; + if (!shouldMultiple && (value[0] == char16_t('?'))) { + vvar = NS_Atomize(value); + } + + // ignorecase + bool shouldIgnoreCase = + aCondition->AttrValueIs(kNameSpaceID_None, nsGkAtoms::ignorecase, + nsGkAtoms::_true, eCaseMatters); + + // negate + bool shouldNegate = + aCondition->AttrValueIs(kNameSpaceID_None, nsGkAtoms::negate, + nsGkAtoms::_true, eCaseMatters); + + nsTemplateCondition* condition; + + if (svar && vvar) { + condition = new nsTemplateCondition(svar, relstring, vvar, + shouldIgnoreCase, shouldNegate); + } + else if (svar && !value.IsEmpty()) { + condition = new nsTemplateCondition(svar, relstring, value, + shouldIgnoreCase, shouldNegate, shouldMultiple); + } + else if (vvar) { + condition = new nsTemplateCondition(subject, relstring, vvar, + shouldIgnoreCase, shouldNegate); + } + else { + nsXULContentUtils::LogTemplateError(ERROR_TEMPLATE_WHERE_NO_VAR); + return NS_OK; + } + + if (*aCurrentCondition) { + (*aCurrentCondition)->SetNext(condition); + } + else { + aRule->SetCondition(condition); + } + + *aCurrentCondition = condition; + + return NS_OK; +} + +nsresult +nsXULTemplateBuilder::CompileBindings(nsTemplateRule* aRule, nsIContent* aBindings) +{ + // Add an extended rule's bindings. + nsresult rv; + + for (nsIContent* binding = aBindings->GetFirstChild(); + binding; + binding = binding->GetNextSibling()) { + + if (binding->NodeInfo()->Equals(nsGkAtoms::binding, + kNameSpaceID_XUL)) { + rv = CompileBinding(aRule, binding); + if (NS_FAILED(rv)) + return rv; + } + } + + aRule->AddBindingsToQueryProcessor(mQueryProcessor); + + return NS_OK; +} + + +nsresult +nsXULTemplateBuilder::CompileBinding(nsTemplateRule* aRule, + nsIContent* aBinding) +{ + // Compile a <binding> "condition", which must be of the form: + // + // <binding subject="?var1" + // predicate="resource" + // object="?var2" /> + // + // XXXwaterson Some day it would be cool to allow the 'predicate' + // to be bound to a variable. + + // subject + nsAutoString subject; + aBinding->GetAttr(kNameSpaceID_None, nsGkAtoms::subject, subject); + if (subject.IsEmpty()) { + nsXULContentUtils::LogTemplateError(ERROR_TEMPLATE_BINDING_BAD_SUBJECT); + return NS_OK; + } + + nsCOMPtr<nsIAtom> svar; + if (subject[0] == char16_t('?')) { + svar = NS_Atomize(subject); + } + else { + nsXULContentUtils::LogTemplateError(ERROR_TEMPLATE_BINDING_BAD_SUBJECT); + return NS_OK; + } + + // predicate + nsAutoString predicate; + aBinding->GetAttr(kNameSpaceID_None, nsGkAtoms::predicate, predicate); + if (predicate.IsEmpty()) { + nsXULContentUtils::LogTemplateError(ERROR_TEMPLATE_BINDING_BAD_PREDICATE); + return NS_OK; + } + + // object + nsAutoString object; + aBinding->GetAttr(kNameSpaceID_None, nsGkAtoms::object, object); + + if (object.IsEmpty()) { + nsXULContentUtils::LogTemplateError(ERROR_TEMPLATE_BINDING_BAD_OBJECT); + return NS_OK; + } + + nsCOMPtr<nsIAtom> ovar; + if (object[0] == char16_t('?')) { + ovar = NS_Atomize(object); + } + else { + nsXULContentUtils::LogTemplateError(ERROR_TEMPLATE_BINDING_BAD_OBJECT); + return NS_OK; + } + + return aRule->AddBinding(svar, predicate, ovar); +} + +nsresult +nsXULTemplateBuilder::AddSimpleRuleBindings(nsTemplateRule* aRule, + nsIContent* aElement) +{ + // Crawl the content tree of a "simple" rule, adding a variable + // assignment for any attribute whose value is "rdf:". + + AutoTArray<nsIContent*, 8> elements; + + if (elements.AppendElement(aElement) == nullptr) + return NS_ERROR_OUT_OF_MEMORY; + + while (elements.Length()) { + // Pop the next element off the stack + uint32_t i = elements.Length() - 1; + nsIContent* element = elements[i]; + elements.RemoveElementAt(i); + + // Iterate through its attributes, looking for substitutions + // that we need to add as bindings. + uint32_t count = element->GetAttrCount(); + + for (i = 0; i < count; ++i) { + const nsAttrName* name = element->GetAttrNameAt(i); + + if (!name->Equals(nsGkAtoms::id, kNameSpaceID_None) && + !name->Equals(nsGkAtoms::uri, kNameSpaceID_None)) { + nsAutoString value; + element->GetAttr(name->NamespaceID(), name->LocalName(), value); + + // Scan the attribute for variables, adding a binding for + // each one. + ParseAttribute(value, AddBindingsFor, nullptr, aRule); + } + } + + // Push kids onto the stack, and search them next. + for (nsIContent* child = element->GetLastChild(); + child; + child = child->GetPreviousSibling()) { + + if (!elements.AppendElement(child)) + return NS_ERROR_OUT_OF_MEMORY; + } + } + + aRule->AddBindingsToQueryProcessor(mQueryProcessor); + + return NS_OK; +} + +void +nsXULTemplateBuilder::AddBindingsFor(nsXULTemplateBuilder* aThis, + const nsAString& aVariable, + void* aClosure) +{ + // We should *only* be recieving "rdf:"-style variables. Make + // sure... + if (!StringBeginsWith(aVariable, NS_LITERAL_STRING("rdf:"))) + return; + + nsTemplateRule* rule = static_cast<nsTemplateRule*>(aClosure); + + nsCOMPtr<nsIAtom> var = NS_Atomize(aVariable); + + // Strip it down to the raw RDF property by clobbering the "rdf:" + // prefix + nsAutoString property; + property.Assign(Substring(aVariable, uint32_t(4), aVariable.Length() - 4)); + + if (! rule->HasBinding(rule->GetMemberVariable(), property, var)) + // In the simple syntax, the binding is always from the + // member variable, through the property, to the target. + rule->AddBinding(rule->GetMemberVariable(), property, var); +} + + +nsresult +nsXULTemplateBuilder::IsSystemPrincipal(nsIPrincipal *principal, bool *result) +{ + if (!gSystemPrincipal) + return NS_ERROR_UNEXPECTED; + + *result = (principal == gSystemPrincipal); + return NS_OK; +} + +bool +nsXULTemplateBuilder::IsActivated(nsIRDFResource *aResource) +{ + for (ActivationEntry *entry = mTop; + entry != nullptr; + entry = entry->mPrevious) { + if (entry->mResource == aResource) + return true; + } + return false; +} + +nsresult +nsXULTemplateBuilder::GetResultResource(nsIXULTemplateResult* aResult, + nsIRDFResource** aResource) +{ + // get the resource for a result by checking its resource property. If it + // is not set, check the id. This allows non-chrome implementations to + // avoid having to use RDF. + nsresult rv = aResult->GetResource(aResource); + if (NS_FAILED(rv)) + return rv; + + if (! *aResource) { + nsAutoString id; + rv = aResult->GetId(id); + if (NS_FAILED(rv)) + return rv; + + return gRDFService->GetUnicodeResource(id, aResource); + } + + return rv; +} + + +void +nsXULTemplateBuilder::OutputMatchToLog(nsIRDFResource* aId, + nsTemplateMatch* aMatch, + bool aIsNew) +{ + int32_t priority = aMatch->QuerySetPriority() + 1; + int32_t activePriority = -1; + + nsAutoString msg; + + nsAutoString templateid; + mRoot->GetAttr(kNameSpaceID_None, nsGkAtoms::id, templateid); + msg.AppendLiteral("In template"); + if (!templateid.IsEmpty()) { + msg.AppendLiteral(" with id "); + msg.Append(templateid); + } + + nsAutoString refstring; + aMatch->mResult->GetBindingFor(mRefVariable, refstring); + if (!refstring.IsEmpty()) { + msg.AppendLiteral(" using ref "); + msg.Append(refstring); + } + + msg.AppendLiteral("\n "); + + nsTemplateMatch* match = nullptr; + if (mMatchMap.Get(aId, &match)){ + while (match) { + if (match == aMatch) + break; + if (match->IsActive() && + match->GetContainer() == aMatch->GetContainer()) { + activePriority = match->QuerySetPriority() + 1; + break; + } + match = match->mNext; + } + } + + if (aMatch->IsActive()) { + if (aIsNew) { + msg.AppendLiteral("New active result for query "); + msg.AppendInt(priority); + msg.AppendLiteral(" matching rule "); + msg.AppendInt(aMatch->RuleIndex() + 1); + } + else { + msg.AppendLiteral("Removed active result for query "); + msg.AppendInt(priority); + if (activePriority > 0) { + msg.AppendLiteral(" (new active query is "); + msg.AppendInt(activePriority); + msg.Append(')'); + } + else { + msg.AppendLiteral(" (no new active query)"); + } + } + } + else { + if (aIsNew) { + msg.AppendLiteral("New inactive result for query "); + msg.AppendInt(priority); + if (activePriority > 0) { + msg.AppendLiteral(" (overridden by query "); + msg.AppendInt(activePriority); + msg.Append(')'); + } + else { + msg.AppendLiteral(" (didn't match a rule)"); + } + } + else { + msg.AppendLiteral("Removed inactive result for query "); + msg.AppendInt(priority); + if (activePriority > 0) { + msg.AppendLiteral(" (active query is "); + msg.AppendInt(activePriority); + msg.Append(')'); + } + else { + msg.AppendLiteral(" (no active query)"); + } + } + } + + nsAutoString idstring; + nsXULContentUtils::GetTextForNode(aId, idstring); + msg.AppendLiteral(": "); + msg.Append(idstring); + + nsCOMPtr<nsIConsoleService> cs = do_GetService(NS_CONSOLESERVICE_CONTRACTID); + if (cs) + cs->LogStringMessage(msg.get()); +} |