/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* vim: set ts=8 sts=2 et sw=2 tw=80: */ /* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ #include <stdio.h> #include "nsNavHistory.h" #include "nsNavBookmarks.h" #include "nsFaviconService.h" #include "nsITaggingService.h" #include "nsAnnotationService.h" #include "Helpers.h" #include "mozilla/DebugOnly.h" #include "nsDebug.h" #include "nsNetUtil.h" #include "nsString.h" #include "nsReadableUtils.h" #include "nsUnicharUtils.h" #include "prtime.h" #include "prprf.h" #include "nsQueryObject.h" #include "nsCycleCollectionParticipant.h" // Thanks, Windows.h :( #undef CompareString #define TO_ICONTAINER(_node) \ static_cast<nsINavHistoryContainerResultNode*>(_node) #define TO_CONTAINER(_node) \ static_cast<nsNavHistoryContainerResultNode*>(_node) #define NOTIFY_RESULT_OBSERVERS_RET(_result, _method, _ret) \ PR_BEGIN_MACRO \ NS_ENSURE_TRUE(_result, _ret); \ if (!_result->mSuppressNotifications) { \ ENUMERATE_WEAKARRAY(_result->mObservers, nsINavHistoryResultObserver, \ _method) \ } \ PR_END_MACRO #define NOTIFY_RESULT_OBSERVERS(_result, _method) \ NOTIFY_RESULT_OBSERVERS_RET(_result, _method, NS_ERROR_UNEXPECTED) // What we want is: NS_INTERFACE_MAP_ENTRY(self) for static IID accessors, // but some of our classes (like nsNavHistoryResult) have an ambiguous base // class of nsISupports which prevents this from working (the default macro // converts it to nsISupports, then addrefs it, then returns it). Therefore, we // expand the macro here and change it so that it works. Yuck. #define NS_INTERFACE_MAP_STATIC_AMBIGUOUS(_class) \ if (aIID.Equals(NS_GET_IID(_class))) { \ NS_ADDREF(this); \ *aInstancePtr = this; \ return NS_OK; \ } else // Number of changes to handle separately in a batch. If more changes are // requested the node will switch to full refresh mode. #define MAX_BATCH_CHANGES_BEFORE_REFRESH 5 // Emulate string comparison (used for sorting) for PRTime and int. inline int32_t ComparePRTime(PRTime a, PRTime b) { if (a < b) return -1; else if (a > b) return 1; return 0; } inline int32_t CompareIntegers(uint32_t a, uint32_t b) { return a - b; } using namespace mozilla; using namespace mozilla::places; NS_IMPL_CYCLE_COLLECTION(nsNavHistoryResultNode, mParent) NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsNavHistoryResultNode) NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsINavHistoryResultNode) NS_INTERFACE_MAP_ENTRY(nsINavHistoryResultNode) NS_INTERFACE_MAP_END NS_IMPL_CYCLE_COLLECTING_ADDREF(nsNavHistoryResultNode) NS_IMPL_CYCLE_COLLECTING_RELEASE(nsNavHistoryResultNode) nsNavHistoryResultNode::nsNavHistoryResultNode( const nsACString& aURI, const nsACString& aTitle, uint32_t aAccessCount, PRTime aTime, const nsACString& aIconURI) : mParent(nullptr), mURI(aURI), mTitle(aTitle), mAreTagsSorted(false), mAccessCount(aAccessCount), mTime(aTime), mFaviconURI(aIconURI), mBookmarkIndex(-1), mItemId(-1), mFolderId(-1), mVisitId(-1), mFromVisitId(-1), mDateAdded(0), mLastModified(0), mIndentLevel(-1), mFrecency(0), mHidden(false), mTransitionType(0) { mTags.SetIsVoid(true); } NS_IMETHODIMP nsNavHistoryResultNode::GetIcon(nsACString& aIcon) { if (mFaviconURI.IsEmpty()) { aIcon.Truncate(); return NS_OK; } nsFaviconService* faviconService = nsFaviconService::GetFaviconService(); NS_ENSURE_TRUE(faviconService, NS_ERROR_OUT_OF_MEMORY); faviconService->GetFaviconSpecForIconString(mFaviconURI, aIcon); return NS_OK; } NS_IMETHODIMP nsNavHistoryResultNode::GetParent(nsINavHistoryContainerResultNode** aParent) { NS_IF_ADDREF(*aParent = mParent); return NS_OK; } NS_IMETHODIMP nsNavHistoryResultNode::GetParentResult(nsINavHistoryResult** aResult) { *aResult = nullptr; if (IsContainer()) NS_IF_ADDREF(*aResult = GetAsContainer()->mResult); else if (mParent) NS_IF_ADDREF(*aResult = mParent->mResult); NS_ENSURE_STATE(*aResult); return NS_OK; } NS_IMETHODIMP nsNavHistoryResultNode::GetTags(nsAString& aTags) { // Only URI-nodes may be associated with tags if (!IsURI()) { aTags.Truncate(); return NS_OK; } // Initially, the tags string is set to a void string (see constructor). We // then build it the first time this method called is called (and by that, // implicitly unset the void flag). Result observers may re-set the void flag // in order to force rebuilding of the tags string. if (!mTags.IsVoid()) { // If mTags is assigned by a history query it is unsorted for performance // reasons, it must be sorted by name on first read access. if (!mAreTagsSorted) { nsTArray<nsCString> tags; ParseString(NS_ConvertUTF16toUTF8(mTags), ',', tags); tags.Sort(); mTags.SetIsVoid(true); for (nsTArray<nsCString>::index_type i = 0; i < tags.Length(); ++i) { AppendUTF8toUTF16(tags[i], mTags); if (i < tags.Length() - 1 ) mTags.AppendLiteral(", "); } mAreTagsSorted = true; } aTags.Assign(mTags); return NS_OK; } // Fetch the tags RefPtr<Database> DB = Database::GetDatabase(); NS_ENSURE_STATE(DB); nsCOMPtr<mozIStorageStatement> stmt = DB->GetStatement( "/* do not warn (bug 487594) */ " "SELECT GROUP_CONCAT(tag_title, ', ') " "FROM ( " "SELECT t.title AS tag_title " "FROM moz_bookmarks b " "JOIN moz_bookmarks t ON t.id = +b.parent " "WHERE b.fk = (SELECT id FROM moz_places WHERE url_hash = hash(:page_url) AND url = :page_url) " "AND t.parent = :tags_folder " "ORDER BY t.title COLLATE NOCASE ASC " ") " ); NS_ENSURE_STATE(stmt); mozStorageStatementScoper scoper(stmt); nsNavHistory* history = nsNavHistory::GetHistoryService(); NS_ENSURE_STATE(history); nsresult rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("tags_folder"), history->GetTagsFolder()); NS_ENSURE_SUCCESS(rv, rv); rv = URIBinder::Bind(stmt, NS_LITERAL_CSTRING("page_url"), mURI); NS_ENSURE_SUCCESS(rv, rv); bool hasTags = false; if (NS_SUCCEEDED(stmt->ExecuteStep(&hasTags)) && hasTags) { rv = stmt->GetString(0, mTags); NS_ENSURE_SUCCESS(rv, rv); aTags.Assign(mTags); mAreTagsSorted = true; } // If this node is a child of a history query, we need to make sure changes // to tags are properly live-updated. if (mParent && mParent->IsQuery() && mParent->mOptions->QueryType() == nsINavHistoryQueryOptions::QUERY_TYPE_HISTORY) { nsNavHistoryQueryResultNode* query = mParent->GetAsQuery(); nsNavHistoryResult* result = query->GetResult(); NS_ENSURE_STATE(result); result->AddAllBookmarksObserver(query); } return NS_OK; } NS_IMETHODIMP nsNavHistoryResultNode::GetPageGuid(nsACString& aPageGuid) { aPageGuid = mPageGuid; return NS_OK; } NS_IMETHODIMP nsNavHistoryResultNode::GetBookmarkGuid(nsACString& aBookmarkGuid) { aBookmarkGuid = mBookmarkGuid; return NS_OK; } NS_IMETHODIMP nsNavHistoryResultNode::GetVisitId(int64_t* aVisitId) { *aVisitId = mVisitId; return NS_OK; } NS_IMETHODIMP nsNavHistoryResultNode::GetFromVisitId(int64_t* aFromVisitId) { *aFromVisitId = mFromVisitId; return NS_OK; } NS_IMETHODIMP nsNavHistoryResultNode::GetVisitType(uint32_t* aVisitType) { *aVisitType = mTransitionType; return NS_OK; } void nsNavHistoryResultNode::OnRemoving() { mParent = nullptr; } /** * This will find the result for this node. We can ask the nearest container * for this value (either ourselves or our parents should be a container, * and all containers have result pointers). * * @note The result may be null, if the container is detached from the result * who owns it. */ nsNavHistoryResult* nsNavHistoryResultNode::GetResult() { nsNavHistoryResultNode* node = this; do { if (node->IsContainer()) { nsNavHistoryContainerResultNode* container = TO_CONTAINER(node); return container->mResult; } node = node->mParent; } while (node); MOZ_ASSERT(false, "No container node found in hierarchy!"); return nullptr; } /** * Searches up the tree for the closest ancestor node that has an options * structure. This will tell us the options that were used to generate this * node. * * Be careful, this function walks up the tree, so it can not be used when * result nodes are created because they have no parent. Only call this * function after the tree has been built. */ nsNavHistoryQueryOptions* nsNavHistoryResultNode::GetGeneratingOptions() { if (!mParent) { // When we have no parent, it either means we haven't built the tree yet, // in which case calling this function is a bug, or this node is the root // of the tree. When we are the root of the tree, our own options are the // generating options. if (IsContainer()) return GetAsContainer()->mOptions; NS_NOTREACHED("Can't find a generating node for this container, perhaps FillStats has not been called on this tree yet?"); return nullptr; } // Look up the tree. We want the options that were used to create this node, // and since it has a parent, it's the options of an ancestor, not of the node // itself. So start at the parent. nsNavHistoryContainerResultNode* cur = mParent; while (cur) { if (cur->IsContainer()) return cur->GetAsContainer()->mOptions; cur = cur->mParent; } // We should always find a container node as an ancestor. NS_NOTREACHED("Can't find a generating node for this container, the tree seemes corrupted."); return nullptr; } NS_IMPL_CYCLE_COLLECTION_INHERITED(nsNavHistoryContainerResultNode, nsNavHistoryResultNode, mResult, mChildren) NS_IMPL_ADDREF_INHERITED(nsNavHistoryContainerResultNode, nsNavHistoryResultNode) NS_IMPL_RELEASE_INHERITED(nsNavHistoryContainerResultNode, nsNavHistoryResultNode) NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(nsNavHistoryContainerResultNode) NS_INTERFACE_MAP_STATIC_AMBIGUOUS(nsNavHistoryContainerResultNode) NS_INTERFACE_MAP_ENTRY(nsINavHistoryContainerResultNode) NS_INTERFACE_MAP_END_INHERITING(nsNavHistoryResultNode) nsNavHistoryContainerResultNode::nsNavHistoryContainerResultNode( const nsACString& aURI, const nsACString& aTitle, const nsACString& aIconURI, uint32_t aContainerType, nsNavHistoryQueryOptions* aOptions) : nsNavHistoryResultNode(aURI, aTitle, 0, 0, aIconURI), mResult(nullptr), mContainerType(aContainerType), mExpanded(false), mOptions(aOptions), mAsyncCanceledState(NOT_CANCELED) { } nsNavHistoryContainerResultNode::nsNavHistoryContainerResultNode( const nsACString& aURI, const nsACString& aTitle, PRTime aTime, const nsACString& aIconURI, uint32_t aContainerType, nsNavHistoryQueryOptions* aOptions) : nsNavHistoryResultNode(aURI, aTitle, 0, aTime, aIconURI), mResult(nullptr), mContainerType(aContainerType), mExpanded(false), mOptions(aOptions), mAsyncCanceledState(NOT_CANCELED) { } nsNavHistoryContainerResultNode::~nsNavHistoryContainerResultNode() { // Explicitly clean up array of children of this container. We must ensure // all references are gone and all of their destructors are called. mChildren.Clear(); } /** * Containers should notify their children that they are being removed when the * container is being removed. */ void nsNavHistoryContainerResultNode::OnRemoving() { nsNavHistoryResultNode::OnRemoving(); for (int32_t i = 0; i < mChildren.Count(); ++i) mChildren[i]->OnRemoving(); mChildren.Clear(); mResult = nullptr; } bool nsNavHistoryContainerResultNode::AreChildrenVisible() { nsNavHistoryResult* result = GetResult(); if (!result) { NS_NOTREACHED("Invalid result"); return false; } if (!mExpanded) return false; // Now check if any ancestor is closed. nsNavHistoryContainerResultNode* ancestor = mParent; while (ancestor) { if (!ancestor->mExpanded) return false; ancestor = ancestor->mParent; } return true; } NS_IMETHODIMP nsNavHistoryContainerResultNode::GetContainerOpen(bool *aContainerOpen) { *aContainerOpen = mExpanded; return NS_OK; } NS_IMETHODIMP nsNavHistoryContainerResultNode::SetContainerOpen(bool aContainerOpen) { if (aContainerOpen) { if (!mExpanded) { nsNavHistoryQueryOptions* options = GetGeneratingOptions(); if (options && options->AsyncEnabled()) OpenContainerAsync(); else OpenContainer(); } } else { if (mExpanded) CloseContainer(); else if (mAsyncPendingStmt) CancelAsyncOpen(false); } return NS_OK; } /** * Notifies the result's observers of a change in the container's state. The * notification includes both the old and new states: The old is aOldState, and * the new is the container's current state. * * @param aOldState * The state being transitioned out of. */ nsresult nsNavHistoryContainerResultNode::NotifyOnStateChange(uint16_t aOldState) { nsNavHistoryResult* result = GetResult(); NS_ENSURE_STATE(result); nsresult rv; uint16_t currState; rv = GetState(&currState); NS_ENSURE_SUCCESS(rv, rv); // Notify via the new ContainerStateChanged observer method. NOTIFY_RESULT_OBSERVERS(result, ContainerStateChanged(this, aOldState, currState)); return NS_OK; } NS_IMETHODIMP nsNavHistoryContainerResultNode::GetState(uint16_t* _state) { NS_ENSURE_ARG_POINTER(_state); *_state = mExpanded ? (uint16_t)STATE_OPENED : mAsyncPendingStmt ? (uint16_t)STATE_LOADING : (uint16_t)STATE_CLOSED; return NS_OK; } /** * This handles the generic container case. Other container types should * override this to do their own handling. */ nsresult nsNavHistoryContainerResultNode::OpenContainer() { NS_ASSERTION(!mExpanded, "Container must not be expanded to open it"); mExpanded = true; nsresult rv = NotifyOnStateChange(STATE_CLOSED); NS_ENSURE_SUCCESS(rv, rv); return NS_OK; } /** * Unset aSuppressNotifications to notify observers on this change. That is * the normal operation. This is set to false for the recursive calls since the * root container that is being closed will handle recomputation of the visible * elements for its entire subtree. */ nsresult nsNavHistoryContainerResultNode::CloseContainer(bool aSuppressNotifications) { NS_ASSERTION((mExpanded && !mAsyncPendingStmt) || (!mExpanded && mAsyncPendingStmt), "Container must be expanded or loading to close it"); nsresult rv; uint16_t oldState; rv = GetState(&oldState); NS_ENSURE_SUCCESS(rv, rv); if (mExpanded) { // Recursively close all child containers. for (int32_t i = 0; i < mChildren.Count(); ++i) { if (mChildren[i]->IsContainer() && mChildren[i]->GetAsContainer()->mExpanded) mChildren[i]->GetAsContainer()->CloseContainer(true); } mExpanded = false; } // Be sure to set this to null before notifying observers. It signifies that // the container is no longer loading (if it was in the first place). mAsyncPendingStmt = nullptr; if (!aSuppressNotifications) { rv = NotifyOnStateChange(oldState); NS_ENSURE_SUCCESS(rv, rv); } // If this is the root container of a result, we can tell the result to stop // observing changes, otherwise the result will stay in memory and updates // itself till it is cycle collected. nsNavHistoryResult* result = GetResult(); NS_ENSURE_STATE(result); if (result->mRootNode == this) { result->StopObserving(); // When reopening this node its result will be out of sync. // We must clear our children to ensure we will call FillChildren // again in such a case. if (this->IsQuery()) this->GetAsQuery()->ClearChildren(true); else if (this->IsFolder()) this->GetAsFolder()->ClearChildren(true); } return NS_OK; } /** * The async version of OpenContainer. */ nsresult nsNavHistoryContainerResultNode::OpenContainerAsync() { return NS_ERROR_NOT_IMPLEMENTED; } /** * Cancels the pending asynchronous Storage execution triggered by * FillChildrenAsync, if it exists. This method doesn't do much, because after * cancelation Storage will call this node's HandleCompletion callback, where * the real work is done. * * @param aRestart * If true, async execution will be restarted by HandleCompletion. */ void nsNavHistoryContainerResultNode::CancelAsyncOpen(bool aRestart) { NS_ASSERTION(mAsyncPendingStmt, "Async execution canceled but not pending"); mAsyncCanceledState = aRestart ? CANCELED_RESTART_NEEDED : CANCELED; // Cancel will fail if the pending statement has already been canceled. // That's OK since this method may be called multiple times, and multiple // cancels don't harm anything. (void)mAsyncPendingStmt->Cancel(); } /** * This builds up tree statistics from the bottom up. Call with a container * and the indent level of that container. To init the full tree, call with * the root container. The default indent level is -1, which is appropriate * for the root level. * * CALL THIS AFTER FILLING ANY CONTAINER to update the parent and result node * pointers, even if you don't care about visit counts and last visit dates. */ void nsNavHistoryContainerResultNode::FillStats() { uint32_t accessCount = 0; PRTime newTime = 0; for (int32_t i = 0; i < mChildren.Count(); ++i) { nsNavHistoryResultNode* node = mChildren[i]; node->mParent = this; node->mIndentLevel = mIndentLevel + 1; if (node->IsContainer()) { nsNavHistoryContainerResultNode* container = node->GetAsContainer(); container->mResult = mResult; container->FillStats(); } accessCount += node->mAccessCount; // this is how container nodes get sorted by date // The container gets the most recent time of the child nodes. if (node->mTime > newTime) newTime = node->mTime; } if (mExpanded) { mAccessCount = accessCount; if (!IsQuery() || newTime > mTime) mTime = newTime; } } /** * This is used when one container changes to do a minimal update of the tree * structure. When something changes, you want to call FillStats if necessary * and update this container completely. Then call this function which will * walk up the tree and fill in the previous containers. * * Note that you have to tell us by how much our access count changed. Our * access count should already be set to the new value; this is used tochange * the parents without having to re-count all their children. * * This does NOT update the last visit date downward. Therefore, if you are * deleting a node that has the most recent last visit date, the parents will * not get their last visit dates downshifted accordingly. This is a rather * unusual case: we don't often delete things, and we usually don't even show * the last visit date for folders. Updating would be slower because we would * have to recompute it from scratch. */ nsresult nsNavHistoryContainerResultNode::ReverseUpdateStats(int32_t aAccessCountChange) { if (mParent) { nsNavHistoryResult* result = GetResult(); bool shouldNotify = result && mParent->mParent && mParent->mParent->AreChildrenVisible(); mParent->mAccessCount += aAccessCountChange; bool timeChanged = false; if (mTime > mParent->mTime) { timeChanged = true; mParent->mTime = mTime; } if (shouldNotify) { NOTIFY_RESULT_OBSERVERS(result, NodeHistoryDetailsChanged(TO_ICONTAINER(mParent), mParent->mTime, mParent->mAccessCount)); } // check sorting, the stats may have caused this node to move if the // sorting depended on something we are changing. uint16_t sortMode = mParent->GetSortType(); bool sortingByVisitCount = sortMode == nsINavHistoryQueryOptions::SORT_BY_VISITCOUNT_ASCENDING || sortMode == nsINavHistoryQueryOptions::SORT_BY_VISITCOUNT_DESCENDING; bool sortingByTime = sortMode == nsINavHistoryQueryOptions::SORT_BY_DATE_ASCENDING || sortMode == nsINavHistoryQueryOptions::SORT_BY_DATE_DESCENDING; if ((sortingByVisitCount && aAccessCountChange != 0) || (sortingByTime && timeChanged)) { int32_t ourIndex = mParent->FindChild(this); NS_ASSERTION(ourIndex >= 0, "Could not find self in parent"); if (ourIndex >= 0) EnsureItemPosition(static_cast<uint32_t>(ourIndex)); } nsresult rv = mParent->ReverseUpdateStats(aAccessCountChange); NS_ENSURE_SUCCESS(rv, rv); } return NS_OK; } /** * This walks up the tree until we find a query result node or the root to get * the sorting type. */ uint16_t nsNavHistoryContainerResultNode::GetSortType() { if (mParent) return mParent->GetSortType(); if (mResult) return mResult->mSortingMode; // This is a detached container, just use natural order. return nsINavHistoryQueryOptions::SORT_BY_NONE; } nsresult nsNavHistoryContainerResultNode::Refresh() { NS_WARNING("Refresh() is supported by queries or folders, not generic containers."); return NS_OK; } void nsNavHistoryContainerResultNode::GetSortingAnnotation(nsACString& aAnnotation) { if (mParent) mParent->GetSortingAnnotation(aAnnotation); else if (mResult) aAnnotation.Assign(mResult->mSortingAnnotation); } /** * @return the sorting comparator function for the give sort type, or null if * there is no comparator. */ nsNavHistoryContainerResultNode::SortComparator nsNavHistoryContainerResultNode::GetSortingComparator(uint16_t aSortType) { switch (aSortType) { case nsINavHistoryQueryOptions::SORT_BY_NONE: return &SortComparison_Bookmark; case nsINavHistoryQueryOptions::SORT_BY_TITLE_ASCENDING: return &SortComparison_TitleLess; case nsINavHistoryQueryOptions::SORT_BY_TITLE_DESCENDING: return &SortComparison_TitleGreater; case nsINavHistoryQueryOptions::SORT_BY_DATE_ASCENDING: return &SortComparison_DateLess; case nsINavHistoryQueryOptions::SORT_BY_DATE_DESCENDING: return &SortComparison_DateGreater; case nsINavHistoryQueryOptions::SORT_BY_URI_ASCENDING: return &SortComparison_URILess; case nsINavHistoryQueryOptions::SORT_BY_URI_DESCENDING: return &SortComparison_URIGreater; case nsINavHistoryQueryOptions::SORT_BY_VISITCOUNT_ASCENDING: return &SortComparison_VisitCountLess; case nsINavHistoryQueryOptions::SORT_BY_VISITCOUNT_DESCENDING: return &SortComparison_VisitCountGreater; case nsINavHistoryQueryOptions::SORT_BY_KEYWORD_ASCENDING: return &SortComparison_KeywordLess; case nsINavHistoryQueryOptions::SORT_BY_KEYWORD_DESCENDING: return &SortComparison_KeywordGreater; case nsINavHistoryQueryOptions::SORT_BY_ANNOTATION_ASCENDING: return &SortComparison_AnnotationLess; case nsINavHistoryQueryOptions::SORT_BY_ANNOTATION_DESCENDING: return &SortComparison_AnnotationGreater; case nsINavHistoryQueryOptions::SORT_BY_DATEADDED_ASCENDING: return &SortComparison_DateAddedLess; case nsINavHistoryQueryOptions::SORT_BY_DATEADDED_DESCENDING: return &SortComparison_DateAddedGreater; case nsINavHistoryQueryOptions::SORT_BY_LASTMODIFIED_ASCENDING: return &SortComparison_LastModifiedLess; case nsINavHistoryQueryOptions::SORT_BY_LASTMODIFIED_DESCENDING: return &SortComparison_LastModifiedGreater; case nsINavHistoryQueryOptions::SORT_BY_TAGS_ASCENDING: return &SortComparison_TagsLess; case nsINavHistoryQueryOptions::SORT_BY_TAGS_DESCENDING: return &SortComparison_TagsGreater; case nsINavHistoryQueryOptions::SORT_BY_FRECENCY_ASCENDING: return &SortComparison_FrecencyLess; case nsINavHistoryQueryOptions::SORT_BY_FRECENCY_DESCENDING: return &SortComparison_FrecencyGreater; default: NS_NOTREACHED("Bad sorting type"); return nullptr; } } /** * This is used by Result::SetSortingMode and QueryResultNode::FillChildren to * sort the child list. * * This does NOT update any visibility or tree information. The caller will * have to completely rebuild the visible list after this. */ void nsNavHistoryContainerResultNode::RecursiveSort( const char* aData, SortComparator aComparator) { void* data = const_cast<void*>(static_cast<const void*>(aData)); mChildren.Sort(aComparator, data); for (int32_t i = 0; i < mChildren.Count(); ++i) { if (mChildren[i]->IsContainer()) mChildren[i]->GetAsContainer()->RecursiveSort(aData, aComparator); } } /** * @return the index that the given item would fall on if it were to be * inserted using the given sorting. */ uint32_t nsNavHistoryContainerResultNode::FindInsertionPoint( nsNavHistoryResultNode* aNode, SortComparator aComparator, const char* aData, bool* aItemExists) { if (aItemExists) (*aItemExists) = false; if (mChildren.Count() == 0) return 0; void* data = const_cast<void*>(static_cast<const void*>(aData)); // The common case is the beginning or the end because this is used to insert // new items that are added to history, which is usually sorted by date. int32_t res; res = aComparator(aNode, mChildren[0], data); if (res <= 0) { if (aItemExists && res == 0) (*aItemExists) = true; return 0; } res = aComparator(aNode, mChildren[mChildren.Count() - 1], data); if (res >= 0) { if (aItemExists && res == 0) (*aItemExists) = true; return mChildren.Count(); } uint32_t beginRange = 0; // inclusive uint32_t endRange = mChildren.Count(); // exclusive while (1) { if (beginRange == endRange) return endRange; uint32_t center = beginRange + (endRange - beginRange) / 2; int32_t res = aComparator(aNode, mChildren[center], data); if (res <= 0) { endRange = center; // left side if (aItemExists && res == 0) (*aItemExists) = true; } else { beginRange = center + 1; // right site } } } /** * This checks the child node at the given index to see if its sorting is * correct. This is called when nodes are updated and we need to see whether * we need to move it. * * @returns true if not and it should be resorted. */ bool nsNavHistoryContainerResultNode::DoesChildNeedResorting(uint32_t aIndex, SortComparator aComparator, const char* aData) { NS_ASSERTION(aIndex < uint32_t(mChildren.Count()), "Input index out of range"); if (mChildren.Count() == 1) return false; void* data = const_cast<void*>(static_cast<const void*>(aData)); if (aIndex > 0) { // compare to previous item if (aComparator(mChildren[aIndex - 1], mChildren[aIndex], data) > 0) return true; } if (aIndex < uint32_t(mChildren.Count()) - 1) { // compare to next item if (aComparator(mChildren[aIndex], mChildren[aIndex + 1], data) > 0) return true; } return false; } /* static */ int32_t nsNavHistoryContainerResultNode::SortComparison_StringLess( const nsAString& a, const nsAString& b) { nsNavHistory* history = nsNavHistory::GetHistoryService(); NS_ENSURE_TRUE(history, 0); nsICollation* collation = history->GetCollation(); NS_ENSURE_TRUE(collation, 0); int32_t res = 0; collation->CompareString(nsICollation::kCollationCaseInSensitive, a, b, &res); return res; } /** * When there are bookmark indices, we should never have ties, so we don't * need to worry about tiebreaking. When there are no bookmark indices, * everything will be -1 and we don't worry about sorting. */ int32_t nsNavHistoryContainerResultNode::SortComparison_Bookmark( nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure) { return a->mBookmarkIndex - b->mBookmarkIndex; } /** * These are a little more complicated because they do a localization * conversion. If this is too slow, we can compute the sort keys once in * advance, sort that array, and then reorder the real array accordingly. * This would save some key generations. * * The collation object must be allocated before sorting on title! */ int32_t nsNavHistoryContainerResultNode::SortComparison_TitleLess( nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure) { uint32_t aType; a->GetType(&aType); int32_t value = SortComparison_StringLess(NS_ConvertUTF8toUTF16(a->mTitle), NS_ConvertUTF8toUTF16(b->mTitle)); if (value == 0) { // resolve by URI if (a->IsURI()) { value = a->mURI.Compare(b->mURI.get()); } if (value == 0) { // resolve by date value = ComparePRTime(a->mTime, b->mTime); if (value == 0) value = nsNavHistoryContainerResultNode::SortComparison_Bookmark(a, b, closure); } } return value; } int32_t nsNavHistoryContainerResultNode::SortComparison_TitleGreater( nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure) { return -SortComparison_TitleLess(a, b, closure); } /** * Equal times will be very unusual, but it is important that there is some * deterministic ordering of the results so they don't move around. */ int32_t nsNavHistoryContainerResultNode::SortComparison_DateLess( nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure) { int32_t value = ComparePRTime(a->mTime, b->mTime); if (value == 0) { value = SortComparison_StringLess(NS_ConvertUTF8toUTF16(a->mTitle), NS_ConvertUTF8toUTF16(b->mTitle)); if (value == 0) value = nsNavHistoryContainerResultNode::SortComparison_Bookmark(a, b, closure); } return value; } int32_t nsNavHistoryContainerResultNode::SortComparison_DateGreater( nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure) { return -nsNavHistoryContainerResultNode::SortComparison_DateLess(a, b, closure); } int32_t nsNavHistoryContainerResultNode::SortComparison_DateAddedLess( nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure) { int32_t value = ComparePRTime(a->mDateAdded, b->mDateAdded); if (value == 0) { value = SortComparison_StringLess(NS_ConvertUTF8toUTF16(a->mTitle), NS_ConvertUTF8toUTF16(b->mTitle)); if (value == 0) value = nsNavHistoryContainerResultNode::SortComparison_Bookmark(a, b, closure); } return value; } int32_t nsNavHistoryContainerResultNode::SortComparison_DateAddedGreater( nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure) { return -nsNavHistoryContainerResultNode::SortComparison_DateAddedLess(a, b, closure); } int32_t nsNavHistoryContainerResultNode::SortComparison_LastModifiedLess( nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure) { int32_t value = ComparePRTime(a->mLastModified, b->mLastModified); if (value == 0) { value = SortComparison_StringLess(NS_ConvertUTF8toUTF16(a->mTitle), NS_ConvertUTF8toUTF16(b->mTitle)); if (value == 0) value = nsNavHistoryContainerResultNode::SortComparison_Bookmark(a, b, closure); } return value; } int32_t nsNavHistoryContainerResultNode::SortComparison_LastModifiedGreater( nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure) { return -nsNavHistoryContainerResultNode::SortComparison_LastModifiedLess(a, b, closure); } /** * Certain types of parent nodes are treated specially because URIs are not * valid (like days or hosts). */ int32_t nsNavHistoryContainerResultNode::SortComparison_URILess( nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure) { int32_t value; if (a->IsURI() && b->IsURI()) { // normal URI or visit value = a->mURI.Compare(b->mURI.get()); } else { // for everything else, use title (= host name) value = SortComparison_StringLess(NS_ConvertUTF8toUTF16(a->mTitle), NS_ConvertUTF8toUTF16(b->mTitle)); } if (value == 0) { value = ComparePRTime(a->mTime, b->mTime); if (value == 0) value = nsNavHistoryContainerResultNode::SortComparison_Bookmark(a, b, closure); } return value; } int32_t nsNavHistoryContainerResultNode::SortComparison_URIGreater( nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure) { return -SortComparison_URILess(a, b, closure); } int32_t nsNavHistoryContainerResultNode::SortComparison_KeywordLess( nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure) { int32_t value = 0; if (a->mItemId != -1 || b->mItemId != -1) { // compare the keywords nsAutoString keywordA, keywordB; nsNavBookmarks* bookmarks = nsNavBookmarks::GetBookmarksService(); NS_ENSURE_TRUE(bookmarks, 0); nsresult rv; if (a->mItemId != -1) { rv = bookmarks->GetKeywordForBookmark(a->mItemId, keywordA); NS_ENSURE_SUCCESS(rv, 0); } if (b->mItemId != -1) { rv = bookmarks->GetKeywordForBookmark(b->mItemId, keywordB); NS_ENSURE_SUCCESS(rv, 0); } value = SortComparison_StringLess(keywordA, keywordB); } // Fall back to title sorting. if (value == 0) value = SortComparison_TitleLess(a, b, closure); return value; } int32_t nsNavHistoryContainerResultNode::SortComparison_KeywordGreater( nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure) { return -SortComparison_KeywordLess(a, b, closure); } int32_t nsNavHistoryContainerResultNode::SortComparison_AnnotationLess( nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure) { nsAutoCString annoName(static_cast<char*>(closure)); NS_ENSURE_TRUE(!annoName.IsEmpty(), 0); bool a_itemAnno = false; bool b_itemAnno = false; // Not used for item annos nsCOMPtr<nsIURI> a_uri, b_uri; if (a->mItemId != -1) { a_itemAnno = true; } else { nsAutoCString spec; if (NS_SUCCEEDED(a->GetUri(spec))){ MOZ_ALWAYS_SUCCEEDS(NS_NewURI(getter_AddRefs(a_uri), spec)); } NS_ENSURE_TRUE(a_uri, 0); } if (b->mItemId != -1) { b_itemAnno = true; } else { nsAutoCString spec; if (NS_SUCCEEDED(b->GetUri(spec))) { MOZ_ALWAYS_SUCCEEDS(NS_NewURI(getter_AddRefs(b_uri), spec)); } NS_ENSURE_TRUE(b_uri, 0); } nsAnnotationService* annosvc = nsAnnotationService::GetAnnotationService(); NS_ENSURE_TRUE(annosvc, 0); bool a_hasAnno, b_hasAnno; if (a_itemAnno) { NS_ENSURE_SUCCESS(annosvc->ItemHasAnnotation(a->mItemId, annoName, &a_hasAnno), 0); } else { NS_ENSURE_SUCCESS(annosvc->PageHasAnnotation(a_uri, annoName, &a_hasAnno), 0); } if (b_itemAnno) { NS_ENSURE_SUCCESS(annosvc->ItemHasAnnotation(b->mItemId, annoName, &b_hasAnno), 0); } else { NS_ENSURE_SUCCESS(annosvc->PageHasAnnotation(b_uri, annoName, &b_hasAnno), 0); } int32_t value = 0; if (a_hasAnno || b_hasAnno) { uint16_t annoType; if (a_hasAnno) { if (a_itemAnno) { NS_ENSURE_SUCCESS(annosvc->GetItemAnnotationType(a->mItemId, annoName, &annoType), 0); } else { NS_ENSURE_SUCCESS(annosvc->GetPageAnnotationType(a_uri, annoName, &annoType), 0); } } if (b_hasAnno) { uint16_t b_type; if (b_itemAnno) { NS_ENSURE_SUCCESS(annosvc->GetItemAnnotationType(b->mItemId, annoName, &b_type), 0); } else { NS_ENSURE_SUCCESS(annosvc->GetPageAnnotationType(b_uri, annoName, &b_type), 0); } // We better make the API not support this state, really // XXXmano: this is actually wrong for double<->int and int64_t<->int32_t if (a_hasAnno && b_type != annoType) return 0; annoType = b_type; } #define GET_ANNOTATIONS_VALUES(METHOD_ITEM, METHOD_PAGE, A_VAL, B_VAL) \ if (a_hasAnno) { \ if (a_itemAnno) { \ NS_ENSURE_SUCCESS(annosvc->METHOD_ITEM(a->mItemId, annoName, \ A_VAL), 0); \ } else { \ NS_ENSURE_SUCCESS(annosvc->METHOD_PAGE(a_uri, annoName, \ A_VAL), 0); \ } \ } \ if (b_hasAnno) { \ if (b_itemAnno) { \ NS_ENSURE_SUCCESS(annosvc->METHOD_ITEM(b->mItemId, annoName, \ B_VAL), 0); \ } else { \ NS_ENSURE_SUCCESS(annosvc->METHOD_PAGE(b_uri, annoName, \ B_VAL), 0); \ } \ } if (annoType == nsIAnnotationService::TYPE_STRING) { nsAutoString a_val, b_val; GET_ANNOTATIONS_VALUES(GetItemAnnotationString, GetPageAnnotationString, a_val, b_val); value = SortComparison_StringLess(a_val, b_val); } else if (annoType == nsIAnnotationService::TYPE_INT32) { int32_t a_val = 0, b_val = 0; GET_ANNOTATIONS_VALUES(GetItemAnnotationInt32, GetPageAnnotationInt32, &a_val, &b_val); value = (a_val < b_val) ? -1 : (a_val > b_val) ? 1 : 0; } else if (annoType == nsIAnnotationService::TYPE_INT64) { int64_t a_val = 0, b_val = 0; GET_ANNOTATIONS_VALUES(GetItemAnnotationInt64, GetPageAnnotationInt64, &a_val, &b_val); value = (a_val < b_val) ? -1 : (a_val > b_val) ? 1 : 0; } else if (annoType == nsIAnnotationService::TYPE_DOUBLE) { double a_val = 0, b_val = 0; GET_ANNOTATIONS_VALUES(GetItemAnnotationDouble, GetPageAnnotationDouble, &a_val, &b_val); value = (a_val < b_val) ? -1 : (a_val > b_val) ? 1 : 0; } } // Note we also fall back to the title-sorting route one of the items didn't // have the annotation set or if both had it set but in a different storage // type if (value == 0) return SortComparison_TitleLess(a, b, nullptr); return value; } int32_t nsNavHistoryContainerResultNode::SortComparison_AnnotationGreater( nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure) { return -SortComparison_AnnotationLess(a, b, closure); } /** * Fall back on dates for conflict resolution */ int32_t nsNavHistoryContainerResultNode::SortComparison_VisitCountLess( nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure) { int32_t value = CompareIntegers(a->mAccessCount, b->mAccessCount); if (value == 0) { value = ComparePRTime(a->mTime, b->mTime); if (value == 0) value = nsNavHistoryContainerResultNode::SortComparison_Bookmark(a, b, closure); } return value; } int32_t nsNavHistoryContainerResultNode::SortComparison_VisitCountGreater( nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure) { return -nsNavHistoryContainerResultNode::SortComparison_VisitCountLess(a, b, closure); } int32_t nsNavHistoryContainerResultNode::SortComparison_TagsLess( nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure) { int32_t value = 0; nsAutoString aTags, bTags; nsresult rv = a->GetTags(aTags); NS_ENSURE_SUCCESS(rv, 0); rv = b->GetTags(bTags); NS_ENSURE_SUCCESS(rv, 0); value = SortComparison_StringLess(aTags, bTags); // fall back to title sorting if (value == 0) value = SortComparison_TitleLess(a, b, closure); return value; } int32_t nsNavHistoryContainerResultNode::SortComparison_TagsGreater( nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure) { return -SortComparison_TagsLess(a, b, closure); } /** * Fall back on date and bookmarked status, for conflict resolution. */ int32_t nsNavHistoryContainerResultNode::SortComparison_FrecencyLess( nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure ) { int32_t value = CompareIntegers(a->mFrecency, b->mFrecency); if (value == 0) { value = ComparePRTime(a->mTime, b->mTime); if (value == 0) { value = nsNavHistoryContainerResultNode::SortComparison_Bookmark(a, b, closure); } } return value; } int32_t nsNavHistoryContainerResultNode::SortComparison_FrecencyGreater( nsNavHistoryResultNode* a, nsNavHistoryResultNode* b, void* closure ) { return -nsNavHistoryContainerResultNode::SortComparison_FrecencyLess(a, b, closure); } /** * Searches this folder for a node with the given URI. Returns null if not * found. * * @note Does not addref the node! */ nsNavHistoryResultNode* nsNavHistoryContainerResultNode::FindChildURI(const nsACString& aSpec, uint32_t* aNodeIndex) { for (int32_t i = 0; i < mChildren.Count(); ++i) { if (mChildren[i]->IsURI()) { if (aSpec.Equals(mChildren[i]->mURI)) { *aNodeIndex = i; return mChildren[i]; } } } return nullptr; } /** * This does the work of adding a child to the container. The child can be * either a container or or a single item that may even be collapsed with the * adjacent ones. */ nsresult nsNavHistoryContainerResultNode::InsertChildAt(nsNavHistoryResultNode* aNode, int32_t aIndex) { nsNavHistoryResult* result = GetResult(); NS_ENSURE_STATE(result); aNode->mParent = this; aNode->mIndentLevel = mIndentLevel + 1; if (aNode->IsContainer()) { // need to update all the new item's children nsNavHistoryContainerResultNode* container = aNode->GetAsContainer(); container->mResult = result; container->FillStats(); } if (!mChildren.InsertObjectAt(aNode, aIndex)) return NS_ERROR_OUT_OF_MEMORY; // Update our stats and notify the result's observers. mAccessCount += aNode->mAccessCount; if (mTime < aNode->mTime) mTime = aNode->mTime; if (!mParent || mParent->AreChildrenVisible()) { NOTIFY_RESULT_OBSERVERS(result, NodeHistoryDetailsChanged(TO_ICONTAINER(this), mTime, mAccessCount)); } nsresult rv = ReverseUpdateStats(aNode->mAccessCount); NS_ENSURE_SUCCESS(rv, rv); // Update tree if we are visible. Note that we could be here and not // expanded, like when there is a bookmark folder being updated because its // parent is visible. if (AreChildrenVisible()) NOTIFY_RESULT_OBSERVERS(result, NodeInserted(this, aNode, aIndex)); return NS_OK; } /** * This locates the proper place for insertion according to the current sort * and calls InsertChildAt */ nsresult nsNavHistoryContainerResultNode::InsertSortedChild( nsNavHistoryResultNode* aNode, bool aIgnoreDuplicates) { if (mChildren.Count() == 0) return InsertChildAt(aNode, 0); SortComparator comparator = GetSortingComparator(GetSortType()); if (comparator) { // When inserting a new node, it must have proper statistics because we use // them to find the correct insertion point. The insert function will then // recompute these statistics and fill in the proper parents and hierarchy // level. Doing this twice shouldn't be a large performance penalty because // when we are inserting new containers, they typically contain only one // item (because we've browsed a new page). if (aNode->IsContainer()) { // need to update all the new item's children nsNavHistoryContainerResultNode* container = aNode->GetAsContainer(); container->mResult = mResult; container->FillStats(); } nsAutoCString sortingAnnotation; GetSortingAnnotation(sortingAnnotation); bool itemExists; uint32_t position = FindInsertionPoint(aNode, comparator, sortingAnnotation.get(), &itemExists); if (aIgnoreDuplicates && itemExists) return NS_OK; return InsertChildAt(aNode, position); } return InsertChildAt(aNode, mChildren.Count()); } /** * This checks if the item at aIndex is located correctly given the sorting * move. If it's not, the item is moved, and the result's observers are * notified. * * @return true if the item position has been changed, false otherwise. */ bool nsNavHistoryContainerResultNode::EnsureItemPosition(uint32_t aIndex) { NS_ASSERTION(aIndex < (uint32_t)mChildren.Count(), "Invalid index"); if (aIndex >= (uint32_t)mChildren.Count()) return false; SortComparator comparator = GetSortingComparator(GetSortType()); if (!comparator) return false; nsAutoCString sortAnno; GetSortingAnnotation(sortAnno); if (!DoesChildNeedResorting(aIndex, comparator, sortAnno.get())) return false; RefPtr<nsNavHistoryResultNode> node(mChildren[aIndex]); mChildren.RemoveObjectAt(aIndex); uint32_t newIndex = FindInsertionPoint( node, comparator,sortAnno.get(), nullptr); mChildren.InsertObjectAt(node.get(), newIndex); if (AreChildrenVisible()) { nsNavHistoryResult* result = GetResult(); NOTIFY_RESULT_OBSERVERS_RET(result, NodeMoved(node, this, aIndex, this, newIndex), false); } return true; } /** * This does all the work of removing a child from this container, including * updating the tree if necessary. Note that we do not need to be open for * this to work. */ nsresult nsNavHistoryContainerResultNode::RemoveChildAt(int32_t aIndex) { NS_ASSERTION(aIndex >= 0 && aIndex < mChildren.Count(), "Invalid index"); // Hold an owning reference to keep from expiring while we work with it. RefPtr<nsNavHistoryResultNode> oldNode = mChildren[aIndex]; // Update stats. // XXX This assertion does not reliably pass -- investigate!! (bug 1049797) // MOZ_ASSERT(mAccessCount >= mChildren[aIndex]->mAccessCount, // "Invalid access count while updating!"); uint32_t oldAccessCount = mAccessCount; mAccessCount -= mChildren[aIndex]->mAccessCount; // Remove it from our list and notify the result's observers. mChildren.RemoveObjectAt(aIndex); if (AreChildrenVisible()) { nsNavHistoryResult* result = GetResult(); NOTIFY_RESULT_OBSERVERS(result, NodeRemoved(this, oldNode, aIndex)); } nsresult rv = ReverseUpdateStats(mAccessCount - oldAccessCount); NS_ENSURE_SUCCESS(rv, rv); oldNode->OnRemoving(); return NS_OK; } /** * Searches for matches for the given URI. If aOnlyOne is set, it will * terminate as soon as it finds a single match. This would be used when there * are URI results so there will only ever be one copy of any URI. * * When aOnlyOne is false, it will check all elements. This is for visit * style results that may have multiple copies of any given URI. */ void nsNavHistoryContainerResultNode::RecursiveFindURIs(bool aOnlyOne, nsNavHistoryContainerResultNode* aContainer, const nsCString& aSpec, nsCOMArray<nsNavHistoryResultNode>* aMatches) { for (int32_t child = 0; child < aContainer->mChildren.Count(); ++child) { uint32_t type; aContainer->mChildren[child]->GetType(&type); if (nsNavHistoryResultNode::IsTypeURI(type)) { // compare URIs nsNavHistoryResultNode* uriNode = aContainer->mChildren[child]; if (uriNode->mURI.Equals(aSpec)) { // found aMatches->AppendObject(uriNode); if (aOnlyOne) return; } } } } /** * If aUpdateSort is true, we will also update the sorting of this item. * Normally you want this to be true, but it can be false if the thing you are * changing can not affect sorting (like favicons). * * You should NOT change any child lists as part of the callback function. */ bool nsNavHistoryContainerResultNode::UpdateURIs(bool aRecursive, bool aOnlyOne, bool aUpdateSort, const nsCString& aSpec, nsresult (*aCallback)(nsNavHistoryResultNode*, const void*, const nsNavHistoryResult*), const void* aClosure) { const nsNavHistoryResult* result = GetResult(); if (!result) { MOZ_ASSERT(false, "Should have a result"); return false; } // this needs to be owning since sometimes we remove and re-insert nodes // in their parents and we don't want them to go away. nsCOMArray<nsNavHistoryResultNode> matches; if (aRecursive) { RecursiveFindURIs(aOnlyOne, this, aSpec, &matches); } else if (aOnlyOne) { uint32_t nodeIndex; nsNavHistoryResultNode* node = FindChildURI(aSpec, &nodeIndex); if (node) matches.AppendObject(node); } else { MOZ_ASSERT(false, "UpdateURIs does not handle nonrecursive updates of multiple items."); // this case easy to add if you need it, just find all the matching URIs // at this level. However, this isn't currently used. History uses // recursive, Bookmarks uses one level and knows that the match is unique. return false; } if (matches.Count() == 0) return false; // PERFORMANCE: This updates each container for each child in it that // changes. In some cases, many elements have changed inside the same // container. It would be better to compose a list of containers, and // update each one only once for all the items that have changed in it. for (int32_t i = 0; i < matches.Count(); ++i) { nsNavHistoryResultNode* node = matches[i]; nsNavHistoryContainerResultNode* parent = node->mParent; if (!parent) { MOZ_ASSERT(false, "All URI nodes being updated must have parents"); continue; } uint32_t oldAccessCount = node->mAccessCount; PRTime oldTime = node->mTime; aCallback(node, aClosure, result); if (oldAccessCount != node->mAccessCount || oldTime != node->mTime) { parent->mAccessCount += node->mAccessCount - oldAccessCount; if (node->mTime > parent->mTime) parent->mTime = node->mTime; if (parent->AreChildrenVisible()) { NOTIFY_RESULT_OBSERVERS_RET(result, NodeHistoryDetailsChanged( TO_ICONTAINER(parent), parent->mTime, parent->mAccessCount), true); } DebugOnly<nsresult> rv = parent->ReverseUpdateStats(node->mAccessCount - oldAccessCount); MOZ_ASSERT(NS_SUCCEEDED(rv), "should be able to ReverseUpdateStats"); } if (aUpdateSort) { int32_t childIndex = parent->FindChild(node); MOZ_ASSERT(childIndex >= 0, "Could not find child we just got a reference to"); if (childIndex >= 0) parent->EnsureItemPosition(childIndex); } } return true; } /** * This is used to update the titles in the tree. This is called from both * query and bookmark folder containers to update the tree. Bookmark folders * should be sure to set recursive to false, since child folders will have * their own callbacks registered. */ static nsresult setTitleCallback(nsNavHistoryResultNode* aNode, const void* aClosure, const nsNavHistoryResult* aResult) { const nsACString* newTitle = static_cast<const nsACString*>(aClosure); aNode->mTitle = *newTitle; if (aResult && (!aNode->mParent || aNode->mParent->AreChildrenVisible())) NOTIFY_RESULT_OBSERVERS(aResult, NodeTitleChanged(aNode, *newTitle)); return NS_OK; } nsresult nsNavHistoryContainerResultNode::ChangeTitles(nsIURI* aURI, const nsACString& aNewTitle, bool aRecursive, bool aOnlyOne) { // uri string nsAutoCString uriString; nsresult rv = aURI->GetSpec(uriString); NS_ENSURE_SUCCESS(rv, rv); // The recursive function will update the result's tree nodes, but only if we // give it a non-null pointer. So if there isn't a tree, just pass nullptr // so it doesn't bother trying to call the result. nsNavHistoryResult* result = GetResult(); NS_ENSURE_STATE(result); uint16_t sortType = GetSortType(); bool updateSorting = (sortType == nsINavHistoryQueryOptions::SORT_BY_TITLE_ASCENDING || sortType == nsINavHistoryQueryOptions::SORT_BY_TITLE_DESCENDING); UpdateURIs(aRecursive, aOnlyOne, updateSorting, uriString, setTitleCallback, static_cast<const void*>(&aNewTitle)); return NS_OK; } /** * Complex containers (folders and queries) will override this. Here, we * handle the case of simple containers (like host groups) where the children * are always stored. */ NS_IMETHODIMP nsNavHistoryContainerResultNode::GetHasChildren(bool *aHasChildren) { *aHasChildren = (mChildren.Count() > 0); return NS_OK; } /** * @throws if this node is closed. */ NS_IMETHODIMP nsNavHistoryContainerResultNode::GetChildCount(uint32_t* aChildCount) { if (!mExpanded) return NS_ERROR_NOT_AVAILABLE; *aChildCount = mChildren.Count(); return NS_OK; } NS_IMETHODIMP nsNavHistoryContainerResultNode::GetChild(uint32_t aIndex, nsINavHistoryResultNode** _retval) { if (!mExpanded) return NS_ERROR_NOT_AVAILABLE; if (aIndex >= uint32_t(mChildren.Count())) return NS_ERROR_INVALID_ARG; NS_ADDREF(*_retval = mChildren[aIndex]); return NS_OK; } NS_IMETHODIMP nsNavHistoryContainerResultNode::GetChildIndex(nsINavHistoryResultNode* aNode, uint32_t* _retval) { if (!mExpanded) return NS_ERROR_NOT_AVAILABLE; int32_t nodeIndex = FindChild(static_cast<nsNavHistoryResultNode*>(aNode)); if (nodeIndex == -1) return NS_ERROR_INVALID_ARG; *_retval = nodeIndex; return NS_OK; } NS_IMETHODIMP nsNavHistoryContainerResultNode::FindNodeByDetails(const nsACString& aURIString, PRTime aTime, int64_t aItemId, bool aRecursive, nsINavHistoryResultNode** _retval) { if (!mExpanded) return NS_ERROR_NOT_AVAILABLE; *_retval = nullptr; for (int32_t i = 0; i < mChildren.Count(); ++i) { if (mChildren[i]->mURI.Equals(aURIString) && mChildren[i]->mTime == aTime && mChildren[i]->mItemId == aItemId) { *_retval = mChildren[i]; break; } if (aRecursive && mChildren[i]->IsContainer()) { nsNavHistoryContainerResultNode* asContainer = mChildren[i]->GetAsContainer(); if (asContainer->mExpanded) { nsresult rv = asContainer->FindNodeByDetails(aURIString, aTime, aItemId, aRecursive, _retval); if (NS_SUCCEEDED(rv) && _retval) break; } } } NS_IF_ADDREF(*_retval); return NS_OK; } /** * HOW QUERY UPDATING WORKS * * Queries are different than bookmark folders in that we can not always do * dynamic updates (easily) and updates are more expensive. Therefore, we do * NOT query if we are not open and want to see if we have any children (for * drawing a twisty) and always assume we will. * * When the container is opened, we execute the query and register the * listeners. Like bookmark folders, we stay registered even when closed, and * clear ourselves as soon as a message comes in. This lets us respond quickly * if the user closes and reopens the container. * * We try to handle the most common notifications for the most common query * types dynamically, that is, figuring out what should happen in response to * a message without doing a requery. For complex changes or complex queries, * we give up and requery. */ NS_IMPL_ISUPPORTS_INHERITED(nsNavHistoryQueryResultNode, nsNavHistoryContainerResultNode, nsINavHistoryQueryResultNode) nsNavHistoryQueryResultNode::nsNavHistoryQueryResultNode( const nsACString& aTitle, const nsACString& aIconURI, const nsACString& aQueryURI) : nsNavHistoryContainerResultNode(aQueryURI, aTitle, aIconURI, nsNavHistoryResultNode::RESULT_TYPE_QUERY, nullptr), mLiveUpdate(QUERYUPDATE_COMPLEX_WITH_BOOKMARKS), mHasSearchTerms(false), mContentsValid(false), mBatchChanges(0) { } nsNavHistoryQueryResultNode::nsNavHistoryQueryResultNode( const nsACString& aTitle, const nsACString& aIconURI, const nsCOMArray<nsNavHistoryQuery>& aQueries, nsNavHistoryQueryOptions* aOptions) : nsNavHistoryContainerResultNode(EmptyCString(), aTitle, aIconURI, nsNavHistoryResultNode::RESULT_TYPE_QUERY, aOptions), mQueries(aQueries), mContentsValid(false), mBatchChanges(0), mTransitions(mQueries[0]->Transitions()) { NS_ASSERTION(aQueries.Count() > 0, "Must have at least one query"); nsNavHistory* history = nsNavHistory::GetHistoryService(); NS_ASSERTION(history, "History service missing"); if (history) { mLiveUpdate = history->GetUpdateRequirements(mQueries, mOptions, &mHasSearchTerms); } // Collect transitions shared by all queries. for (int32_t i = 1; i < mQueries.Count(); ++i) { const nsTArray<uint32_t>& queryTransitions = mQueries[i]->Transitions(); for (uint32_t j = 0; j < mTransitions.Length() ; ++j) { uint32_t transition = mTransitions.SafeElementAt(j, 0); if (transition && !queryTransitions.Contains(transition)) mTransitions.RemoveElement(transition); } } } nsNavHistoryQueryResultNode::nsNavHistoryQueryResultNode( const nsACString& aTitle, const nsACString& aIconURI, PRTime aTime, const nsCOMArray<nsNavHistoryQuery>& aQueries, nsNavHistoryQueryOptions* aOptions) : nsNavHistoryContainerResultNode(EmptyCString(), aTitle, aTime, aIconURI, nsNavHistoryResultNode::RESULT_TYPE_QUERY, aOptions), mQueries(aQueries), mContentsValid(false), mBatchChanges(0), mTransitions(mQueries[0]->Transitions()) { NS_ASSERTION(aQueries.Count() > 0, "Must have at least one query"); nsNavHistory* history = nsNavHistory::GetHistoryService(); NS_ASSERTION(history, "History service missing"); if (history) { mLiveUpdate = history->GetUpdateRequirements(mQueries, mOptions, &mHasSearchTerms); } // Collect transitions shared by all queries. for (int32_t i = 1; i < mQueries.Count(); ++i) { const nsTArray<uint32_t>& queryTransitions = mQueries[i]->Transitions(); for (uint32_t j = 0; j < mTransitions.Length() ; ++j) { uint32_t transition = mTransitions.SafeElementAt(j, 0); if (transition && !queryTransitions.Contains(transition)) mTransitions.RemoveElement(transition); } } } nsNavHistoryQueryResultNode::~nsNavHistoryQueryResultNode() { // Remove this node from result's observers. We don't need to be notified // anymore. if (mResult && mResult->mAllBookmarksObservers.Contains(this)) mResult->RemoveAllBookmarksObserver(this); if (mResult && mResult->mHistoryObservers.Contains(this)) mResult->RemoveHistoryObserver(this); } /** * Whoever made us may want non-expanding queries. However, we always expand * when we are the root node, or else asking for non-expanding queries would be * useless. A query node is not expandable if excludeItems is set or if * expandQueries is unset. */ bool nsNavHistoryQueryResultNode::CanExpand() { if (IsContainersQuery()) return true; // If ExcludeItems is set on the root or on the node itself, don't expand. if ((mResult && mResult->mRootNode->mOptions->ExcludeItems()) || Options()->ExcludeItems()) return false; // Check the ancestor container. nsNavHistoryQueryOptions* options = GetGeneratingOptions(); if (options) { if (options->ExcludeItems()) return false; if (options->ExpandQueries()) return true; } if (mResult && mResult->mRootNode == this) return true; return false; } /** * Some query with a particular result type can contain other queries. They * must be always expandable */ bool nsNavHistoryQueryResultNode::IsContainersQuery() { uint16_t resultType = Options()->ResultType(); return resultType == nsINavHistoryQueryOptions::RESULTS_AS_DATE_QUERY || resultType == nsINavHistoryQueryOptions::RESULTS_AS_DATE_SITE_QUERY || resultType == nsINavHistoryQueryOptions::RESULTS_AS_TAG_QUERY || resultType == nsINavHistoryQueryOptions::RESULTS_AS_SITE_QUERY; } /** * Here we do not want to call ContainerResultNode::OnRemoving since our own * ClearChildren will do the same thing and more (unregister the observers). * The base ResultNode::OnRemoving will clear some regular node stats, so it * is OK. */ void nsNavHistoryQueryResultNode::OnRemoving() { nsNavHistoryResultNode::OnRemoving(); ClearChildren(true); mResult = nullptr; } /** * Marks the container as open, rebuilding results if they are invalid. We * may still have valid results if the container was previously open and * nothing happened since closing it. * * We do not handle CloseContainer specially. The default one just marks the * container as closed, but doesn't actually mark the results as invalid. * The results will be invalidated by the next history or bookmark * notification that comes in. This means if you open and close the item * without anything happening in between, it will be fast (this actually * happens when results are used as menus). */ nsresult nsNavHistoryQueryResultNode::OpenContainer() { NS_ASSERTION(!mExpanded, "Container must be closed to open it"); mExpanded = true; nsresult rv; if (!CanExpand()) return NS_OK; if (!mContentsValid) { rv = FillChildren(); NS_ENSURE_SUCCESS(rv, rv); } rv = NotifyOnStateChange(STATE_CLOSED); NS_ENSURE_SUCCESS(rv, rv); return NS_OK; } /** * When we have valid results we can always give an exact answer. When we * don't we just assume we'll have results, since actually doing the query * might be hard. This is used to draw twisties on the tree, so precise results * don't matter. */ NS_IMETHODIMP nsNavHistoryQueryResultNode::GetHasChildren(bool* aHasChildren) { *aHasChildren = false; if (!CanExpand()) { return NS_OK; } uint16_t resultType = mOptions->ResultType(); // Tags are always populated, otherwise they are removed. if (resultType == nsINavHistoryQueryOptions::RESULTS_AS_TAG_CONTENTS) { *aHasChildren = true; return NS_OK; } // For tag containers query we must check if we have any tag if (resultType == nsINavHistoryQueryOptions::RESULTS_AS_TAG_QUERY) { nsCOMPtr<nsITaggingService> tagging = do_GetService(NS_TAGGINGSERVICE_CONTRACTID); if (tagging) { bool hasTags; *aHasChildren = NS_SUCCEEDED(tagging->GetHasTags(&hasTags)) && hasTags; } return NS_OK; } // For history containers query we must check if we have any history if (resultType == nsINavHistoryQueryOptions::RESULTS_AS_DATE_QUERY || resultType == nsINavHistoryQueryOptions::RESULTS_AS_DATE_SITE_QUERY || resultType == nsINavHistoryQueryOptions::RESULTS_AS_SITE_QUERY) { nsNavHistory* history = nsNavHistory::GetHistoryService(); NS_ENSURE_TRUE(history, NS_ERROR_OUT_OF_MEMORY); return history->GetHasHistoryEntries(aHasChildren); } //XXX: For other containers queries we must: // 1. If it's open, just check mChildren for containers // 2. Else null the view (keep it in a var), open container, check mChildren // for containers, close container, reset the view if (mContentsValid) { *aHasChildren = (mChildren.Count() > 0); return NS_OK; } *aHasChildren = true; return NS_OK; } /** * This doesn't just return mURI because in the case of queries that may * be lazily constructed from the query objects. */ NS_IMETHODIMP nsNavHistoryQueryResultNode::GetUri(nsACString& aURI) { nsresult rv = VerifyQueriesSerialized(); NS_ENSURE_SUCCESS(rv, rv); aURI = mURI; return NS_OK; } NS_IMETHODIMP nsNavHistoryQueryResultNode::GetFolderItemId(int64_t* aItemId) { *aItemId = -1; return NS_OK; } NS_IMETHODIMP nsNavHistoryQueryResultNode::GetTargetFolderGuid(nsACString& aGuid) { aGuid = EmptyCString(); return NS_OK; } NS_IMETHODIMP nsNavHistoryQueryResultNode::GetQueries(uint32_t* queryCount, nsINavHistoryQuery*** queries) { nsresult rv = VerifyQueriesParsed(); NS_ENSURE_SUCCESS(rv, rv); NS_ASSERTION(mQueries.Count() > 0, "Must have >= 1 query"); *queries = static_cast<nsINavHistoryQuery**> (moz_xmalloc(mQueries.Count() * sizeof(nsINavHistoryQuery*))); NS_ENSURE_TRUE(*queries, NS_ERROR_OUT_OF_MEMORY); for (int32_t i = 0; i < mQueries.Count(); ++i) NS_ADDREF((*queries)[i] = mQueries[i]); *queryCount = mQueries.Count(); return NS_OK; } NS_IMETHODIMP nsNavHistoryQueryResultNode::GetQueryOptions( nsINavHistoryQueryOptions** aQueryOptions) { *aQueryOptions = Options(); NS_ADDREF(*aQueryOptions); return NS_OK; } /** * Safe options getter, ensures queries are parsed first. */ nsNavHistoryQueryOptions* nsNavHistoryQueryResultNode::Options() { nsresult rv = VerifyQueriesParsed(); if (NS_FAILED(rv)) return nullptr; NS_ASSERTION(mOptions, "Options invalid, cannot generate from URI"); return mOptions; } nsresult nsNavHistoryQueryResultNode::VerifyQueriesParsed() { if (mQueries.Count() > 0) { NS_ASSERTION(mOptions, "If a result has queries, it also needs options"); return NS_OK; } NS_ASSERTION(!mURI.IsEmpty(), "Query nodes must have either a URI or query/options"); nsNavHistory* history = nsNavHistory::GetHistoryService(); NS_ENSURE_TRUE(history, NS_ERROR_OUT_OF_MEMORY); nsresult rv = history->QueryStringToQueryArray(mURI, &mQueries, getter_AddRefs(mOptions)); NS_ENSURE_SUCCESS(rv, rv); mLiveUpdate = history->GetUpdateRequirements(mQueries, mOptions, &mHasSearchTerms); return NS_OK; } nsresult nsNavHistoryQueryResultNode::VerifyQueriesSerialized() { if (!mURI.IsEmpty()) { return NS_OK; } NS_ASSERTION(mQueries.Count() > 0 && mOptions, "Query nodes must have either a URI or query/options"); nsTArray<nsINavHistoryQuery*> flatQueries; flatQueries.SetCapacity(mQueries.Count()); for (int32_t i = 0; i < mQueries.Count(); ++i) flatQueries.AppendElement(static_cast<nsINavHistoryQuery*> (mQueries.ObjectAt(i))); nsNavHistory* history = nsNavHistory::GetHistoryService(); NS_ENSURE_TRUE(history, NS_ERROR_OUT_OF_MEMORY); nsresult rv = history->QueriesToQueryString(flatQueries.Elements(), flatQueries.Length(), mOptions, mURI); NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_STATE(!mURI.IsEmpty()); return NS_OK; } nsresult nsNavHistoryQueryResultNode::FillChildren() { NS_ASSERTION(!mContentsValid, "Don't call FillChildren when contents are valid"); NS_ASSERTION(mChildren.Count() == 0, "We are trying to fill children when there already are some"); nsNavHistory* history = nsNavHistory::GetHistoryService(); NS_ENSURE_TRUE(history, NS_ERROR_OUT_OF_MEMORY); // get the results from the history service nsresult rv = VerifyQueriesParsed(); NS_ENSURE_SUCCESS(rv, rv); rv = history->GetQueryResults(this, mQueries, mOptions, &mChildren); NS_ENSURE_SUCCESS(rv, rv); // it is important to call FillStats to fill in the parents on all // nodes and the result node pointers on the containers FillStats(); uint16_t sortType = GetSortType(); if (mResult && mResult->mNeedsToApplySortingMode) { // We should repopulate container and then apply sortingMode. To avoid // sorting 2 times we simply do that here. mResult->SetSortingMode(mResult->mSortingMode); } else if (mOptions->QueryType() != nsINavHistoryQueryOptions::QUERY_TYPE_HISTORY || sortType != nsINavHistoryQueryOptions::SORT_BY_NONE) { // The default SORT_BY_NONE sorts by the bookmark index (position), // which we do not have for history queries. // Once we've computed all tree stats, we can sort, because containers will // then have proper visit counts and dates. SortComparator comparator = GetSortingComparator(GetSortType()); if (comparator) { nsAutoCString sortingAnnotation; GetSortingAnnotation(sortingAnnotation); // Usually containers queries results comes already sorted from the // database, but some locales could have special rules to sort by title. // RecursiveSort won't apply these rules to containers in containers // queries because when setting sortingMode on the result we want to sort // contained items (bug 473157). // Base container RecursiveSort will sort both our children and all // descendants, and is used in this case because we have to do manual // title sorting. // Query RecursiveSort will instead only sort descendants if we are a // constinaersQuery, e.g. a grouped query that will return other queries. // For other type of queries it will act as the base one. if (IsContainersQuery() && sortType == mOptions->SortingMode() && (sortType == nsINavHistoryQueryOptions::SORT_BY_TITLE_ASCENDING || sortType == nsINavHistoryQueryOptions::SORT_BY_TITLE_DESCENDING)) nsNavHistoryContainerResultNode::RecursiveSort(sortingAnnotation.get(), comparator); else RecursiveSort(sortingAnnotation.get(), comparator); } } // if we are limiting our results remove items from the end of the // mChildren array after sorting. This is done for root node only. // note, if count < max results, we won't do anything. if (!mParent && mOptions->MaxResults()) { while ((uint32_t)mChildren.Count() > mOptions->MaxResults()) mChildren.RemoveObjectAt(mChildren.Count() - 1); } nsNavHistoryResult* result = GetResult(); NS_ENSURE_STATE(result); if (mOptions->QueryType() == nsINavHistoryQueryOptions::QUERY_TYPE_HISTORY || mOptions->QueryType() == nsINavHistoryQueryOptions::QUERY_TYPE_UNIFIED) { // Date containers that contain site containers have no reason to observe // history, if the inside site container is expanded it will update, // otherwise we are going to refresh the parent query. if (!mParent || mParent->mOptions->ResultType() != nsINavHistoryQueryOptions::RESULTS_AS_DATE_SITE_QUERY) { // register with the result for history updates result->AddHistoryObserver(this); } } if (mOptions->QueryType() == nsINavHistoryQueryOptions::QUERY_TYPE_BOOKMARKS || mOptions->QueryType() == nsINavHistoryQueryOptions::QUERY_TYPE_UNIFIED || mLiveUpdate == QUERYUPDATE_COMPLEX_WITH_BOOKMARKS || mHasSearchTerms) { // register with the result for bookmark updates result->AddAllBookmarksObserver(this); } mContentsValid = true; return NS_OK; } /** * Call with unregister = false when we are going to update the children (for * example, when the container is open). This will clear the list and notify * all the children that they are going away. * * When the results are becoming invalid and we are not going to refresh them, * set unregister = true, which will unregister the listener from the * result if any. We use unregister = false when we are refreshing the list * immediately so want to stay a notifier. */ void nsNavHistoryQueryResultNode::ClearChildren(bool aUnregister) { for (int32_t i = 0; i < mChildren.Count(); ++i) mChildren[i]->OnRemoving(); mChildren.Clear(); if (aUnregister && mContentsValid) { nsNavHistoryResult* result = GetResult(); if (result) { result->RemoveHistoryObserver(this); result->RemoveAllBookmarksObserver(this); } } mContentsValid = false; } /** * This is called to update the result when something has changed that we * can not incrementally update. */ nsresult nsNavHistoryQueryResultNode::Refresh() { nsNavHistoryResult* result = GetResult(); NS_ENSURE_STATE(result); if (result->mBatchInProgress) { result->requestRefresh(this); return NS_OK; } // This is not a root node but it does not have a parent - this means that // the node has already been cleared and it is now called, because it was // left in a local copy of the observers array. if (mIndentLevel > -1 && !mParent) return NS_OK; // Do not refresh if we are not expanded or if we are child of a query // containing other queries. In this case calling Refresh for each child // query could cause a major slowdown. We should not refresh nested // queries, since we will already refresh the parent one. if (!mExpanded || (mParent && mParent->IsQuery() && mParent->GetAsQuery()->IsContainersQuery())) { // Don't update, just invalidate and unhook ClearChildren(true); return NS_OK; // no updates in tree state } if (mLiveUpdate == QUERYUPDATE_COMPLEX_WITH_BOOKMARKS) ClearChildren(true); else ClearChildren(false); // Ignore errors from FillChildren, since we will still want to refresh // the tree (there just might not be anything in it on error). (void)FillChildren(); NOTIFY_RESULT_OBSERVERS(result, InvalidateContainer(TO_CONTAINER(this))); return NS_OK; } /** * Here, we override GetSortType to return the current sorting for this * query. GetSortType is used when dynamically inserting query results so we * can see which comparator we should use to find the proper insertion point * (it shouldn't be called from folder containers which maintain their own * sorting). * * Normally, the container just forwards it up the chain. This is what we want * for host groups, for example. For queries, we often want to use the query's * sorting mode. * * However, we only use this query node's sorting when it is not the root. * When it is the root, we use the result's sorting mode. This is because * there are two cases: * - You are looking at a bookmark hierarchy that contains an embedded * result. We should always use the query's sort ordering since the result * node's headers have nothing to do with us (and are disabled). * - You are looking at a query in the tree. In this case, we want the * result sorting to override ours (it should be initialized to the same * sorting mode). */ uint16_t nsNavHistoryQueryResultNode::GetSortType() { if (mParent) return mOptions->SortingMode(); if (mResult) return mResult->mSortingMode; // This is a detached container, just use natural order. return nsINavHistoryQueryOptions::SORT_BY_NONE; } void nsNavHistoryQueryResultNode::GetSortingAnnotation(nsACString& aAnnotation) { if (mParent) { // use our sorting, we are not the root mOptions->GetSortingAnnotation(aAnnotation); } else if (mResult) { aAnnotation.Assign(mResult->mSortingAnnotation); } } void nsNavHistoryQueryResultNode::RecursiveSort( const char* aData, SortComparator aComparator) { void* data = const_cast<void*>(static_cast<const void*>(aData)); if (!IsContainersQuery()) mChildren.Sort(aComparator, data); for (int32_t i = 0; i < mChildren.Count(); ++i) { if (mChildren[i]->IsContainer()) mChildren[i]->GetAsContainer()->RecursiveSort(aData, aComparator); } } NS_IMETHODIMP nsNavHistoryQueryResultNode::GetSkipTags(bool *aSkipTags) { *aSkipTags = false; return NS_OK; } NS_IMETHODIMP nsNavHistoryQueryResultNode::GetSkipDescendantsOnItemRemoval(bool *aSkipDescendantsOnItemRemoval) { *aSkipDescendantsOnItemRemoval = false; return NS_OK; } NS_IMETHODIMP nsNavHistoryQueryResultNode::OnBeginUpdateBatch() { return NS_OK; } NS_IMETHODIMP nsNavHistoryQueryResultNode::OnEndUpdateBatch() { // If the query has no children it's possible it's not yet listening to // bookmarks changes, in such a case it's safer to force a refresh to gather // eventual new nodes matching query options. if (mChildren.Count() == 0) { nsresult rv = Refresh(); NS_ENSURE_SUCCESS(rv, rv); } mBatchChanges = 0; return NS_OK; } static nsresult setHistoryDetailsCallback(nsNavHistoryResultNode* aNode, const void* aClosure, const nsNavHistoryResult* aResult) { const nsNavHistoryResultNode* updatedNode = static_cast<const nsNavHistoryResultNode*>(aClosure); aNode->mAccessCount = updatedNode->mAccessCount; aNode->mTime = updatedNode->mTime; aNode->mFrecency = updatedNode->mFrecency; aNode->mHidden = updatedNode->mHidden; return NS_OK; } /** * Here we need to update all copies of the URI we have with the new visit * count, and potentially add a new entry in our query. This is the most * common update operation and it is important that it be as efficient as * possible. */ NS_IMETHODIMP nsNavHistoryQueryResultNode::OnVisit(nsIURI* aURI, int64_t aVisitId, PRTime aTime, int64_t aSessionId, int64_t aReferringId, uint32_t aTransitionType, const nsACString& aGUID, bool aHidden, uint32_t* aAdded) { if (aHidden && !mOptions->IncludeHidden()) return NS_OK; nsNavHistoryResult* result = GetResult(); NS_ENSURE_STATE(result); if (result->mBatchInProgress && ++mBatchChanges > MAX_BATCH_CHANGES_BEFORE_REFRESH) { nsresult rv = Refresh(); NS_ENSURE_SUCCESS(rv, rv); return NS_OK; } nsNavHistory* history = nsNavHistory::GetHistoryService(); NS_ENSURE_TRUE(history, NS_ERROR_OUT_OF_MEMORY); switch(mLiveUpdate) { case QUERYUPDATE_HOST: { // For these simple yet common cases we can check the host ourselves // before doing the overhead of creating a new result node. MOZ_ASSERT(mQueries.Count() == 1, "Host updated queries can have only one object"); RefPtr<nsNavHistoryQuery> query = do_QueryObject(mQueries[0]); bool hasDomain; query->GetHasDomain(&hasDomain); if (!hasDomain) return NS_OK; nsAutoCString host; if (NS_FAILED(aURI->GetAsciiHost(host))) return NS_OK; if (!query->Domain().Equals(host)) return NS_OK; // Fall through to check the time, if the time is not present it will // still match. MOZ_FALLTHROUGH; } case QUERYUPDATE_TIME: { // For these simple yet common cases we can check the time ourselves // before doing the overhead of creating a new result node. MOZ_ASSERT(mQueries.Count() == 1, "Time updated queries can have only one object"); RefPtr<nsNavHistoryQuery> query = do_QueryObject(mQueries[0]); bool hasIt; query->GetHasBeginTime(&hasIt); if (hasIt) { PRTime beginTime = history->NormalizeTime(query->BeginTimeReference(), query->BeginTime()); if (aTime < beginTime) return NS_OK; // before our time range } query->GetHasEndTime(&hasIt); if (hasIt) { PRTime endTime = history->NormalizeTime(query->EndTimeReference(), query->EndTime()); if (aTime > endTime) return NS_OK; // after our time range } // Now we know that our visit satisfies the time range, fall through to // the QUERYUPDATE_SIMPLE case below. MOZ_FALLTHROUGH; } case QUERYUPDATE_SIMPLE: { // If all of the queries are filtered by some transitions, skip the // update if aTransitionType doesn't match any of them. if (mTransitions.Length() > 0 && !mTransitions.Contains(aTransitionType)) return NS_OK; // The history service can tell us whether the new item should appear // in the result. We first have to construct a node for it to check. RefPtr<nsNavHistoryResultNode> addition; nsresult rv = history->VisitIdToResultNode(aVisitId, mOptions, getter_AddRefs(addition)); NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_STATE(addition); addition->mTransitionType = aTransitionType; if (!history->EvaluateQueryForNode(mQueries, mOptions, addition)) return NS_OK; // don't need to include in our query if (mOptions->ResultType() == nsNavHistoryQueryOptions::RESULTS_AS_VISIT) { // If this is a visit type query, just insert the new visit. We never // update visits, only add or remove them. rv = InsertSortedChild(addition); NS_ENSURE_SUCCESS(rv, rv); } else { uint16_t sortType = GetSortType(); bool updateSorting = sortType == nsINavHistoryQueryOptions::SORT_BY_VISITCOUNT_ASCENDING || sortType == nsINavHistoryQueryOptions::SORT_BY_VISITCOUNT_DESCENDING || sortType == nsINavHistoryQueryOptions::SORT_BY_DATE_ASCENDING || sortType == nsINavHistoryQueryOptions::SORT_BY_DATE_DESCENDING || sortType == nsINavHistoryQueryOptions::SORT_BY_FRECENCY_ASCENDING || sortType == nsINavHistoryQueryOptions::SORT_BY_FRECENCY_DESCENDING; if (!UpdateURIs(false, true, updateSorting, addition->mURI, setHistoryDetailsCallback, const_cast<void*>(static_cast<void*>(addition.get())))) { // Couldn't find a node to update. rv = InsertSortedChild(addition); NS_ENSURE_SUCCESS(rv, rv); } } if (aAdded) ++(*aAdded); break; } case QUERYUPDATE_COMPLEX: case QUERYUPDATE_COMPLEX_WITH_BOOKMARKS: // need to requery in complex cases return Refresh(); default: MOZ_ASSERT(false, "Invalid value for mLiveUpdate"); return Refresh(); } return NS_OK; } /** * Find every node that matches this URI and rename it. We try to do * incremental updates here, even when we are closed, because changing titles * is easier than requerying if we are invalid. * * This actually gets called a lot. Typically, we will get an AddURI message * when the user visits the page, and then the title will be set asynchronously * when the title element of the page is parsed. */ NS_IMETHODIMP nsNavHistoryQueryResultNode::OnTitleChanged(nsIURI* aURI, const nsAString& aPageTitle, const nsACString& aGUID) { if (!mExpanded) { // When we are not expanded, we don't update, just invalidate and unhook. // It would still be pretty easy to traverse the results and update the // titles, but when a title changes, its unlikely that it will be the only // thing. Therefore, we just give up. ClearChildren(true); return NS_OK; // no updates in tree state } nsNavHistoryResult* result = GetResult(); NS_ENSURE_STATE(result); if (result->mBatchInProgress && ++mBatchChanges > MAX_BATCH_CHANGES_BEFORE_REFRESH) { nsresult rv = Refresh(); NS_ENSURE_SUCCESS(rv, rv); return NS_OK; } // compute what the new title should be NS_ConvertUTF16toUTF8 newTitle(aPageTitle); bool onlyOneEntry = mOptions->ResultType() == nsINavHistoryQueryOptions::RESULTS_AS_URI || mOptions->ResultType() == nsINavHistoryQueryOptions::RESULTS_AS_TAG_CONTENTS; // See if our queries have any search term matching. if (mHasSearchTerms) { // Find all matching URI nodes. nsCOMArray<nsNavHistoryResultNode> matches; nsAutoCString spec; nsresult rv = aURI->GetSpec(spec); NS_ENSURE_SUCCESS(rv, rv); RecursiveFindURIs(onlyOneEntry, this, spec, &matches); if (matches.Count() == 0) { // This could be a new node matching the query, thus we could need // to add it to the result. RefPtr<nsNavHistoryResultNode> node; nsNavHistory* history = nsNavHistory::GetHistoryService(); NS_ENSURE_TRUE(history, NS_ERROR_OUT_OF_MEMORY); rv = history->URIToResultNode(aURI, mOptions, getter_AddRefs(node)); NS_ENSURE_SUCCESS(rv, rv); if (history->EvaluateQueryForNode(mQueries, mOptions, node)) { rv = InsertSortedChild(node); NS_ENSURE_SUCCESS(rv, rv); } } for (int32_t i = 0; i < matches.Count(); ++i) { // For each matched node we check if it passes the query filter, if not // we remove the node from the result, otherwise we'll update the title // later. nsNavHistoryResultNode* node = matches[i]; // We must check the node with the new title. node->mTitle = newTitle; nsNavHistory* history = nsNavHistory::GetHistoryService(); NS_ENSURE_TRUE(history, NS_ERROR_OUT_OF_MEMORY); if (!history->EvaluateQueryForNode(mQueries, mOptions, node)) { nsNavHistoryContainerResultNode* parent = node->mParent; // URI nodes should always have parents NS_ENSURE_TRUE(parent, NS_ERROR_UNEXPECTED); int32_t childIndex = parent->FindChild(node); NS_ASSERTION(childIndex >= 0, "Child not found in parent"); parent->RemoveChildAt(childIndex); } } } return ChangeTitles(aURI, newTitle, true, onlyOneEntry); } NS_IMETHODIMP nsNavHistoryQueryResultNode::OnFrecencyChanged(nsIURI* aURI, int32_t aNewFrecency, const nsACString& aGUID, bool aHidden, PRTime aLastVisitDate) { return NS_OK; } NS_IMETHODIMP nsNavHistoryQueryResultNode::OnManyFrecenciesChanged() { return NS_OK; } /** * Here, we can always live update by just deleting all occurrences of * the given URI. */ NS_IMETHODIMP nsNavHistoryQueryResultNode::OnDeleteURI(nsIURI* aURI, const nsACString& aGUID, uint16_t aReason) { nsNavHistoryResult* result = GetResult(); NS_ENSURE_STATE(result); if (result->mBatchInProgress && ++mBatchChanges > MAX_BATCH_CHANGES_BEFORE_REFRESH) { nsresult rv = Refresh(); NS_ENSURE_SUCCESS(rv, rv); return NS_OK; } if (IsContainersQuery()) { // Incremental updates of query returning queries are pretty much // complicated. In this case it's possible one of the child queries has // no more children and it should be removed. Unfortunately there is no // way to know that without executing the child query and counting results. nsresult rv = Refresh(); NS_ENSURE_SUCCESS(rv, rv); return NS_OK; } bool onlyOneEntry = (mOptions->ResultType() == nsINavHistoryQueryOptions::RESULTS_AS_URI || mOptions->ResultType() == nsINavHistoryQueryOptions::RESULTS_AS_TAG_CONTENTS); nsAutoCString spec; nsresult rv = aURI->GetSpec(spec); NS_ENSURE_SUCCESS(rv, rv); nsCOMArray<nsNavHistoryResultNode> matches; RecursiveFindURIs(onlyOneEntry, this, spec, &matches); for (int32_t i = 0; i < matches.Count(); ++i) { nsNavHistoryResultNode* node = matches[i]; nsNavHistoryContainerResultNode* parent = node->mParent; // URI nodes should always have parents NS_ENSURE_TRUE(parent, NS_ERROR_UNEXPECTED); int32_t childIndex = parent->FindChild(node); NS_ASSERTION(childIndex >= 0, "Child not found in parent"); parent->RemoveChildAt(childIndex); if (parent->mChildren.Count() == 0 && parent->IsQuery() && parent->mIndentLevel > -1) { // When query subcontainers (like hosts) get empty we should remove them // as well. If the parent is not the root node, append it to our list // and it will get evaluated later in the loop. matches.AppendObject(parent); } } return NS_OK; } NS_IMETHODIMP nsNavHistoryQueryResultNode::OnClearHistory() { nsresult rv = Refresh(); NS_ENSURE_SUCCESS(rv, rv); return NS_OK; } static nsresult setFaviconCallback(nsNavHistoryResultNode* aNode, const void* aClosure, const nsNavHistoryResult* aResult) { const nsCString* newFavicon = static_cast<const nsCString*>(aClosure); aNode->mFaviconURI = *newFavicon; if (aResult && (!aNode->mParent || aNode->mParent->AreChildrenVisible())) NOTIFY_RESULT_OBSERVERS(aResult, NodeIconChanged(aNode)); return NS_OK; } NS_IMETHODIMP nsNavHistoryQueryResultNode::OnPageChanged(nsIURI* aURI, uint32_t aChangedAttribute, const nsAString& aNewValue, const nsACString& aGUID) { nsAutoCString spec; nsresult rv = aURI->GetSpec(spec); NS_ENSURE_SUCCESS(rv, rv); switch (aChangedAttribute) { case nsINavHistoryObserver::ATTRIBUTE_FAVICON: { NS_ConvertUTF16toUTF8 newFavicon(aNewValue); bool onlyOneEntry = (mOptions->ResultType() == nsINavHistoryQueryOptions::RESULTS_AS_URI || mOptions->ResultType() == nsINavHistoryQueryOptions::RESULTS_AS_TAG_CONTENTS); UpdateURIs(true, onlyOneEntry, false, spec, setFaviconCallback, &newFavicon); break; } default: NS_WARNING("Unknown page changed notification"); } return NS_OK; } NS_IMETHODIMP nsNavHistoryQueryResultNode::OnDeleteVisits(nsIURI* aURI, PRTime aVisitTime, const nsACString& aGUID, uint16_t aReason, uint32_t aTransitionType) { NS_PRECONDITION(mOptions->QueryType() == nsINavHistoryQueryOptions::QUERY_TYPE_HISTORY, "Bookmarks queries should not get a OnDeleteVisits notification"); if (aVisitTime == 0) { // All visits for this uri have been removed, but the uri won't be removed // from the databse, most likely because it's a bookmark. For a history // query this is equivalent to a onDeleteURI notification. nsresult rv = OnDeleteURI(aURI, aGUID, aReason); NS_ENSURE_SUCCESS(rv, rv); } if (aTransitionType > 0) { // All visits for aTransitionType have been removed, if the query is // filtering on such transition type, this is equivalent to an onDeleteURI // notification. if (mTransitions.Length() > 0 && mTransitions.Contains(aTransitionType)) { nsresult rv = OnDeleteURI(aURI, aGUID, aReason); NS_ENSURE_SUCCESS(rv, rv); } } return NS_OK; } nsresult nsNavHistoryQueryResultNode::NotifyIfTagsChanged(nsIURI* aURI) { nsNavHistoryResult* result = GetResult(); NS_ENSURE_STATE(result); nsAutoCString spec; nsresult rv = aURI->GetSpec(spec); NS_ENSURE_SUCCESS(rv, rv); bool onlyOneEntry = (mOptions->ResultType() == nsINavHistoryQueryOptions::RESULTS_AS_URI || mOptions->ResultType() == nsINavHistoryQueryOptions::RESULTS_AS_TAG_CONTENTS ); // Find matching URI nodes. RefPtr<nsNavHistoryResultNode> node; nsNavHistory* history = nsNavHistory::GetHistoryService(); nsCOMArray<nsNavHistoryResultNode> matches; RecursiveFindURIs(onlyOneEntry, this, spec, &matches); if (matches.Count() == 0 && mHasSearchTerms) { // A new tag has been added, it's possible it matches our query. NS_ENSURE_TRUE(history, NS_ERROR_OUT_OF_MEMORY); rv = history->URIToResultNode(aURI, mOptions, getter_AddRefs(node)); NS_ENSURE_SUCCESS(rv, rv); if (history->EvaluateQueryForNode(mQueries, mOptions, node)) { rv = InsertSortedChild(node); NS_ENSURE_SUCCESS(rv, rv); } } for (int32_t i = 0; i < matches.Count(); ++i) { nsNavHistoryResultNode* node = matches[i]; // Force a tags update before checking the node. node->mTags.SetIsVoid(true); nsAutoString tags; rv = node->GetTags(tags); NS_ENSURE_SUCCESS(rv, rv); // It's possible now this node does not respect anymore the conditions. // In such a case it should be removed. if (mHasSearchTerms && !history->EvaluateQueryForNode(mQueries, mOptions, node)) { nsNavHistoryContainerResultNode* parent = node->mParent; // URI nodes should always have parents NS_ENSURE_TRUE(parent, NS_ERROR_UNEXPECTED); int32_t childIndex = parent->FindChild(node); NS_ASSERTION(childIndex >= 0, "Child not found in parent"); parent->RemoveChildAt(childIndex); } else { NOTIFY_RESULT_OBSERVERS(result, NodeTagsChanged(node)); } } return NS_OK; } /** * These are the bookmark observer functions for query nodes. They listen * for bookmark events and refresh the results if we have any dependence on * the bookmark system. */ NS_IMETHODIMP nsNavHistoryQueryResultNode::OnItemAdded(int64_t aItemId, int64_t aParentId, int32_t aIndex, uint16_t aItemType, nsIURI* aURI, const nsACString& aTitle, PRTime aDateAdded, const nsACString& aGUID, const nsACString& aParentGUID, uint16_t aSource) { if (aItemType == nsINavBookmarksService::TYPE_BOOKMARK && mLiveUpdate != QUERYUPDATE_SIMPLE && mLiveUpdate != QUERYUPDATE_TIME) { nsresult rv = Refresh(); NS_ENSURE_SUCCESS(rv, rv); } return NS_OK; } NS_IMETHODIMP nsNavHistoryQueryResultNode::OnItemRemoved(int64_t aItemId, int64_t aParentId, int32_t aIndex, uint16_t aItemType, nsIURI* aURI, const nsACString& aGUID, const nsACString& aParentGUID, uint16_t aSource) { if (aItemType == nsINavBookmarksService::TYPE_BOOKMARK && mLiveUpdate != QUERYUPDATE_SIMPLE && mLiveUpdate != QUERYUPDATE_TIME) { nsresult rv = Refresh(); NS_ENSURE_SUCCESS(rv, rv); } return NS_OK; } NS_IMETHODIMP nsNavHistoryQueryResultNode::OnItemChanged(int64_t aItemId, const nsACString& aProperty, bool aIsAnnotationProperty, const nsACString& aNewValue, PRTime aLastModified, uint16_t aItemType, int64_t aParentId, const nsACString& aGUID, const nsACString& aParentGUID, const nsACString& aOldValue, uint16_t aSource) { // History observers should not get OnItemChanged // but should get the corresponding history notifications instead. // For bookmark queries, "all bookmark" observers should get OnItemChanged. // For example, when a title of a bookmark changes, we want that to refresh. if (mLiveUpdate == QUERYUPDATE_COMPLEX_WITH_BOOKMARKS) { switch (aItemType) { case nsINavBookmarksService::TYPE_SEPARATOR: // No separators in queries. return NS_OK; case nsINavBookmarksService::TYPE_FOLDER: // Queries never result as "folders", but the tags-query results as // special "tag" containers, which should follow their corresponding // folders titles. if (mOptions->ResultType() != nsINavHistoryQueryOptions::RESULTS_AS_TAG_QUERY) return NS_OK; MOZ_FALLTHROUGH; default: (void)Refresh(); } } else { // Some node could observe both bookmarks and history. But a node observing // only history should never get a bookmark notification. NS_WARNING_ASSERTION( mResult && (mResult->mIsAllBookmarksObserver || mResult->mIsBookmarkFolderObserver), "history observers should not get OnItemChanged, but should get the " "corresponding history notifications instead"); // Tags in history queries are a special case since tags are per uri and // we filter tags based on searchterms. if (aItemType == nsINavBookmarksService::TYPE_BOOKMARK && aProperty.EqualsLiteral("tags")) { nsNavBookmarks* bookmarks = nsNavBookmarks::GetBookmarksService(); NS_ENSURE_TRUE(bookmarks, NS_ERROR_OUT_OF_MEMORY); nsCOMPtr<nsIURI> uri; nsresult rv = bookmarks->GetBookmarkURI(aItemId, getter_AddRefs(uri)); NS_ENSURE_SUCCESS(rv, rv); rv = NotifyIfTagsChanged(uri); NS_ENSURE_SUCCESS(rv, rv); } } return nsNavHistoryResultNode::OnItemChanged(aItemId, aProperty, aIsAnnotationProperty, aNewValue, aLastModified, aItemType, aParentId, aGUID, aParentGUID, aOldValue, aSource); } NS_IMETHODIMP nsNavHistoryQueryResultNode::OnItemVisited(int64_t aItemId, int64_t aVisitId, PRTime aTime, uint32_t aTransitionType, nsIURI* aURI, int64_t aParentId, const nsACString& aGUID, const nsACString& aParentGUID) { // for bookmark queries, "all bookmark" observer should get OnItemVisited // but it is ignored. if (mLiveUpdate != QUERYUPDATE_COMPLEX_WITH_BOOKMARKS) NS_WARNING_ASSERTION( mResult && (mResult->mIsAllBookmarksObserver || mResult->mIsBookmarkFolderObserver), "history observers should not get OnItemVisited, but should get OnVisit " "instead"); return NS_OK; } NS_IMETHODIMP nsNavHistoryQueryResultNode::OnItemMoved(int64_t aFolder, int64_t aOldParent, int32_t aOldIndex, int64_t aNewParent, int32_t aNewIndex, uint16_t aItemType, const nsACString& aGUID, const nsACString& aOldParentGUID, const nsACString& aNewParentGUID, uint16_t aSource) { // 1. The query cannot be affected by the item's position // 2. For the time being, we cannot optimize this not to update // queries which are not restricted to some folders, due to way // sub-queries are updated (see Refresh) if (mLiveUpdate == QUERYUPDATE_COMPLEX_WITH_BOOKMARKS && aItemType != nsINavBookmarksService::TYPE_SEPARATOR && aOldParent != aNewParent) { return Refresh(); } return NS_OK; } /** * HOW DYNAMIC FOLDER UPDATING WORKS * * When you create a result, it will automatically keep itself in sync with * stuff that happens in the system. For folder nodes, this means changes to * bookmarks. * * A folder will fill its children "when necessary." This means it is being * opened or whether we need to see if it is empty for twisty drawing. It will * then register its ID with the main result object that owns it. This result * object will listen for all bookmark notifications and pass those * notifications to folder nodes that have registered for that specific folder * ID. * * When a bookmark folder is closed, it will not clear its children. Instead, * it will keep them and also stay registered as a listener. This means that * you can more quickly re-open the same folder without doing any work. This * happens a lot for menus, and bookmarks don't change very often. * * When a message comes in and the folder is open, we will do the correct * operations to keep ourselves in sync with the bookmark service. If the * folder is closed, we just clear our list to mark it as invalid and * unregister as a listener. This means we do not have to keep maintaining * an up-to-date list for the entire bookmark menu structure in every place * it is used. */ NS_IMPL_ISUPPORTS_INHERITED(nsNavHistoryFolderResultNode, nsNavHistoryContainerResultNode, nsINavHistoryQueryResultNode, mozIStorageStatementCallback) nsNavHistoryFolderResultNode::nsNavHistoryFolderResultNode( const nsACString& aTitle, nsNavHistoryQueryOptions* aOptions, int64_t aFolderId) : nsNavHistoryContainerResultNode(EmptyCString(), aTitle, EmptyCString(), nsNavHistoryResultNode::RESULT_TYPE_FOLDER, aOptions), mContentsValid(false), mTargetFolderItemId(aFolderId), mIsRegisteredFolderObserver(false) { mItemId = aFolderId; } nsNavHistoryFolderResultNode::~nsNavHistoryFolderResultNode() { if (mIsRegisteredFolderObserver && mResult) mResult->RemoveBookmarkFolderObserver(this, mTargetFolderItemId); } /** * Here we do not want to call ContainerResultNode::OnRemoving since our own * ClearChildren will do the same thing and more (unregister the observers). * The base ResultNode::OnRemoving will clear some regular node stats, so it is * OK. */ void nsNavHistoryFolderResultNode::OnRemoving() { nsNavHistoryResultNode::OnRemoving(); ClearChildren(true); mResult = nullptr; } nsresult nsNavHistoryFolderResultNode::OpenContainer() { NS_ASSERTION(!mExpanded, "Container must be expanded to close it"); nsresult rv; if (!mContentsValid) { rv = FillChildren(); NS_ENSURE_SUCCESS(rv, rv); } mExpanded = true; rv = NotifyOnStateChange(STATE_CLOSED); NS_ENSURE_SUCCESS(rv, rv); return NS_OK; } /** * The async version of OpenContainer. */ nsresult nsNavHistoryFolderResultNode::OpenContainerAsync() { NS_ASSERTION(!mExpanded, "Container already expanded when opening it"); // If the children are valid, open the container synchronously. This will be // the case when the container has already been opened and any other time // FillChildren or FillChildrenAsync has previously been called. if (mContentsValid) return OpenContainer(); nsresult rv = FillChildrenAsync(); NS_ENSURE_SUCCESS(rv, rv); rv = NotifyOnStateChange(STATE_CLOSED); NS_ENSURE_SUCCESS(rv, rv); return NS_OK; } /** * @see nsNavHistoryQueryResultNode::HasChildren. The semantics here are a * little different. Querying the contents of a bookmark folder is relatively * fast and it is common to have empty folders. Therefore, we always want to * return the correct result so that twisties are drawn properly. */ NS_IMETHODIMP nsNavHistoryFolderResultNode::GetHasChildren(bool* aHasChildren) { if (!mContentsValid) { nsresult rv = FillChildren(); NS_ENSURE_SUCCESS(rv, rv); } *aHasChildren = (mChildren.Count() > 0); return NS_OK; } NS_IMETHODIMP nsNavHistoryFolderResultNode::GetFolderItemId(int64_t* aItemId) { *aItemId = mTargetFolderItemId; return NS_OK; } NS_IMETHODIMP nsNavHistoryFolderResultNode::GetTargetFolderGuid(nsACString& aGuid) { aGuid = mTargetFolderGuid; return NS_OK; } /** * Lazily computes the URI for this specific folder query with the current * options. */ NS_IMETHODIMP nsNavHistoryFolderResultNode::GetUri(nsACString& aURI) { if (!mURI.IsEmpty()) { aURI = mURI; return NS_OK; } uint32_t queryCount; nsINavHistoryQuery** queries; nsresult rv = GetQueries(&queryCount, &queries); NS_ENSURE_SUCCESS(rv, rv); nsNavHistory* history = nsNavHistory::GetHistoryService(); NS_ENSURE_TRUE(history, NS_ERROR_OUT_OF_MEMORY); rv = history->QueriesToQueryString(queries, queryCount, mOptions, aURI); for (uint32_t queryIndex = 0; queryIndex < queryCount; ++queryIndex) { NS_RELEASE(queries[queryIndex]); } free(queries); return rv; } /** * @return the queries that give you this bookmarks folder */ NS_IMETHODIMP nsNavHistoryFolderResultNode::GetQueries(uint32_t* queryCount, nsINavHistoryQuery*** queries) { // get the query object nsCOMPtr<nsINavHistoryQuery> query; nsNavHistory* history = nsNavHistory::GetHistoryService(); NS_ENSURE_TRUE(history, NS_ERROR_OUT_OF_MEMORY); nsresult rv = history->GetNewQuery(getter_AddRefs(query)); NS_ENSURE_SUCCESS(rv, rv); // query just has the folder ID set and nothing else rv = query->SetFolders(&mTargetFolderItemId, 1); NS_ENSURE_SUCCESS(rv, rv); // make array of our 1 query *queries = static_cast<nsINavHistoryQuery**> (moz_xmalloc(sizeof(nsINavHistoryQuery*))); if (!*queries) return NS_ERROR_OUT_OF_MEMORY; (*queries)[0] = query.forget().take(); *queryCount = 1; return NS_OK; } /** * Options for the query that gives you this bookmarks folder. This is just * the options for the folder with the current folder ID set. */ NS_IMETHODIMP nsNavHistoryFolderResultNode::GetQueryOptions( nsINavHistoryQueryOptions** aQueryOptions) { NS_ASSERTION(mOptions, "Options invalid"); *aQueryOptions = mOptions; NS_ADDREF(*aQueryOptions); return NS_OK; } nsresult nsNavHistoryFolderResultNode::FillChildren() { NS_ASSERTION(!mContentsValid, "Don't call FillChildren when contents are valid"); NS_ASSERTION(mChildren.Count() == 0, "We are trying to fill children when there already are some"); nsNavBookmarks* bookmarks = nsNavBookmarks::GetBookmarksService(); NS_ENSURE_TRUE(bookmarks, NS_ERROR_OUT_OF_MEMORY); // Actually get the folder children from the bookmark service. nsresult rv = bookmarks->QueryFolderChildren(mTargetFolderItemId, mOptions, &mChildren); NS_ENSURE_SUCCESS(rv, rv); // PERFORMANCE: it may be better to also fill any child folders at this point // so that we can draw tree twisties without doing a separate query later. // If we don't end up drawing twisties a lot, it doesn't matter. If we do // this, we should wrap everything in a transaction here on the bookmark // service's connection. return OnChildrenFilled(); } /** * Performs some tasks after all the children of the container have been added. * The container's contents are not valid until this method has been called. */ nsresult nsNavHistoryFolderResultNode::OnChildrenFilled() { // It is important to call FillStats to fill in the parents on all // nodes and the result node pointers on the containers. FillStats(); if (mResult && mResult->mNeedsToApplySortingMode) { // We should repopulate container and then apply sortingMode. To avoid // sorting 2 times we simply do that here. mResult->SetSortingMode(mResult->mSortingMode); } else { // Once we've computed all tree stats, we can sort, because containers will // then have proper visit counts and dates. SortComparator comparator = GetSortingComparator(GetSortType()); if (comparator) { nsAutoCString sortingAnnotation; GetSortingAnnotation(sortingAnnotation); RecursiveSort(sortingAnnotation.get(), comparator); } } // If we are limiting our results remove items from the end of the // mChildren array after sorting. This is done for root node only. // Note, if count < max results, we won't do anything. if (!mParent && mOptions->MaxResults()) { while ((uint32_t)mChildren.Count() > mOptions->MaxResults()) mChildren.RemoveObjectAt(mChildren.Count() - 1); } // Register with the result for updates. EnsureRegisteredAsFolderObserver(); mContentsValid = true; return NS_OK; } /** * Registers the node with its result as a folder observer if it is not already * registered. */ void nsNavHistoryFolderResultNode::EnsureRegisteredAsFolderObserver() { if (!mIsRegisteredFolderObserver && mResult) { mResult->AddBookmarkFolderObserver(this, mTargetFolderItemId); mIsRegisteredFolderObserver = true; } } /** * The async version of FillChildren. This begins asynchronous execution by * calling nsNavBookmarks::QueryFolderChildrenAsync. During execution, this * node's async Storage callbacks, HandleResult and HandleCompletion, will be * called. */ nsresult nsNavHistoryFolderResultNode::FillChildrenAsync() { NS_ASSERTION(!mContentsValid, "FillChildrenAsync when contents are valid"); NS_ASSERTION(mChildren.Count() == 0, "FillChildrenAsync when children exist"); // ProcessFolderNodeChild, called in HandleResult, increments this for every // result row it processes. Initialize it here as we begin async execution. mAsyncBookmarkIndex = -1; nsNavBookmarks* bmSvc = nsNavBookmarks::GetBookmarksService(); NS_ENSURE_TRUE(bmSvc, NS_ERROR_OUT_OF_MEMORY); nsresult rv = bmSvc->QueryFolderChildrenAsync(this, mTargetFolderItemId, getter_AddRefs(mAsyncPendingStmt)); NS_ENSURE_SUCCESS(rv, rv); // Register with the result for updates. All updates during async execution // will cause it to be restarted. EnsureRegisteredAsFolderObserver(); return NS_OK; } /** * A mozIStorageStatementCallback method. Called during the async execution * begun by FillChildrenAsync. * * @param aResultSet * The result set containing the data from the database. */ NS_IMETHODIMP nsNavHistoryFolderResultNode::HandleResult(mozIStorageResultSet* aResultSet) { NS_ENSURE_ARG_POINTER(aResultSet); nsNavBookmarks* bmSvc = nsNavBookmarks::GetBookmarksService(); if (!bmSvc) { CancelAsyncOpen(false); return NS_ERROR_OUT_OF_MEMORY; } // Consume all the currently available rows of the result set. nsCOMPtr<mozIStorageRow> row; while (NS_SUCCEEDED(aResultSet->GetNextRow(getter_AddRefs(row))) && row) { nsresult rv = bmSvc->ProcessFolderNodeRow(row, mOptions, &mChildren, mAsyncBookmarkIndex); if (NS_FAILED(rv)) { CancelAsyncOpen(false); return rv; } } return NS_OK; } /** * A mozIStorageStatementCallback method. Called during the async execution * begun by FillChildrenAsync. * * @param aReason * Indicates the final state of execution. */ NS_IMETHODIMP nsNavHistoryFolderResultNode::HandleCompletion(uint16_t aReason) { if (aReason == mozIStorageStatementCallback::REASON_FINISHED && mAsyncCanceledState == NOT_CANCELED) { // Async execution successfully completed. The container is ready to open. nsresult rv = OnChildrenFilled(); NS_ENSURE_SUCCESS(rv, rv); mExpanded = true; mAsyncPendingStmt = nullptr; // Notify observers only after mExpanded and mAsyncPendingStmt are set. rv = NotifyOnStateChange(STATE_LOADING); NS_ENSURE_SUCCESS(rv, rv); } else if (mAsyncCanceledState == CANCELED_RESTART_NEEDED) { // Async execution was canceled and needs to be restarted. mAsyncCanceledState = NOT_CANCELED; ClearChildren(false); FillChildrenAsync(); } else { // Async execution failed or was canceled without restart. Remove all // children and close the container, notifying observers. mAsyncCanceledState = NOT_CANCELED; ClearChildren(true); CloseContainer(); } return NS_OK; } void nsNavHistoryFolderResultNode::ClearChildren(bool unregister) { for (int32_t i = 0; i < mChildren.Count(); ++i) mChildren[i]->OnRemoving(); mChildren.Clear(); bool needsUnregister = unregister && (mContentsValid || mAsyncPendingStmt); if (needsUnregister && mResult && mIsRegisteredFolderObserver) { mResult->RemoveBookmarkFolderObserver(this, mTargetFolderItemId); mIsRegisteredFolderObserver = false; } mContentsValid = false; } /** * This is called to update the result when something has changed that we * can not incrementally update. */ nsresult nsNavHistoryFolderResultNode::Refresh() { nsNavHistoryResult* result = GetResult(); NS_ENSURE_STATE(result); if (result->mBatchInProgress) { result->requestRefresh(this); return NS_OK; } ClearChildren(true); if (!mExpanded) { // When we are not expanded, we don't update, just invalidate and unhook. return NS_OK; } // Ignore errors from FillChildren, since we will still want to refresh // the tree (there just might not be anything in it on error). ClearChildren // has unregistered us as an observer since FillChildren will try to // re-register us. (void)FillChildren(); NOTIFY_RESULT_OBSERVERS(result, InvalidateContainer(TO_CONTAINER(this))); return NS_OK; } /** * Implements the logic described above the constructor. This sees if we * should do an incremental update and returns true if so. If not, it * invalidates our children, unregisters us an observer, and returns false. */ bool nsNavHistoryFolderResultNode::StartIncrementalUpdate() { // if any items are excluded, we can not do incremental updates since the // indices from the bookmark service will not be valid if (!mOptions->ExcludeItems() && !mOptions->ExcludeQueries() && !mOptions->ExcludeReadOnlyFolders()) { // easy case: we are visible, always do incremental update if (mExpanded || AreChildrenVisible()) return true; nsNavHistoryResult* result = GetResult(); NS_ENSURE_TRUE(result, false); // When any observers are attached also do incremental updates if our // parent is visible, so that twisties are drawn correctly. if (mParent) return result->mObservers.Length() > 0; } // otherwise, we don't do incremental updates, invalidate and unregister (void)Refresh(); return false; } /** * This function adds aDelta to all bookmark indices between the two endpoints, * inclusive. It is used when items are added or removed from the bookmark * folder. */ void nsNavHistoryFolderResultNode::ReindexRange(int32_t aStartIndex, int32_t aEndIndex, int32_t aDelta) { for (int32_t i = 0; i < mChildren.Count(); ++i) { nsNavHistoryResultNode* node = mChildren[i]; if (node->mBookmarkIndex >= aStartIndex && node->mBookmarkIndex <= aEndIndex) node->mBookmarkIndex += aDelta; } } /** * Searches this folder for a node with the given id/target-folder-id. * * @return the node if found, null otherwise. * @note Does not addref the node! */ nsNavHistoryResultNode* nsNavHistoryFolderResultNode::FindChildById(int64_t aItemId, uint32_t* aNodeIndex) { for (int32_t i = 0; i < mChildren.Count(); ++i) { if (mChildren[i]->mItemId == aItemId || (mChildren[i]->IsFolder() && mChildren[i]->GetAsFolder()->mTargetFolderItemId == aItemId)) { *aNodeIndex = i; return mChildren[i]; } } return nullptr; } // Used by nsNavHistoryFolderResultNode's nsINavBookmarkObserver methods below. // If the container is notified of a bookmark event while asynchronous execution // is pending, this restarts it and returns. #define RESTART_AND_RETURN_IF_ASYNC_PENDING() \ if (mAsyncPendingStmt) { \ CancelAsyncOpen(true); \ return NS_OK; \ } NS_IMETHODIMP nsNavHistoryFolderResultNode::GetSkipTags(bool *aSkipTags) { *aSkipTags = false; return NS_OK; } NS_IMETHODIMP nsNavHistoryFolderResultNode::GetSkipDescendantsOnItemRemoval(bool *aSkipDescendantsOnItemRemoval) { *aSkipDescendantsOnItemRemoval = false; return NS_OK; } NS_IMETHODIMP nsNavHistoryFolderResultNode::OnBeginUpdateBatch() { return NS_OK; } NS_IMETHODIMP nsNavHistoryFolderResultNode::OnEndUpdateBatch() { return NS_OK; } NS_IMETHODIMP nsNavHistoryFolderResultNode::OnItemAdded(int64_t aItemId, int64_t aParentFolder, int32_t aIndex, uint16_t aItemType, nsIURI* aURI, const nsACString& aTitle, PRTime aDateAdded, const nsACString& aGUID, const nsACString& aParentGUID, uint16_t aSource) { MOZ_ASSERT(aParentFolder == mTargetFolderItemId, "Got wrong bookmark update"); RESTART_AND_RETURN_IF_ASYNC_PENDING(); { uint32_t index; nsNavHistoryResultNode* node = FindChildById(aItemId, &index); // Bug 1097528. // It's possible our result registered due to a previous notification, for // example the Library left pane could have refreshed and replaced the // right pane as a consequence. In such a case our contents are already // up-to-date. That's OK. if (node) return NS_OK; } bool excludeItems = (mResult && mResult->mRootNode->mOptions->ExcludeItems()) || (mParent && mParent->mOptions->ExcludeItems()) || mOptions->ExcludeItems(); // here, try to do something reasonable if the bookmark service gives us // a bogus index. if (aIndex < 0) { NS_NOTREACHED("Invalid index for item adding: <0"); aIndex = 0; } else if (aIndex > mChildren.Count()) { if (!excludeItems) { // Something wrong happened while updating indexes. NS_NOTREACHED("Invalid index for item adding: greater than count"); } aIndex = mChildren.Count(); } nsresult rv; // Check for query URIs, which are bookmarks, but treated as containers // in results and views. bool isQuery = false; if (aItemType == nsINavBookmarksService::TYPE_BOOKMARK) { NS_ASSERTION(aURI, "Got a null URI when we are a bookmark?!"); nsAutoCString itemURISpec; rv = aURI->GetSpec(itemURISpec); NS_ENSURE_SUCCESS(rv, rv); isQuery = IsQueryURI(itemURISpec); } if (aItemType != nsINavBookmarksService::TYPE_FOLDER && !isQuery && excludeItems) { // don't update items when we aren't displaying them, but we still need // to adjust bookmark indices to account for the insertion ReindexRange(aIndex, INT32_MAX, 1); return NS_OK; } if (!StartIncrementalUpdate()) return NS_OK; // folder was completely refreshed for us // adjust indices to account for insertion ReindexRange(aIndex, INT32_MAX, 1); RefPtr<nsNavHistoryResultNode> node; if (aItemType == nsINavBookmarksService::TYPE_BOOKMARK) { nsNavHistory* history = nsNavHistory::GetHistoryService(); NS_ENSURE_TRUE(history, NS_ERROR_OUT_OF_MEMORY); rv = history->BookmarkIdToResultNode(aItemId, mOptions, getter_AddRefs(node)); NS_ENSURE_SUCCESS(rv, rv); } else if (aItemType == nsINavBookmarksService::TYPE_FOLDER) { nsNavBookmarks* bookmarks = nsNavBookmarks::GetBookmarksService(); NS_ENSURE_TRUE(bookmarks, NS_ERROR_OUT_OF_MEMORY); rv = bookmarks->ResultNodeForContainer(aItemId, mOptions, getter_AddRefs(node)); NS_ENSURE_SUCCESS(rv, rv); } else if (aItemType == nsINavBookmarksService::TYPE_SEPARATOR) { node = new nsNavHistorySeparatorResultNode(); NS_ENSURE_TRUE(node, NS_ERROR_OUT_OF_MEMORY); node->mItemId = aItemId; node->mBookmarkGuid = aGUID; node->mDateAdded = aDateAdded; node->mLastModified = aDateAdded; } node->mBookmarkIndex = aIndex; if (aItemType == nsINavBookmarksService::TYPE_SEPARATOR || GetSortType() == nsINavHistoryQueryOptions::SORT_BY_NONE) { // insert at natural bookmarks position return InsertChildAt(node, aIndex); } // insert at sorted position return InsertSortedChild(node); } NS_IMETHODIMP nsNavHistoryFolderResultNode::OnItemRemoved(int64_t aItemId, int64_t aParentFolder, int32_t aIndex, uint16_t aItemType, nsIURI* aURI, const nsACString& aGUID, const nsACString& aParentGUID, uint16_t aSource) { // Folder shortcuts should not be notified removal of the target folder. MOZ_ASSERT_IF(mItemId != mTargetFolderItemId, aItemId != mTargetFolderItemId); // Concrete folders should not be notified their own removal. // Note aItemId may equal mItemId for recursive folder shortcuts. MOZ_ASSERT_IF(mItemId == mTargetFolderItemId, aItemId != mItemId); // In any case though, here we only care about the children removal. if (mTargetFolderItemId == aItemId || mItemId == aItemId) return NS_OK; MOZ_ASSERT(aParentFolder == mTargetFolderItemId, "Got wrong bookmark update"); RESTART_AND_RETURN_IF_ASYNC_PENDING(); // don't trust the index from the bookmark service, find it ourselves. The // sorting could be different, or the bookmark services indices and ours might // be out of sync somehow. uint32_t index; nsNavHistoryResultNode* node = FindChildById(aItemId, &index); // Bug 1097528. // It's possible our result registered due to a previous notification, for // example the Library left pane could have refreshed and replaced the // right pane as a consequence. In such a case our contents are already // up-to-date. That's OK. if (!node) { return NS_OK; } bool excludeItems = (mResult && mResult->mRootNode->mOptions->ExcludeItems()) || (mParent && mParent->mOptions->ExcludeItems()) || mOptions->ExcludeItems(); if ((node->IsURI() || node->IsSeparator()) && excludeItems) { // don't update items when we aren't displaying them, but we do need to // adjust everybody's bookmark indices to account for the removal ReindexRange(aIndex, INT32_MAX, -1); return NS_OK; } if (!StartIncrementalUpdate()) return NS_OK; // we are completely refreshed // shift all following indices down ReindexRange(aIndex + 1, INT32_MAX, -1); return RemoveChildAt(index); } NS_IMETHODIMP nsNavHistoryResultNode::OnItemChanged(int64_t aItemId, const nsACString& aProperty, bool aIsAnnotationProperty, const nsACString& aNewValue, PRTime aLastModified, uint16_t aItemType, int64_t aParentId, const nsACString& aGUID, const nsACString& aParentGUID, const nsACString& aOldValue, uint16_t aSource) { if (aItemId != mItemId) return NS_OK; mLastModified = aLastModified; nsNavHistoryResult* result = GetResult(); NS_ENSURE_STATE(result); bool shouldNotify = !mParent || mParent->AreChildrenVisible(); if (aIsAnnotationProperty) { if (shouldNotify) NOTIFY_RESULT_OBSERVERS(result, NodeAnnotationChanged(this, aProperty)); } else if (aProperty.EqualsLiteral("title")) { // XXX: what should we do if the new title is void? mTitle = aNewValue; if (shouldNotify) NOTIFY_RESULT_OBSERVERS(result, NodeTitleChanged(this, mTitle)); } else if (aProperty.EqualsLiteral("uri")) { // clear the tags string as well mTags.SetIsVoid(true); mURI = aNewValue; if (shouldNotify) NOTIFY_RESULT_OBSERVERS(result, NodeURIChanged(this, mURI)); } else if (aProperty.EqualsLiteral("favicon")) { mFaviconURI = aNewValue; if (shouldNotify) NOTIFY_RESULT_OBSERVERS(result, NodeIconChanged(this)); } else if (aProperty.EqualsLiteral("cleartime")) { mTime = 0; if (shouldNotify) { NOTIFY_RESULT_OBSERVERS(result, NodeHistoryDetailsChanged(this, 0, mAccessCount)); } } else if (aProperty.EqualsLiteral("tags")) { mTags.SetIsVoid(true); if (shouldNotify) NOTIFY_RESULT_OBSERVERS(result, NodeTagsChanged(this)); } else if (aProperty.EqualsLiteral("dateAdded")) { // aNewValue has the date as a string, but we can use aLastModified, // because it's set to the same value when dateAdded is changed. mDateAdded = aLastModified; if (shouldNotify) NOTIFY_RESULT_OBSERVERS(result, NodeDateAddedChanged(this, mDateAdded)); } else if (aProperty.EqualsLiteral("lastModified")) { if (shouldNotify) { NOTIFY_RESULT_OBSERVERS(result, NodeLastModifiedChanged(this, aLastModified)); } } else if (aProperty.EqualsLiteral("keyword")) { if (shouldNotify) NOTIFY_RESULT_OBSERVERS(result, NodeKeywordChanged(this, aNewValue)); } else NS_NOTREACHED("Unknown bookmark property changing."); if (!mParent) return NS_OK; // DO NOT OPTIMIZE THIS TO CHECK aProperty // The sorting methods fall back to each other so we need to re-sort the // result even if it's not set to sort by the given property. int32_t ourIndex = mParent->FindChild(this); NS_ASSERTION(ourIndex >= 0, "Could not find self in parent"); if (ourIndex >= 0) mParent->EnsureItemPosition(ourIndex); return NS_OK; } NS_IMETHODIMP nsNavHistoryFolderResultNode::OnItemChanged(int64_t aItemId, const nsACString& aProperty, bool aIsAnnotationProperty, const nsACString& aNewValue, PRTime aLastModified, uint16_t aItemType, int64_t aParentId, const nsACString& aGUID, const nsACString& aParentGUID, const nsACString& aOldValue, uint16_t aSource) { RESTART_AND_RETURN_IF_ASYNC_PENDING(); return nsNavHistoryResultNode::OnItemChanged(aItemId, aProperty, aIsAnnotationProperty, aNewValue, aLastModified, aItemType, aParentId, aGUID, aParentGUID, aOldValue, aSource); } /** * Updates visit count and last visit time and refreshes. */ NS_IMETHODIMP nsNavHistoryFolderResultNode::OnItemVisited(int64_t aItemId, int64_t aVisitId, PRTime aTime, uint32_t aTransitionType, nsIURI* aURI, int64_t aParentId, const nsACString& aGUID, const nsACString& aParentGUID) { bool excludeItems = (mResult && mResult->mRootNode->mOptions->ExcludeItems()) || (mParent && mParent->mOptions->ExcludeItems()) || mOptions->ExcludeItems(); if (excludeItems) return NS_OK; // don't update items when we aren't displaying them RESTART_AND_RETURN_IF_ASYNC_PENDING(); if (!StartIncrementalUpdate()) return NS_OK; uint32_t nodeIndex; nsNavHistoryResultNode* node = FindChildById(aItemId, &nodeIndex); if (!node) return NS_ERROR_FAILURE; // Update node. node->mTime = aTime; ++node->mAccessCount; // Update us. int32_t oldAccessCount = mAccessCount; ++mAccessCount; if (aTime > mTime) mTime = aTime; nsresult rv = ReverseUpdateStats(mAccessCount - oldAccessCount); NS_ENSURE_SUCCESS(rv, rv); // Update frecency for proper frecency ordering. // TODO (bug 832617): we may avoid one query here, by providing the new // frecency value in the notification. nsNavHistory* history = nsNavHistory::GetHistoryService(); NS_ENSURE_TRUE(history, NS_OK); RefPtr<nsNavHistoryResultNode> visitNode; rv = history->VisitIdToResultNode(aVisitId, mOptions, getter_AddRefs(visitNode)); NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_STATE(visitNode); node->mFrecency = visitNode->mFrecency; if (AreChildrenVisible()) { // Sorting has not changed, just redraw the row if it's visible. nsNavHistoryResult* result = GetResult(); NOTIFY_RESULT_OBSERVERS(result, NodeHistoryDetailsChanged(node, mTime, mAccessCount)); } // Update sorting if necessary. uint32_t sortType = GetSortType(); if (sortType == nsINavHistoryQueryOptions::SORT_BY_VISITCOUNT_ASCENDING || sortType == nsINavHistoryQueryOptions::SORT_BY_VISITCOUNT_DESCENDING || sortType == nsINavHistoryQueryOptions::SORT_BY_DATE_ASCENDING || sortType == nsINavHistoryQueryOptions::SORT_BY_DATE_DESCENDING || sortType == nsINavHistoryQueryOptions::SORT_BY_FRECENCY_ASCENDING || sortType == nsINavHistoryQueryOptions::SORT_BY_FRECENCY_DESCENDING) { int32_t childIndex = FindChild(node); NS_ASSERTION(childIndex >= 0, "Could not find child we just got a reference to"); if (childIndex >= 0) { EnsureItemPosition(childIndex); } } return NS_OK; } NS_IMETHODIMP nsNavHistoryFolderResultNode::OnItemMoved(int64_t aItemId, int64_t aOldParent, int32_t aOldIndex, int64_t aNewParent, int32_t aNewIndex, uint16_t aItemType, const nsACString& aGUID, const nsACString& aOldParentGUID, const nsACString& aNewParentGUID, uint16_t aSource) { NS_ASSERTION(aOldParent == mTargetFolderItemId || aNewParent == mTargetFolderItemId, "Got a bookmark message that doesn't belong to us"); RESTART_AND_RETURN_IF_ASYNC_PENDING(); uint32_t index; nsNavHistoryResultNode* node = FindChildById(aItemId, &index); // Bug 1097528. // It's possible our result registered due to a previous notification, for // example the Library left pane could have refreshed and replaced the // right pane as a consequence. In such a case our contents are already // up-to-date. That's OK. if (node && aNewParent == mTargetFolderItemId && index == static_cast<uint32_t>(aNewIndex)) return NS_OK; if (!node && aOldParent == mTargetFolderItemId) return NS_OK; bool excludeItems = (mResult && mResult->mRootNode->mOptions->ExcludeItems()) || (mParent && mParent->mOptions->ExcludeItems()) || mOptions->ExcludeItems(); if (node && excludeItems && (node->IsURI() || node->IsSeparator())) { // Don't update items when we aren't displaying them. return NS_OK; } if (!StartIncrementalUpdate()) return NS_OK; // entire container was refreshed for us if (aOldParent == aNewParent) { // getting moved within the same folder, we don't want to do a remove and // an add because that will lose your tree state. // adjust bookmark indices ReindexRange(aOldIndex + 1, INT32_MAX, -1); ReindexRange(aNewIndex, INT32_MAX, 1); MOZ_ASSERT(node, "Can't find folder that is moving!"); if (!node) { return NS_ERROR_FAILURE; } MOZ_ASSERT(index < uint32_t(mChildren.Count()), "Invalid index!"); node->mBookmarkIndex = aNewIndex; // adjust position EnsureItemPosition(index); return NS_OK; } else { // moving between two different folders, just do a remove and an add nsCOMPtr<nsIURI> itemURI; nsAutoCString itemTitle; if (aItemType == nsINavBookmarksService::TYPE_BOOKMARK) { nsNavBookmarks* bookmarks = nsNavBookmarks::GetBookmarksService(); NS_ENSURE_TRUE(bookmarks, NS_ERROR_OUT_OF_MEMORY); nsresult rv = bookmarks->GetBookmarkURI(aItemId, getter_AddRefs(itemURI)); NS_ENSURE_SUCCESS(rv, rv); rv = bookmarks->GetItemTitle(aItemId, itemTitle); NS_ENSURE_SUCCESS(rv, rv); } if (aOldParent == mTargetFolderItemId) { OnItemRemoved(aItemId, aOldParent, aOldIndex, aItemType, itemURI, aGUID, aOldParentGUID, aSource); } if (aNewParent == mTargetFolderItemId) { OnItemAdded(aItemId, aNewParent, aNewIndex, aItemType, itemURI, itemTitle, RoundedPRNow(), // This is a dummy dateAdded, not the real value. aGUID, aNewParentGUID, aSource); } } return NS_OK; } /** * Separator nodes do not hold any data. */ nsNavHistorySeparatorResultNode::nsNavHistorySeparatorResultNode() : nsNavHistoryResultNode(EmptyCString(), EmptyCString(), 0, 0, EmptyCString()) { } NS_IMPL_CYCLE_COLLECTION_CLASS(nsNavHistoryResult) NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsNavHistoryResult) tmp->StopObserving(); NS_IMPL_CYCLE_COLLECTION_UNLINK(mRootNode) NS_IMPL_CYCLE_COLLECTION_UNLINK(mObservers) for (auto it = tmp->mBookmarkFolderObservers.Iter(); !it.Done(); it.Next()) { delete it.Data(); it.Remove(); } NS_IMPL_CYCLE_COLLECTION_UNLINK(mAllBookmarksObservers) NS_IMPL_CYCLE_COLLECTION_UNLINK(mHistoryObservers) NS_IMPL_CYCLE_COLLECTION_UNLINK_END NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsNavHistoryResult) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRootNode) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mObservers) for (auto it = tmp->mBookmarkFolderObservers.Iter(); !it.Done(); it.Next()) { nsNavHistoryResult::FolderObserverList*& list = it.Data(); for (uint32_t i = 0; i < list->Length(); ++i) { NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mBookmarkFolderObservers value[i]"); nsNavHistoryResultNode* node = list->ElementAt(i); cb.NoteXPCOMChild(node); } } NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAllBookmarksObservers) NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mHistoryObservers) NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END NS_IMPL_CYCLE_COLLECTING_ADDREF(nsNavHistoryResult) NS_IMPL_CYCLE_COLLECTING_RELEASE(nsNavHistoryResult) NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsNavHistoryResult) NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsINavHistoryResult) NS_INTERFACE_MAP_STATIC_AMBIGUOUS(nsNavHistoryResult) NS_INTERFACE_MAP_ENTRY(nsINavHistoryResult) NS_INTERFACE_MAP_ENTRY(nsINavBookmarkObserver) NS_INTERFACE_MAP_ENTRY(nsINavHistoryObserver) NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference) NS_INTERFACE_MAP_END nsNavHistoryResult::nsNavHistoryResult(nsNavHistoryContainerResultNode* aRoot) : mRootNode(aRoot) , mNeedsToApplySortingMode(false) , mIsHistoryObserver(false) , mIsBookmarkFolderObserver(false) , mIsAllBookmarksObserver(false) , mBookmarkFolderObservers(64) , mBatchInProgress(false) , mSuppressNotifications(false) { mRootNode->mResult = this; } nsNavHistoryResult::~nsNavHistoryResult() { // Delete all heap-allocated bookmark folder observer arrays. for (auto it = mBookmarkFolderObservers.Iter(); !it.Done(); it.Next()) { delete it.Data(); it.Remove(); } } void nsNavHistoryResult::StopObserving() { if (mIsBookmarkFolderObserver || mIsAllBookmarksObserver) { nsNavBookmarks* bookmarks = nsNavBookmarks::GetBookmarksService(); if (bookmarks) { bookmarks->RemoveObserver(this); mIsBookmarkFolderObserver = false; mIsAllBookmarksObserver = false; } } if (mIsHistoryObserver) { nsNavHistory* history = nsNavHistory::GetHistoryService(); if (history) { history->RemoveObserver(this); mIsHistoryObserver = false; } } } /** * @note you must call AddRef before this, since we may do things like * register ourselves. */ nsresult nsNavHistoryResult::Init(nsINavHistoryQuery** aQueries, uint32_t aQueryCount, nsNavHistoryQueryOptions *aOptions) { nsresult rv; NS_ASSERTION(aOptions, "Must have valid options"); NS_ASSERTION(aQueries && aQueryCount > 0, "Must have >1 query in result"); // Fill saved source queries with copies of the original (the caller might // change their original objects, and we always want to reflect the source // parameters). for (uint32_t i = 0; i < aQueryCount; ++i) { nsCOMPtr<nsINavHistoryQuery> queryClone; rv = aQueries[i]->Clone(getter_AddRefs(queryClone)); NS_ENSURE_SUCCESS(rv, rv); if (!mQueries.AppendObject(queryClone)) return NS_ERROR_OUT_OF_MEMORY; } rv = aOptions->Clone(getter_AddRefs(mOptions)); NS_ENSURE_SUCCESS(rv, rv); mSortingMode = aOptions->SortingMode(); rv = aOptions->GetSortingAnnotation(mSortingAnnotation); NS_ENSURE_SUCCESS(rv, rv); NS_ASSERTION(mRootNode->mIndentLevel == -1, "Root node's indent level initialized wrong"); mRootNode->FillStats(); return NS_OK; } /** * Constructs a new history result object. */ nsresult // static nsNavHistoryResult::NewHistoryResult(nsINavHistoryQuery** aQueries, uint32_t aQueryCount, nsNavHistoryQueryOptions* aOptions, nsNavHistoryContainerResultNode* aRoot, bool aBatchInProgress, nsNavHistoryResult** result) { *result = new nsNavHistoryResult(aRoot); if (!*result) return NS_ERROR_OUT_OF_MEMORY; NS_ADDREF(*result); // must happen before Init // Correctly set mBatchInProgress for the result based on the root node value. (*result)->mBatchInProgress = aBatchInProgress; nsresult rv = (*result)->Init(aQueries, aQueryCount, aOptions); if (NS_FAILED(rv)) { NS_RELEASE(*result); *result = nullptr; return rv; } return NS_OK; } void nsNavHistoryResult::AddHistoryObserver(nsNavHistoryQueryResultNode* aNode) { if (!mIsHistoryObserver) { nsNavHistory* history = nsNavHistory::GetHistoryService(); NS_ASSERTION(history, "Can't create history service"); history->AddObserver(this, true); mIsHistoryObserver = true; } // Don't add duplicate observers. In some case we don't unregister when // children are cleared (see ClearChildren) and the next FillChildren call // will try to add the observer again. if (mHistoryObservers.IndexOf(aNode) == mHistoryObservers.NoIndex) { mHistoryObservers.AppendElement(aNode); } } void nsNavHistoryResult::AddAllBookmarksObserver(nsNavHistoryQueryResultNode* aNode) { if (!mIsAllBookmarksObserver && !mIsBookmarkFolderObserver) { nsNavBookmarks* bookmarks = nsNavBookmarks::GetBookmarksService(); if (!bookmarks) { NS_NOTREACHED("Can't create bookmark service"); return; } bookmarks->AddObserver(this, true); mIsAllBookmarksObserver = true; } // Don't add duplicate observers. In some case we don't unregister when // children are cleared (see ClearChildren) and the next FillChildren call // will try to add the observer again. if (mAllBookmarksObservers.IndexOf(aNode) == mAllBookmarksObservers.NoIndex) { mAllBookmarksObservers.AppendElement(aNode); } } void nsNavHistoryResult::AddBookmarkFolderObserver(nsNavHistoryFolderResultNode* aNode, int64_t aFolder) { if (!mIsBookmarkFolderObserver && !mIsAllBookmarksObserver) { nsNavBookmarks* bookmarks = nsNavBookmarks::GetBookmarksService(); if (!bookmarks) { NS_NOTREACHED("Can't create bookmark service"); return; } bookmarks->AddObserver(this, true); mIsBookmarkFolderObserver = true; } // Don't add duplicate observers. In some case we don't unregister when // children are cleared (see ClearChildren) and the next FillChildren call // will try to add the observer again. FolderObserverList* list = BookmarkFolderObserversForId(aFolder, true); if (list->IndexOf(aNode) == list->NoIndex) { list->AppendElement(aNode); } } void nsNavHistoryResult::RemoveHistoryObserver(nsNavHistoryQueryResultNode* aNode) { mHistoryObservers.RemoveElement(aNode); } void nsNavHistoryResult::RemoveAllBookmarksObserver(nsNavHistoryQueryResultNode* aNode) { mAllBookmarksObservers.RemoveElement(aNode); } void nsNavHistoryResult::RemoveBookmarkFolderObserver(nsNavHistoryFolderResultNode* aNode, int64_t aFolder) { FolderObserverList* list = BookmarkFolderObserversForId(aFolder, false); if (!list) return; // we don't even have an entry for that folder list->RemoveElement(aNode); } nsNavHistoryResult::FolderObserverList* nsNavHistoryResult::BookmarkFolderObserversForId(int64_t aFolderId, bool aCreate) { FolderObserverList* list; if (mBookmarkFolderObservers.Get(aFolderId, &list)) return list; if (!aCreate) return nullptr; // need to create a new list list = new FolderObserverList; mBookmarkFolderObservers.Put(aFolderId, list); return list; } NS_IMETHODIMP nsNavHistoryResult::GetSortingMode(uint16_t* aSortingMode) { *aSortingMode = mSortingMode; return NS_OK; } NS_IMETHODIMP nsNavHistoryResult::SetSortingMode(uint16_t aSortingMode) { NS_ENSURE_STATE(mRootNode); if (aSortingMode > nsINavHistoryQueryOptions::SORT_BY_FRECENCY_DESCENDING) return NS_ERROR_INVALID_ARG; // Keep everything in sync. NS_ASSERTION(mOptions, "Options should always be present for a root query"); mSortingMode = aSortingMode; if (!mRootNode->mExpanded) { // Need to do this later when node will be expanded. mNeedsToApplySortingMode = true; return NS_OK; } // Actually do sorting. nsNavHistoryContainerResultNode::SortComparator comparator = nsNavHistoryContainerResultNode::GetSortingComparator(aSortingMode); if (comparator) { nsNavHistory* history = nsNavHistory::GetHistoryService(); NS_ENSURE_TRUE(history, NS_ERROR_OUT_OF_MEMORY); mRootNode->RecursiveSort(mSortingAnnotation.get(), comparator); } NOTIFY_RESULT_OBSERVERS(this, SortingChanged(aSortingMode)); NOTIFY_RESULT_OBSERVERS(this, InvalidateContainer(mRootNode)); return NS_OK; } NS_IMETHODIMP nsNavHistoryResult::GetSortingAnnotation(nsACString& _result) { _result.Assign(mSortingAnnotation); return NS_OK; } NS_IMETHODIMP nsNavHistoryResult::SetSortingAnnotation(const nsACString& aSortingAnnotation) { mSortingAnnotation.Assign(aSortingAnnotation); return NS_OK; } NS_IMETHODIMP nsNavHistoryResult::AddObserver(nsINavHistoryResultObserver* aObserver, bool aOwnsWeak) { NS_ENSURE_ARG(aObserver); nsresult rv = mObservers.AppendWeakElement(aObserver, aOwnsWeak); NS_ENSURE_SUCCESS(rv, rv); rv = aObserver->SetResult(this); NS_ENSURE_SUCCESS(rv, rv); // If we are batching, notify a fake batch start to the observers. // Not doing so would then notify a not coupled batch end. if (mBatchInProgress) { NOTIFY_RESULT_OBSERVERS(this, Batching(true)); } return NS_OK; } NS_IMETHODIMP nsNavHistoryResult::RemoveObserver(nsINavHistoryResultObserver* aObserver) { NS_ENSURE_ARG(aObserver); return mObservers.RemoveWeakElement(aObserver); } NS_IMETHODIMP nsNavHistoryResult::GetSuppressNotifications(bool* _retval) { *_retval = mSuppressNotifications; return NS_OK; } NS_IMETHODIMP nsNavHistoryResult::SetSuppressNotifications(bool aSuppressNotifications) { mSuppressNotifications = aSuppressNotifications; return NS_OK; } NS_IMETHODIMP nsNavHistoryResult::GetRoot(nsINavHistoryContainerResultNode** aRoot) { if (!mRootNode) { NS_NOTREACHED("Root is null"); *aRoot = nullptr; return NS_ERROR_FAILURE; } RefPtr<nsNavHistoryContainerResultNode> node(mRootNode); node.forget(aRoot); return NS_OK; } void nsNavHistoryResult::requestRefresh(nsNavHistoryContainerResultNode* aContainer) { // Don't add twice the same container. if (mRefreshParticipants.IndexOf(aContainer) == mRefreshParticipants.NoIndex) mRefreshParticipants.AppendElement(aContainer); } // nsINavBookmarkObserver implementation // Here, it is important that we create a COPY of the observer array. Some // observers will requery themselves, which may cause the observer array to // be modified or added to. #define ENUMERATE_BOOKMARK_FOLDER_OBSERVERS(_folderId, _functionCall) \ PR_BEGIN_MACRO \ FolderObserverList* _fol = BookmarkFolderObserversForId(_folderId, false); \ if (_fol) { \ FolderObserverList _listCopy(*_fol); \ for (uint32_t _fol_i = 0; _fol_i < _listCopy.Length(); ++_fol_i) { \ if (_listCopy[_fol_i]) \ _listCopy[_fol_i]->_functionCall; \ } \ } \ PR_END_MACRO #define ENUMERATE_LIST_OBSERVERS(_listType, _functionCall, _observersList, _conditionCall) \ PR_BEGIN_MACRO \ _listType _listCopy(_observersList); \ for (uint32_t _obs_i = 0; _obs_i < _listCopy.Length(); ++_obs_i) { \ if (_listCopy[_obs_i] && _listCopy[_obs_i]->_conditionCall) \ _listCopy[_obs_i]->_functionCall; \ } \ PR_END_MACRO #define ENUMERATE_QUERY_OBSERVERS(_functionCall, _observersList, _conditionCall) \ ENUMERATE_LIST_OBSERVERS(QueryObserverList, _functionCall, _observersList, _conditionCall) #define ENUMERATE_ALL_BOOKMARKS_OBSERVERS(_functionCall) \ ENUMERATE_QUERY_OBSERVERS(_functionCall, mAllBookmarksObservers, IsQuery()) #define ENUMERATE_HISTORY_OBSERVERS(_functionCall) \ ENUMERATE_QUERY_OBSERVERS(_functionCall, mHistoryObservers, IsQuery()) #define NOTIFY_REFRESH_PARTICIPANTS() \ PR_BEGIN_MACRO \ ENUMERATE_LIST_OBSERVERS(ContainerObserverList, Refresh(), mRefreshParticipants, IsContainer()); \ mRefreshParticipants.Clear(); \ PR_END_MACRO NS_IMETHODIMP nsNavHistoryResult::GetSkipTags(bool *aSkipTags) { *aSkipTags = false; return NS_OK; } NS_IMETHODIMP nsNavHistoryResult::GetSkipDescendantsOnItemRemoval(bool *aSkipDescendantsOnItemRemoval) { *aSkipDescendantsOnItemRemoval = false; return NS_OK; } NS_IMETHODIMP nsNavHistoryResult::OnBeginUpdateBatch() { // Since we could be observing both history and bookmarks, it's possible both // notify the batch. We can safely ignore nested calls. if (!mBatchInProgress) { mBatchInProgress = true; ENUMERATE_HISTORY_OBSERVERS(OnBeginUpdateBatch()); ENUMERATE_ALL_BOOKMARKS_OBSERVERS(OnBeginUpdateBatch()); NOTIFY_RESULT_OBSERVERS(this, Batching(true)); } return NS_OK; } NS_IMETHODIMP nsNavHistoryResult::OnEndUpdateBatch() { // Since we could be observing both history and bookmarks, it's possible both // notify the batch. We can safely ignore nested calls. // Notice it's possible we are notified OnEndUpdateBatch more times than // onBeginUpdateBatch, since the result could be created in the middle of // nested batches. if (mBatchInProgress) { ENUMERATE_HISTORY_OBSERVERS(OnEndUpdateBatch()); ENUMERATE_ALL_BOOKMARKS_OBSERVERS(OnEndUpdateBatch()); // Setting mBatchInProgress before notifying the end of the batch to // observers would make evantual calls to Refresh() directly handled rather // than enqueued. Thus set it just before handling refreshes. mBatchInProgress = false; NOTIFY_REFRESH_PARTICIPANTS(); NOTIFY_RESULT_OBSERVERS(this, Batching(false)); } return NS_OK; } NS_IMETHODIMP nsNavHistoryResult::OnItemAdded(int64_t aItemId, int64_t aParentId, int32_t aIndex, uint16_t aItemType, nsIURI* aURI, const nsACString& aTitle, PRTime aDateAdded, const nsACString& aGUID, const nsACString& aParentGUID, uint16_t aSource) { NS_ENSURE_ARG(aItemType != nsINavBookmarksService::TYPE_BOOKMARK || aURI); ENUMERATE_BOOKMARK_FOLDER_OBSERVERS(aParentId, OnItemAdded(aItemId, aParentId, aIndex, aItemType, aURI, aTitle, aDateAdded, aGUID, aParentGUID, aSource) ); ENUMERATE_HISTORY_OBSERVERS( OnItemAdded(aItemId, aParentId, aIndex, aItemType, aURI, aTitle, aDateAdded, aGUID, aParentGUID, aSource) ); ENUMERATE_ALL_BOOKMARKS_OBSERVERS( OnItemAdded(aItemId, aParentId, aIndex, aItemType, aURI, aTitle, aDateAdded, aGUID, aParentGUID, aSource) ); return NS_OK; } NS_IMETHODIMP nsNavHistoryResult::OnItemRemoved(int64_t aItemId, int64_t aParentId, int32_t aIndex, uint16_t aItemType, nsIURI* aURI, const nsACString& aGUID, const nsACString& aParentGUID, uint16_t aSource) { NS_ENSURE_ARG(aItemType != nsINavBookmarksService::TYPE_BOOKMARK || aURI); ENUMERATE_BOOKMARK_FOLDER_OBSERVERS(aParentId, OnItemRemoved(aItemId, aParentId, aIndex, aItemType, aURI, aGUID, aParentGUID, aSource)); ENUMERATE_ALL_BOOKMARKS_OBSERVERS( OnItemRemoved(aItemId, aParentId, aIndex, aItemType, aURI, aGUID, aParentGUID, aSource)); ENUMERATE_HISTORY_OBSERVERS( OnItemRemoved(aItemId, aParentId, aIndex, aItemType, aURI, aGUID, aParentGUID, aSource)); return NS_OK; } NS_IMETHODIMP nsNavHistoryResult::OnItemChanged(int64_t aItemId, const nsACString &aProperty, bool aIsAnnotationProperty, const nsACString &aNewValue, PRTime aLastModified, uint16_t aItemType, int64_t aParentId, const nsACString& aGUID, const nsACString& aParentGUID, const nsACString& aOldValue, uint16_t aSource) { ENUMERATE_ALL_BOOKMARKS_OBSERVERS( OnItemChanged(aItemId, aProperty, aIsAnnotationProperty, aNewValue, aLastModified, aItemType, aParentId, aGUID, aParentGUID, aOldValue, aSource)); // Note: folder-nodes set their own bookmark observer only once they're // opened, meaning we cannot optimize this code path for changes done to // folder-nodes. FolderObserverList* list = BookmarkFolderObserversForId(aParentId, false); if (!list) return NS_OK; for (uint32_t i = 0; i < list->Length(); ++i) { RefPtr<nsNavHistoryFolderResultNode> folder = list->ElementAt(i); if (folder) { uint32_t nodeIndex; RefPtr<nsNavHistoryResultNode> node = folder->FindChildById(aItemId, &nodeIndex); // if ExcludeItems is true we don't update non visible items bool excludeItems = (mRootNode->mOptions->ExcludeItems()) || folder->mOptions->ExcludeItems(); if (node && (!excludeItems || !(node->IsURI() || node->IsSeparator())) && folder->StartIncrementalUpdate()) { node->OnItemChanged(aItemId, aProperty, aIsAnnotationProperty, aNewValue, aLastModified, aItemType, aParentId, aGUID, aParentGUID, aOldValue, aSource); } } } // Note: we do NOT call history observers in this case. This notification is // the same as other history notification, except that here we know the item // is a bookmark. History observers will handle the history notification // instead. return NS_OK; } NS_IMETHODIMP nsNavHistoryResult::OnItemVisited(int64_t aItemId, int64_t aVisitId, PRTime aVisitTime, uint32_t aTransitionType, nsIURI* aURI, int64_t aParentId, const nsACString& aGUID, const nsACString& aParentGUID) { NS_ENSURE_ARG(aURI); ENUMERATE_BOOKMARK_FOLDER_OBSERVERS(aParentId, OnItemVisited(aItemId, aVisitId, aVisitTime, aTransitionType, aURI, aParentId, aGUID, aParentGUID)); ENUMERATE_ALL_BOOKMARKS_OBSERVERS( OnItemVisited(aItemId, aVisitId, aVisitTime, aTransitionType, aURI, aParentId, aGUID, aParentGUID)); // Note: we do NOT call history observers in this case. This notification is // the same as OnVisit, except that here we know the item is a bookmark. // History observers will handle the history notification instead. return NS_OK; } /** * Need to notify both the source and the destination folders (if they are * different). */ NS_IMETHODIMP nsNavHistoryResult::OnItemMoved(int64_t aItemId, int64_t aOldParent, int32_t aOldIndex, int64_t aNewParent, int32_t aNewIndex, uint16_t aItemType, const nsACString& aGUID, const nsACString& aOldParentGUID, const nsACString& aNewParentGUID, uint16_t aSource) { ENUMERATE_BOOKMARK_FOLDER_OBSERVERS(aOldParent, OnItemMoved(aItemId, aOldParent, aOldIndex, aNewParent, aNewIndex, aItemType, aGUID, aOldParentGUID, aNewParentGUID, aSource)); if (aNewParent != aOldParent) { ENUMERATE_BOOKMARK_FOLDER_OBSERVERS(aNewParent, OnItemMoved(aItemId, aOldParent, aOldIndex, aNewParent, aNewIndex, aItemType, aGUID, aOldParentGUID, aNewParentGUID, aSource)); } ENUMERATE_ALL_BOOKMARKS_OBSERVERS(OnItemMoved(aItemId, aOldParent, aOldIndex, aNewParent, aNewIndex, aItemType, aGUID, aOldParentGUID, aNewParentGUID, aSource)); ENUMERATE_HISTORY_OBSERVERS(OnItemMoved(aItemId, aOldParent, aOldIndex, aNewParent, aNewIndex, aItemType, aGUID, aOldParentGUID, aNewParentGUID, aSource)); return NS_OK; } NS_IMETHODIMP nsNavHistoryResult::OnVisit(nsIURI* aURI, int64_t aVisitId, PRTime aTime, int64_t aSessionId, int64_t aReferringId, uint32_t aTransitionType, const nsACString& aGUID, bool aHidden, uint32_t aVisitCount, uint32_t aTyped) { NS_ENSURE_ARG(aURI); // Embed visits are never shown in our views. if (aTransitionType == nsINavHistoryService::TRANSITION_EMBED) { return NS_OK; } uint32_t added = 0; ENUMERATE_HISTORY_OBSERVERS(OnVisit(aURI, aVisitId, aTime, aSessionId, aReferringId, aTransitionType, aGUID, aHidden, &added)); if (!mRootNode->mExpanded) return NS_OK; // If this visit is accepted by an overlapped container, and not all // overlapped containers are visible, we should still call Refresh if the // visit falls into any of them. bool todayIsMissing = false; uint32_t resultType = mRootNode->mOptions->ResultType(); if (resultType == nsINavHistoryQueryOptions::RESULTS_AS_DATE_QUERY || resultType == nsINavHistoryQueryOptions::RESULTS_AS_DATE_SITE_QUERY) { uint32_t childCount; nsresult rv = mRootNode->GetChildCount(&childCount); NS_ENSURE_SUCCESS(rv, rv); if (childCount) { nsCOMPtr<nsINavHistoryResultNode> firstChild; rv = mRootNode->GetChild(0, getter_AddRefs(firstChild)); NS_ENSURE_SUCCESS(rv, rv); nsAutoCString title; rv = firstChild->GetTitle(title); NS_ENSURE_SUCCESS(rv, rv); nsNavHistory* history = nsNavHistory::GetHistoryService(); NS_ENSURE_TRUE(history, NS_OK); nsAutoCString todayLabel; history->GetStringFromName( u"finduri-AgeInDays-is-0", todayLabel); todayIsMissing = !todayLabel.Equals(title); } } if (!added || todayIsMissing) { // None of registered query observers has accepted our URI. This means, // that a matching query either was not expanded or it does not exist. uint32_t resultType = mRootNode->mOptions->ResultType(); if (resultType == nsINavHistoryQueryOptions::RESULTS_AS_DATE_QUERY || resultType == nsINavHistoryQueryOptions::RESULTS_AS_DATE_SITE_QUERY) { // If the visit falls into the Today bucket and the bucket exists, it was // just not expanded, thus there's no reason to update. int64_t beginOfToday = nsNavHistory::NormalizeTime(nsINavHistoryQuery::TIME_RELATIVE_TODAY, 0); if (todayIsMissing || aTime < beginOfToday) { (void)mRootNode->GetAsQuery()->Refresh(); } return NS_OK; } if (resultType == nsINavHistoryQueryOptions::RESULTS_AS_SITE_QUERY) { (void)mRootNode->GetAsQuery()->Refresh(); return NS_OK; } // We are result of a folder node, then we should run through history // observers that are containers queries and refresh them. // We use a copy of the observers array since requerying could potentially // cause changes to the array. ENUMERATE_QUERY_OBSERVERS(Refresh(), mHistoryObservers, IsContainersQuery()); } return NS_OK; } NS_IMETHODIMP nsNavHistoryResult::OnTitleChanged(nsIURI* aURI, const nsAString& aPageTitle, const nsACString& aGUID) { NS_ENSURE_ARG(aURI); ENUMERATE_HISTORY_OBSERVERS(OnTitleChanged(aURI, aPageTitle, aGUID)); return NS_OK; } NS_IMETHODIMP nsNavHistoryResult::OnFrecencyChanged(nsIURI* aURI, int32_t aNewFrecency, const nsACString& aGUID, bool aHidden, PRTime aLastVisitDate) { return NS_OK; } NS_IMETHODIMP nsNavHistoryResult::OnManyFrecenciesChanged() { return NS_OK; } NS_IMETHODIMP nsNavHistoryResult::OnDeleteURI(nsIURI *aURI, const nsACString& aGUID, uint16_t aReason) { NS_ENSURE_ARG(aURI); ENUMERATE_HISTORY_OBSERVERS(OnDeleteURI(aURI, aGUID, aReason)); return NS_OK; } NS_IMETHODIMP nsNavHistoryResult::OnClearHistory() { ENUMERATE_HISTORY_OBSERVERS(OnClearHistory()); return NS_OK; } NS_IMETHODIMP nsNavHistoryResult::OnPageChanged(nsIURI* aURI, uint32_t aChangedAttribute, const nsAString& aValue, const nsACString& aGUID) { NS_ENSURE_ARG(aURI); ENUMERATE_HISTORY_OBSERVERS(OnPageChanged(aURI, aChangedAttribute, aValue, aGUID)); return NS_OK; } /** * Don't do anything when visits expire. */ NS_IMETHODIMP nsNavHistoryResult::OnDeleteVisits(nsIURI* aURI, PRTime aVisitTime, const nsACString& aGUID, uint16_t aReason, uint32_t aTransitionType) { NS_ENSURE_ARG(aURI); ENUMERATE_HISTORY_OBSERVERS(OnDeleteVisits(aURI, aVisitTime, aGUID, aReason, aTransitionType)); return NS_OK; }