mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
8ddefeed54
Calling QueryInterface with a statically known IID should typically not be necessary. In those cases where it's not, the compiler can do the cast for us, though we have to supply the reference-counting that QueryInterface would do. In passing, several redundant null-checks for the result of |new T| have been deleted.
4720 lines
157 KiB
C++
4720 lines
157 KiB
C++
//* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include <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 "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),
|
|
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
|
|
nsRefPtr<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 = :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;
|
|
}
|
|
|
|
|
|
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)))
|
|
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)))
|
|
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;
|
|
|
|
nsRefPtr<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.
|
|
nsRefPtr<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**>
|
|
(nsMemory::Alloc(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::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");
|
|
nsRefPtr<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.
|
|
}
|
|
|
|
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");
|
|
nsRefPtr<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, fallback to the
|
|
// QUERYUPDATE_SIMPLE case.
|
|
}
|
|
|
|
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.
|
|
nsRefPtr<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.
|
|
nsRefPtr<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.
|
|
nsRefPtr<nsNavHistoryResultNode> node;
|
|
nsNavHistory* history = nsNavHistory::GetHistoryService();
|
|
|
|
nsCOMArray<nsNavHistoryResultNode> matches;
|
|
RecursiveFindURIs(onlyOneEntry, this, spec, &matches);
|
|
|
|
if (matches.Count() == 0 && mHasSearchTerms && !mRemovingURI) {
|
|
// 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)
|
|
{
|
|
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)
|
|
{
|
|
mRemovingURI = aURI;
|
|
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)
|
|
{
|
|
// 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;
|
|
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_WARN_IF_FALSE(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);
|
|
}
|
|
|
|
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_WARN_IF_FALSE(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)
|
|
{
|
|
// 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)
|
|
|
|
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]);
|
|
}
|
|
nsMemory::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**>
|
|
(nsMemory::Alloc(sizeof(nsINavHistoryQuery*)));
|
|
if (!*queries)
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
NS_ADDREF((*queries)[0] = query);
|
|
*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::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)
|
|
{
|
|
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);
|
|
|
|
nsRefPtr<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)
|
|
{
|
|
// If this folder is a folder shortcut, we should never be notified for the
|
|
// removal of the shortcut (the parent node would be).
|
|
MOZ_ASSERT(mItemId == mTargetFolderItemId || aItemId != mItemId);
|
|
|
|
// In any case though, here we only care about the children removal.
|
|
if (mTargetFolderItemId == 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)
|
|
{
|
|
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)
|
|
{
|
|
RESTART_AND_RETURN_IF_ASYNC_PENDING();
|
|
|
|
return nsNavHistoryResultNode::OnItemChanged(aItemId, aProperty,
|
|
aIsAnnotationProperty,
|
|
aNewValue, aLastModified,
|
|
aItemType, aParentId, aGUID,
|
|
aParentGUID);
|
|
}
|
|
|
|
/**
|
|
* 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);
|
|
nsRefPtr<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)
|
|
{
|
|
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);
|
|
}
|
|
if (aNewParent == mTargetFolderItemId) {
|
|
OnItemAdded(aItemId, aNewParent, aNewIndex, aItemType, itemURI, itemTitle,
|
|
RoundedPRNow(), // This is a dummy dateAdded, not the real value.
|
|
aGUID, aNewParentGUID);
|
|
}
|
|
}
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
/**
|
|
* Separator nodes do not hold any data.
|
|
*/
|
|
nsNavHistorySeparatorResultNode::nsNavHistorySeparatorResultNode()
|
|
: nsNavHistoryResultNode(EmptyCString(), EmptyCString(),
|
|
0, 0, EmptyCString())
|
|
{
|
|
}
|
|
|
|
|
|
static PLDHashOperator
|
|
RemoveBookmarkFolderObserversCallback(nsTrimInt64HashKey::KeyType aKey,
|
|
nsNavHistoryResult::FolderObserverList*& aData,
|
|
void* userArg)
|
|
{
|
|
delete aData;
|
|
return PL_DHASH_REMOVE;
|
|
}
|
|
|
|
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)
|
|
tmp->mBookmarkFolderObservers.Enumerate(&RemoveBookmarkFolderObserversCallback, nullptr);
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mAllBookmarksObservers)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mHistoryObservers)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
|
|
|
|
static PLDHashOperator
|
|
TraverseBookmarkFolderObservers(nsTrimInt64HashKey::KeyType aKey,
|
|
nsNavHistoryResult::FolderObserverList* &aData,
|
|
void *aClosure)
|
|
{
|
|
nsCycleCollectionTraversalCallback* cb =
|
|
static_cast<nsCycleCollectionTraversalCallback*>(aClosure);
|
|
for (uint32_t i = 0; i < aData->Length(); ++i) {
|
|
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb,
|
|
"mBookmarkFolderObservers value[i]");
|
|
nsNavHistoryResultNode* node = aData->ElementAt(i);
|
|
cb->NoteXPCOMChild(node);
|
|
}
|
|
return PL_DHASH_NEXT;
|
|
}
|
|
|
|
static void
|
|
traverseResultObservers(nsMaybeWeakPtrArray<nsINavHistoryResultObserver> aObservers,
|
|
void *aClosure)
|
|
{
|
|
nsCycleCollectionTraversalCallback* cb =
|
|
static_cast<nsCycleCollectionTraversalCallback*>(aClosure);
|
|
for (uint32_t i = 0; i < aObservers.Length(); ++i) {
|
|
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb, "mResultObservers value[i]");
|
|
const nsCOMPtr<nsINavHistoryResultObserver> &obs = aObservers.ElementAt(i);
|
|
cb->NoteXPCOMChild(obs);
|
|
}
|
|
}
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsNavHistoryResult)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRootNode)
|
|
traverseResultObservers(tmp->mObservers, &cb);
|
|
tmp->mBookmarkFolderObservers.Enumerate(&TraverseBookmarkFolderObservers, &cb);
|
|
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 bookmark folder observer arrays which are allocated on the heap
|
|
mBookmarkFolderObservers.Enumerate(&RemoveBookmarkFolderObserversCallback, nullptr);
|
|
}
|
|
|
|
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;
|
|
}
|
|
nsRefPtr<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::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)
|
|
{
|
|
ENUMERATE_BOOKMARK_FOLDER_OBSERVERS(aParentId,
|
|
OnItemAdded(aItemId, aParentId, aIndex, aItemType, aURI, aTitle, aDateAdded,
|
|
aGUID, aParentGUID)
|
|
);
|
|
ENUMERATE_HISTORY_OBSERVERS(
|
|
OnItemAdded(aItemId, aParentId, aIndex, aItemType, aURI, aTitle, aDateAdded,
|
|
aGUID, aParentGUID)
|
|
);
|
|
ENUMERATE_ALL_BOOKMARKS_OBSERVERS(
|
|
OnItemAdded(aItemId, aParentId, aIndex, aItemType, aURI, aTitle, aDateAdded,
|
|
aGUID, aParentGUID)
|
|
);
|
|
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)
|
|
{
|
|
ENUMERATE_BOOKMARK_FOLDER_OBSERVERS(aParentId,
|
|
OnItemRemoved(aItemId, aParentId, aIndex, aItemType, aURI, aGUID,
|
|
aParentGUID));
|
|
ENUMERATE_ALL_BOOKMARKS_OBSERVERS(
|
|
OnItemRemoved(aItemId, aParentId, aIndex, aItemType, aURI, aGUID,
|
|
aParentGUID));
|
|
ENUMERATE_HISTORY_OBSERVERS(
|
|
OnItemRemoved(aItemId, aParentId, aIndex, aItemType, aURI, aGUID,
|
|
aParentGUID));
|
|
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)
|
|
{
|
|
ENUMERATE_ALL_BOOKMARKS_OBSERVERS(
|
|
OnItemChanged(aItemId, aProperty, aIsAnnotationProperty, aNewValue,
|
|
aLastModified, aItemType, aParentId, aGUID, aParentGUID));
|
|
|
|
// 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) {
|
|
nsRefPtr<nsNavHistoryFolderResultNode> folder = list->ElementAt(i);
|
|
if (folder) {
|
|
uint32_t nodeIndex;
|
|
nsRefPtr<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);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 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)
|
|
{
|
|
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)
|
|
{
|
|
ENUMERATE_BOOKMARK_FOLDER_OBSERVERS(aOldParent,
|
|
OnItemMoved(aItemId, aOldParent, aOldIndex, aNewParent, aNewIndex,
|
|
aItemType, aGUID, aOldParentGUID, aNewParentGUID));
|
|
if (aNewParent != aOldParent) {
|
|
ENUMERATE_BOOKMARK_FOLDER_OBSERVERS(aNewParent,
|
|
OnItemMoved(aItemId, aOldParent, aOldIndex, aNewParent, aNewIndex,
|
|
aItemType, aGUID, aOldParentGUID, aNewParentGUID));
|
|
}
|
|
ENUMERATE_ALL_BOOKMARKS_OBSERVERS(OnItemMoved(aItemId, aOldParent, aOldIndex,
|
|
aNewParent, aNewIndex,
|
|
aItemType, aGUID,
|
|
aOldParentGUID,
|
|
aNewParentGUID));
|
|
ENUMERATE_HISTORY_OBSERVERS(OnItemMoved(aItemId, aOldParent, aOldIndex,
|
|
aNewParent, aNewIndex, aItemType,
|
|
aGUID, aOldParentGUID,
|
|
aNewParentGUID));
|
|
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 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(
|
|
MOZ_UTF16("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)
|
|
{
|
|
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)
|
|
{
|
|
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)
|
|
{
|
|
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)
|
|
{
|
|
ENUMERATE_HISTORY_OBSERVERS(OnDeleteVisits(aURI, aVisitTime, aGUID, aReason,
|
|
aTransitionType));
|
|
return NS_OK;
|
|
}
|