--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/applayerpluginsandutils/bookmarksupport/src/bkmrkdb.cpp	Tue Feb 02 01:09:52 2010 +0200
@@ -0,0 +1,1011 @@
+// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// Internal class for opening and manipulating the bookmark database.
+// @internalComponent
+// 
+//
+
+#include <e32test.h>
+
+#include "bkmrk.h"
+#include "bkmrkfolder.h"
+#include "bkmrkdb.h"
+#include "repository.h"
+
+_LIT8(KEmptyIconData, "");
+
+const TInt KVersionMajor = 1;
+const TInt KVersionMinor = 0;
+const TInt KVersionBuild = 1;
+
+const TInt 	KFirstIndex	= 1;
+
+CBookmarkDb* CBookmarkDb::NewL(Bookmark::TVisibility aVisibility, MBookmarkObserver* aObserver)
+	{
+	CBookmarkDb* self = new (ELeave) CBookmarkDb(aObserver);
+	CleanupStack::PushL(self);
+	self->ConstructL(aVisibility);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CBookmarkDb::~CBookmarkDb()
+	{
+	delete iHomeText;
+	delete iSearchUri;
+	delete iDatabaseWatcher;
+	delete iDatabaseRepository;
+	delete iFolderWatcher;
+	delete iFolderRepository;
+	delete iBookmarkWatcher;
+	delete iBookmarkRepository;
+	delete iIconWatcher;
+	delete iIconRepository;
+	Reset();
+	delete iCustomProperties;
+	delete iPropertyRegister;
+
+	delete iUnloadedFolderList;
+	}
+
+CBookmarkDb::CBookmarkDb(MBookmarkObserver* aObserver)
+	: iObserver(aObserver)
+	{
+	}
+
+void CBookmarkDb::ConstructL(Bookmark::TVisibility aVisibility)
+	{
+	RThread thread;
+	TSecurityInfo secInfo(thread);
+	TBool hasWriteUserData = secInfo.iCaps.HasCapability(ECapabilityWriteUserData);
+	if (aVisibility == Bookmark::EVisibilityManager && !hasWriteUserData)
+		{
+		User::Leave(KErrPermissionDenied);
+		}
+
+	iVisibility = (aVisibility == Bookmark::EVisibilityDefault) ? Bookmark::EVisibilityAll : aVisibility;
+
+	iDatabaseRepository = CRepository::NewL(KUidBookmarkDatabaseRepository);
+	SetRepository(*iDatabaseRepository);
+	iFolderRepository = CRepository::NewL(KUidFolderRepository);
+	iBookmarkRepository = CRepository::NewL(KUidBookmarkRepository);
+	iIconRepository = CRepository::NewL(KUidIconRepository);
+
+	iPropertyRegister = CPropertyReg::NewL();
+	iCustomProperties = CPropertyList::NewL(*iDatabaseRepository, *iPropertyRegister, CPropertyReg::EGroupDatabase, KDbCusPropertyStart);
+
+	// Create the repositories if they don't exist
+	TPckgBuf<TVersion> pckg;
+	TInt err = iDatabaseRepository->Get(KVersionIndex, pckg);
+	if (err == KErrNone)
+		{
+		TransactionL(ETransLoad);
+		iBkmrkDbInitialized = ETrue;
+		}
+	else if (err == KErrNotFound)
+		{
+		// Set all as default empty values
+		iHomeId 		= Bookmark::KNullItemID;
+		iHomeText 		= KNullDesC().AllocL();
+		iSearchUri 		= KNullDesC8().AllocL();
+		iDefaultProxy 	= 0;
+		iDefaultNap 	= 0;
+		}
+	else
+		{
+		User::Leave(err);
+		}
+
+	if (iObserver)
+		{
+		iDatabaseWatcher = new (ELeave) CBkmrkWatcher(EBkmrkWatcherDatabase, *this, *iDatabaseRepository);
+		iDatabaseWatcher->WatchL();
+		iFolderWatcher = new (ELeave) CBkmrkWatcher(EBkmrkWatcherFolder, *this, *iFolderRepository);
+		iFolderWatcher->WatchL();
+		iBookmarkWatcher = new (ELeave) CBkmrkWatcher(EBkmrkWatcherBookmark, *this, *iBookmarkRepository);
+		iBookmarkWatcher->WatchL();
+		iIconWatcher = new (ELeave) CBkmrkWatcher(EBkmrkWatcherIcon, *this, *iIconRepository);
+		iIconWatcher->WatchL();
+		}
+
+	iTreeSync = EFalse;
+	iConfigSync = EFalse;
+	iIconSync = EFalse;
+
+	iUnloadedFolderList = new (ELeave) CDesCArrayFlat(10);
+	SetClean();
+	}
+
+void CBookmarkDb::Reset()
+	{
+	ResetTree();
+	ResetIcons();
+	if (iCustomProperties)
+		{
+		iCustomProperties->Reset();
+		}
+	}
+
+void CBookmarkDb::ResetTree()
+	{
+	if (iRoot)
+		{
+		iRoot->Reset();
+		delete iRoot;
+		iRoot = NULL;
+		iTreeConstructed = EFalse;
+		}
+
+	if (iUnloadedFolderList)
+		{
+		iUnloadedFolderList->Reset();
+		}
+
+	iFolderList.Reset();
+	iBookmarkList.Reset();
+
+	for (TInt index = iDeletedList.Count() - 1; index >= 0; --index)
+		{
+		delete iDeletedList[index];
+		}
+	iDeletedList.Reset();
+	}
+
+void CBookmarkDb::ResetIcons()
+	{
+	for (TInt index = iIconList.Count() - 1; index >= 0; --index)
+		{
+		delete iIconList[index];
+		}
+	iIconList.Reset();
+
+	iIconSync = EFalse;
+	}
+
+void CBookmarkDb::RefreshL()
+	{
+	// If no repository files( no bookmark data ) exists, it is not required to
+	// refresh the bookmark view. Check whether the repository has data or not
+	// 
+	if ( HasDataInRepositoryL () )
+		{
+		TransactionL(ETransLoad);
+		ResetTree();
+		ConstructTreeL();
+		ResetIcons();
+		LoadIconsL();				
+		}		
+	}
+
+void CBookmarkDb::InitialiseRepL(CRepository& aRepository)
+	{
+	TPckgBuf<TVersion> pckg;
+	TInt err = aRepository.Get(KVersionIndex, pckg);
+	if (err == KErrNotFound)
+		{
+		TInt result = KErrLocked;
+		do
+			{
+			aRepository.StartTransaction(CRepository::EConcurrentReadWriteTransaction);
+
+			// create entries in the repository
+			TVersion version(KVersionMajor, KVersionMinor, KVersionBuild);
+			TPckgBuf<TVersion> pckg(version);
+			aRepository.Create(KVersionIndex, pckg);
+			aRepository.Create(KRepNextIndex, KFirstIndex);
+		
+			// commit the transaction
+			TUint32 failedIndex;
+			result = aRepository.CommitTransaction(failedIndex);
+			} while (result == KErrLocked);
+		User::LeaveIfError(result);
+		}
+	else if (err != KErrNone)
+		{
+		User::Leave(err);
+		}
+	}
+
+
+void CBookmarkDb::CommitL()
+	{
+	CreateDefaultRepositoriesL ();
+	
+	CRepositoryAccessor::CommitL();
+
+	iPropertyRegister->CommitL();
+	iCustomProperties->CommitL();
+
+	TInt index = iFolderList.Count() - 1;
+	for (;index >= 0; --index)
+		{
+		iFolderList[index]->CommitL();
+		}
+
+	index = iBookmarkList.Count() - 1;
+	for (;index >= 0; --index)
+		{
+		iBookmarkList[index]->CommitL();
+		}
+
+	index = iIconList.Count() - 1;
+	for (;index >= 0; --index)
+		{
+		iIconList[index]->CommitL();
+		}
+
+	index = iDeletedList.Count() - 1;
+	for (;index >= 0; --index)
+		{
+		iDeletedList[index]->CommitL();
+		delete iDeletedList[index];
+		iDeletedList[index] = NULL;
+		}
+	iDeletedList.Reset();
+	}
+
+CBookmarkFolder& CBookmarkDb::RootL()
+	{
+	ConstructTreeL();
+	return *iRoot;
+	}
+
+CBookmarkFolder* CBookmarkDb::FindFolder(const TDesC& aFolderName)
+	{
+	TInt index = iFolderList.Count() - 1;
+	for (;index >=0; --index)
+		{
+		if (iFolderList[index] != NULL &&
+			aFolderName.Compare(iFolderList[index]->Title()) == 0)
+			{
+			return static_cast<CBookmarkFolder*>(iFolderList[index]);
+			}
+		}
+
+	return NULL;
+	}
+
+CBookmark& CBookmarkDb::CreateBookmarkL(CBookmarkFolder& aParent)
+	{
+	CreateDefaultRepositoriesL ();
+	ConstructTreeL();
+	CBookmarkFolder* parent = &aParent;
+	CBookmark* bookmark = CBookmark::NewL(*parent, *this);
+	CleanupStack::PushL(bookmark);
+	bookmark->AssignIdL();
+	bookmark->SetTitleL(KNullDesC);
+	iBookmarkList.AppendL(bookmark);
+	CleanupStack::Pop(bookmark);
+
+	return *bookmark;
+	}
+
+CBookmarkFolder& CBookmarkDb::CreateFolderL(const TDesC& aFolderName, CBookmarkFolder& aParent)
+	{
+	CreateDefaultRepositoriesL ();
+	if (FindFolder(aFolderName) || FindUnloadedFolder(aFolderName))
+		{
+		User::Leave(Bookmark::KErrTitleAlreadyUsed);
+		}
+
+	ConstructTreeL();
+	CBookmarkFolder* parent = &aParent;
+	CBookmarkFolder* folder = CBookmarkFolder::NewL(parent, *this);
+	CleanupStack::PushL(folder);
+	folder->AssignIdL();
+	folder->SetTitleL(aFolderName);
+	iFolderList.AppendL(folder);
+	CleanupStack::Pop(folder);
+
+	return *folder;
+	}
+
+void CBookmarkDb::DeleteItemL(Bookmark::TItemId aItem, TBool aRecursive)
+	{
+	if (aItem == Bookmark::KRootItemID)
+		{
+		User::Leave(Bookmark::KErrOperationDenied);
+		}
+
+	CBookmarkBase* item = FindItem(aItem);
+	if (!item)
+		{
+		User::Leave(KErrNotFound);
+		}
+
+  	if (item->Type() == Bookmark::ETypeFolder && !aRecursive)
+		{
+		CBookmarkFolder* folder = static_cast<CBookmarkFolder*>(item);
+		folder->SendChildrenToFolderL(*iRoot);
+		}
+
+	// Bookmark items are not deleted until the database is commited
+	// Deleted items are removed from the folder tree and go into a
+	// 'deleted' list. On a commit the deleted list is deleted from memory
+	// and from the repository.
+  	item->DeleteL();
+	}
+
+void CBookmarkDb::RemoveBookmarkL(CBookmark* aBookmark)
+	{
+	TInt index = iBookmarkList.Find(aBookmark);
+	if (index != KErrNotFound)
+		{
+		if (Home() == aBookmark)
+			{
+			SetHome(NULL);
+			}
+		iBookmarkList.Remove(index);
+		iDeletedList.AppendL(aBookmark);
+		}
+	}
+
+void CBookmarkDb::RemoveFolderL(CBookmarkFolder* aFolder)
+	{
+	TInt index = iFolderList.Find(aFolder);
+	if (index != KErrNotFound)
+		{
+		iFolderList.Remove(index);
+		iDeletedList.AppendL(aFolder);
+		}
+	}
+
+const TDesC8& CBookmarkDb::IconL(Bookmark::TAttachmentId aIconId)
+	{
+	LoadIconsL();
+	TInt index = FindIcon(aIconId);
+	if (index == KErrNotFound)
+		{
+		User::Leave(KErrNotFound);
+		}
+	return iIconList[index]->Data();
+	}
+
+Bookmark::TAttachmentId CBookmarkDb::CreateIconL(const TDesC8& aData)
+	{
+	CreateDefaultRepositoriesL ();
+	
+	LoadIconsL();
+	CBkmrkAttachment* icon = CBkmrkAttachment::NewL(*iIconRepository, aData);
+	CleanupStack::PushL(icon);
+	icon->SetIdL();
+	iIconList.AppendL(icon);
+	CleanupStack::Pop(icon);
+	return icon->Id();
+	}
+
+TInt CBookmarkDb::DeleteIconL(Bookmark::TAttachmentId aIconId)
+	{
+	LoadIconsL();
+	TInt index = FindIcon(aIconId);
+	if (index == KErrNotFound)
+		{
+		return KErrNotFound;
+		}
+
+	iDeletedList.AppendL(iIconList[index]);
+	iIconList[index]->DeleteL();
+	iIconList.Remove(index);
+
+	return KErrNone;
+	}
+
+TVersion CBookmarkDb::Version()
+	{
+	TVersion version(KVersionMajor, KVersionMinor, KVersionBuild);
+	return version;
+	}
+
+Bookmark::TVisibility CBookmarkDb::Visibility()
+	{
+	return iVisibility;
+	}
+
+void CBookmarkDb::SetHome(CBookmark* aHome)
+	{
+	iHome = aHome;
+	if (iHome)
+		{
+		iHomeId = iHome->Id();
+		}
+	else
+		{
+		iHomeId = Bookmark::KNullItemID;
+		}
+	SetDirty();
+	}
+
+CBookmark* CBookmarkDb::Home()
+	{
+	return iHome;
+	}
+
+const TDesC& CBookmarkDb::HomePageText() const
+	{
+	return *iHomeText;
+	}
+
+void CBookmarkDb::SetHomePageTextL(const TDesC& aHomePageText)
+	{
+	// The aHomePageText must be smaller that the maximim descriptor storage size
+	__ASSERT_ALWAYS(aHomePageText.Length() <= Bookmark::KMaxDescriptorLength, User::Panic(Bookmark::KBookmarkErrTooLong, KErrArgument));
+
+	delete iHomeText;
+	iHomeText = NULL;
+	iHomeText = aHomePageText.AllocL();
+	SetDirty();
+	}
+
+const TDesC8& CBookmarkDb::SearchUri() const
+	{
+	return *iSearchUri;
+	}
+
+void CBookmarkDb::SetSearchUriL(const TDesC8& aUri)
+	{
+	// The aUri must be smaller that the maximim uri storage size
+	__ASSERT_ALWAYS(aUri.Length() <= Bookmark::KMaxUriLength, User::Panic(Bookmark::KBookmarkErrTooLong, KErrArgument));
+
+	delete iSearchUri;
+	iSearchUri = NULL;
+	iSearchUri = aUri.AllocL();
+	SetDirty();
+	}
+
+TUint32 CBookmarkDb::DefaultProxy() const
+	{
+	return iDefaultProxy;
+	}
+
+void CBookmarkDb::SetDefaultProxy(TUint32 aServiceId)
+	{
+	iDefaultProxy = aServiceId;
+	SetDirty();
+	}
+
+TUint32 CBookmarkDb::DefaultNap() const
+	{
+	return iDefaultNap;
+	}
+
+void CBookmarkDb::SetDefaultNap(TUint32 aNetworkId)
+	{
+	iDefaultNap = aNetworkId;
+	SetDirty();
+	}
+
+TBool CBookmarkDb::IsTreeConstructed()
+	{
+	return (iRoot != NULL && iTreeConstructed);
+	}
+
+void CBookmarkDb::ConstructTreeL()
+	{
+	if (!iRoot)
+		{
+		iRoot = CBookmarkFolder::NewL(NULL, *this);
+		iRoot->SetTitleL(Bookmark::KTxtRootTitle);
+		iRoot->SetId(Bookmark::KRootItemID);
+		}
+	if ( !IsTreeConstructed() && HasDataInRepositoryL () )
+		{
+		// Load the tree only if the bookmark db is initialized
+		// and the tree is not already constructed.
+		LoadTreeL ();			
+ 		}
+	}
+
+CBookmarkBase* CBookmarkDb::FindItem(Bookmark::TItemId aItemId)
+	{
+	if (aItemId == Bookmark::KRootItemID)
+		{
+		return iRoot;
+		}
+
+	CBookmarkBase* item = NULL;
+
+	TInt index = 0;
+	TInt count = 0;
+	// the top bit of the id indicates whether the id is a folder or bookmark
+	TInt topBitSet = aItemId & KFolderIdMaskID;
+	if (topBitSet == 0)
+		{
+		// item is a bookmark
+		count = iBookmarkList.Count();
+		for (index = 0; index < count; ++index)
+			{
+			if (iBookmarkList[index]->Id() == aItemId)
+				{
+				// bookmark item found
+				item = iBookmarkList[index];
+				break;
+				}
+			}
+		}
+	else
+		{
+		// item is a folder
+		Bookmark::TItemId folderId;
+		count = iFolderList.Count();
+		for (index = 0; index < count; ++index)
+			{
+			folderId = iFolderList[index]->Id();
+			if (folderId == aItemId)
+				{
+				// folder item found
+				item = iFolderList[index];
+				break;
+				}
+			}
+		}
+
+	return item;
+	}
+
+CRepository& CBookmarkDb::FolderRepository()
+	{
+	return *iFolderRepository;
+	}
+
+CRepository& CBookmarkDb::BookmarkRepository()
+	{
+	return *iBookmarkRepository;
+	}
+
+CPropertyList& CBookmarkDb::CustomProperties()
+	{
+	return *iCustomProperties;
+	}
+
+CPropertyReg& CBookmarkDb::PropertyRegister()
+	{
+	return *iPropertyRegister;
+	}
+
+void CBookmarkDb::BWONotify(TBkmrkWatcherType aType)
+	{
+	switch(aType)
+		{
+	case EBkmrkWatcherFolder:
+	case EBkmrkWatcherBookmark:
+		iObserver->MBONotify(MBookmarkObserver::EEventUpdatedBookmarkTree);
+		iTreeSync = EFalse;
+		break;
+	case EBkmrkWatcherDatabase:
+		iObserver->MBONotify(MBookmarkObserver::EEventUpdatedConfig);
+		iConfigSync = EFalse;
+		break;
+	case EBkmrkWatcherIcon:
+		iObserver->MBONotify(MBookmarkObserver::EEventUpdatedIcons);
+		iIconSync = EFalse;
+		break;
+	default:
+		break;
+		}
+	}
+
+void CBookmarkDb::LoadBookmarkListL(CRepository& aRepository, TBkmrkList& aList, Bookmark::TType aType, TBool aLoadAll)
+	{
+	RArray<TUint32> entryList;
+	CleanupClosePushL(entryList);
+	aRepository.FindL(KRepIndexFind, KRepIndexMask, entryList);
+	CBookmarkBase* newItem;
+	TInt count = entryList.Count();
+	for (TInt index = 0;index < count; ++index)
+		{
+		if (aType == Bookmark::ETypeFolder)
+			{
+			newItem = CBookmarkFolder::NewL(NULL, *this);
+			}
+		else
+			{
+			newItem = CBookmark::NewL(*iRoot, *this);
+			}
+		CleanupStack::PushL(newItem);
+		newItem->SetIdFromIndexBase(entryList[index]);
+		newItem->TransactionL(ETransLoad);
+		if (aLoadAll || CheckAccessL(*newItem))
+			{
+			aList.AppendL(newItem);
+			CleanupStack::Pop(newItem);
+			}
+		else
+			{
+			if (aType == Bookmark::ETypeFolder)
+				{
+				iUnloadedFolderList->AppendL(newItem->Title());
+				}
+			CleanupStack::PopAndDestroy(newItem);
+			}
+		}
+	CleanupStack::PopAndDestroy(&entryList);
+	}
+
+void CBookmarkDb::AddItemsToFolderTreeL(TBkmrkList& aList)
+	{
+	TInt rank = 0;
+	CBookmarkFolder* parent;
+	CBookmarkBase* item;
+	TInt count = aList.Count();
+	for (TInt index = 0; index < count; ++index)
+		{
+		item = aList[index];
+		parent = static_cast<CBookmarkFolder*>(FindItem(item->ParentId()));
+		if (!parent)
+			{
+			item->SetOrphaned(ETrue);
+			iRoot->AppendL(*item);
+			}
+		else
+			{
+			rank = item->Rank();
+			if (rank < parent->Count())
+				{
+				parent->InsertL(*item, rank);
+				}
+			else
+				{
+				parent->AppendL(*item);
+				}
+			}
+		item->SetClean();
+		}
+	}
+
+TBool CBookmarkDb::RemoveFolderIfPublicL(CBookmarkFolder& aFolder)
+	{
+	// This method removes public folders in private-only mode.
+	// If not in this mode this method should not be called
+	__ASSERT_DEBUG(iVisibility == Bookmark::EVisibilityPrivate, User::Invariant());
+
+	TBool containsPrivate = EFalse;
+	for (TInt index = aFolder.Count() - 1; index >= 0; --index)
+		{
+		if (aFolder.At(index).Type() == Bookmark::ETypeFolder)
+			{
+			if (RemoveFolderIfPublicL(static_cast<CBookmarkFolder&>(aFolder.At(index))))
+				{
+				containsPrivate = ETrue;
+				}
+			}
+		else
+			{
+			// child is a bookmark which will only exist if it is private
+			containsPrivate = ETrue;
+			}
+		}
+
+	if (&aFolder != iRoot && !containsPrivate && !CheckAccessL(aFolder))
+		{
+		// The folder is not the root, does not contain any private items and is not private itself
+		// we can remove the folder
+		TInt index = iFolderList.Find(&aFolder);
+		iFolderList.Remove(index);
+		iUnloadedFolderList->AppendL(aFolder.Title());
+		delete &aFolder;
+		}
+
+	return containsPrivate;
+	}
+
+void CBookmarkDb::LoadTreeL()
+	{
+	if (HasOpenHandles())
+		{
+		User::Leave(Bookmark::KErrOpenHandle);
+		}
+
+	iLoading = ETrue;
+
+	// If we are in private-only mode then we need to open all the folders initially.
+	// We need to include public folders that contain private bookmarks
+	TBool privateMode = (Visibility() == Bookmark::EVisibilityPrivate);
+
+	// The pointers inside the folder list will not get deleted if LoadBookmarkListL or
+	// AddItemsToFolderTreeL functions leave. Attach the folder list into TCleanupItem
+	CleanupStack::PushL ( TCleanupItem ( CBookmarkDb::ResetAndDestroyBkmrkList, &iFolderList ) );
+	// Load folders into folder list
+	LoadBookmarkListL(*iFolderRepository, iFolderList, Bookmark::ETypeFolder, privateMode);
+	AddItemsToFolderTreeL(iFolderList);
+	CleanupStack::Pop (); // Pop the cleanup item object
+	
+	// Load bookmarks into bookmark list
+	CleanupStack::PushL ( TCleanupItem ( CBookmarkDb::ResetAndDestroyBkmrkList, &iBookmarkList ) );
+	LoadBookmarkListL(*iBookmarkRepository, iBookmarkList, Bookmark::ETypeBookmark, EFalse);
+	AddItemsToFolderTreeL(iBookmarkList);
+	CleanupStack::Pop (); // Pop the cleanup item object	
+	if (privateMode)
+		{
+		// remove folders that are not private and contain no private items.
+		RemoveFolderIfPublicL(*iRoot);
+		}
+
+	SetHome(static_cast<CBookmark*>(FindItem(iHomeId)));
+
+	iLoading = EFalse;
+	iTreeSync = ETrue;
+	iTreeConstructed = ETrue;
+	}
+
+TBool CBookmarkDb::IsLoading()
+	{
+	return iLoading;
+	}
+
+void CBookmarkDb::LoadIconsL()
+	{
+	if (!iIconSync)
+		{
+		RArray<TUint32> entryList;
+		CleanupClosePushL ( entryList );
+		iIconRepository->FindL(KRepIndexFind, KRepIconIndexMask, entryList);
+		CBkmrkAttachment* newIcon;
+		TInt index = 0;
+		TInt count = entryList.Count();
+		for (;index < count; ++index)
+			{
+			newIcon = CBkmrkAttachment::NewL(*iIconRepository, KEmptyIconData);
+			CleanupStack::PushL(newIcon);
+			newIcon->SetIdFromIndexBase(entryList[index]);
+			newIcon->TransactionL(ETransLoad);
+			iIconList.AppendL(newIcon);
+			CleanupStack::Pop(newIcon);
+			newIcon->SetClean();
+			}
+		CleanupStack::PopAndDestroy ( &entryList );
+
+		iIconSync = ETrue;
+		}
+
+	}
+
+TBool CBookmarkDb::HasOpenHandles()
+	{
+	if (!iRoot)
+		{
+		return EFalse;
+		}
+
+	TInt index = iFolderList.Count() -1;
+	for (; index >= 0; --index)
+		{
+		if (iFolderList[index]->RefCount() != 0)
+			{
+			return ETrue;
+			}
+		}
+
+	index = iBookmarkList.Count() -1;
+	for (; index >= 0; --index)
+		{
+		if (iBookmarkList[index]->RefCount() != 0)
+			{
+			return ETrue;
+			}
+		}
+
+	return EFalse;
+	}
+
+TInt CBookmarkDb::FindIcon(Bookmark::TAttachmentId aIconId)
+	{
+	TInt index = iIconList.Count() - 1;
+	for (;index >= 0; --index)
+		{
+		if (iIconList[index]->Id() == aIconId)
+			{
+			break;
+			}
+		}
+	return index;
+	}
+
+TBool CBookmarkDb::FindUnloadedFolder(const TDesC& aFolderName)
+	{
+	TInt index = iUnloadedFolderList->Count() - 1;
+	for (;index >=0; --index)
+		{
+		if (aFolderName.Compare((*iUnloadedFolderList)[index]) == 0)
+			{
+			return ETrue;
+			}
+		}
+
+	return EFalse;
+	}
+
+TBool CBookmarkDb::CheckAccessL(CBookmarkBase& aItem)
+	{
+	TBool accessible = EFalse;
+
+	// Always accessible if the item is the home page
+	if (aItem.Type() == Bookmark::ETypeBookmark && aItem.Id() == iHomeId)
+	{
+		return ETrue;
+	}
+
+	TBool owned = EFalse;
+	if (!aItem.IsPublic())
+		{
+		RThread thread;
+		TSecurityInfo secInfo(thread);
+		TSecureId id;
+		aItem.GetOwnerL(id);
+		if (id == secInfo.iSecureId)
+			{
+			owned = ETrue;
+			}
+		}
+
+	switch(iVisibility)
+		{
+		case Bookmark::EVisibilityPublic:
+			accessible = aItem.IsPublic();
+			break;
+		case Bookmark::EVisibilityPrivate:
+			accessible = owned;
+			break;
+		case Bookmark::EVisibilityAll:
+			accessible = (owned || aItem.IsPublic());
+			break;
+		case Bookmark::EVisibilityManager:
+			accessible = ETrue;
+			break;
+		case Bookmark::EVisibilityDefault:
+		default:
+			// should have been assigned to one of the values above
+			// during construction so shouldn't get here
+			User::Invariant();
+			break;
+		}
+
+	return accessible;
+	}
+
+
+void CBookmarkDb::TransNewL()
+	{
+	TInt customPropertyCount = 0;
+	// create entries in the repository
+	TVersion version(KVersionMajor, KVersionMinor, KVersionBuild);
+	TPckgBuf<TVersion> pckg(version);
+	iRepository->Create(KVersionIndex, pckg);
+	iRepository->Create(KDbHomeIdIndex, iHomeId);
+	iRepository->Create(KDbHomeTextIndex, *iHomeText);
+	iRepository->Create(KDbSearchUriIndex, *iSearchUri);
+	iRepository->Create(KDbDefaultProxyIndex, iDefaultProxy);
+	iRepository->Create(KDbDefaultNapIndex, iDefaultNap);
+	iRepository->Create(KRepBkmrkPropertyStart, customPropertyCount);
+	iRepository->Create(KRepFldrPropertyStart, customPropertyCount);
+	iRepository->Create(KRepDbPropertyStart, customPropertyCount);
+	}
+
+void CBookmarkDb::TransSaveL()
+	{
+	// create entries in the repository
+	TVersion version(KVersionMajor, KVersionMinor, KVersionBuild);
+	TPckgBuf<TVersion> pckg(version);
+	iRepository->Set(KVersionIndex, pckg);
+	iRepository->Set(KDbHomeIdIndex, iHomeId);
+	iRepository->Set(KDbHomeTextIndex, *iHomeText);
+	iRepository->Set(KDbSearchUriIndex, *iSearchUri);
+	iRepository->Set(KDbDefaultProxyIndex, iDefaultProxy);
+	iRepository->Set(KDbDefaultNapIndex, iDefaultNap);
+	}
+
+void CBookmarkDb::TransLoadL()
+	{
+	TPckgBuf<TVersion> pckg;
+	User::LeaveIfError(iRepository->Get(KVersionIndex, pckg));
+	TVersion version = pckg();
+	if (version.iMajor != KVersionMajor ||
+		version.iMinor != KVersionMinor )		
+		{
+		User::Leave(Bookmark::KErrBadVersion);
+		}
+
+	User::LeaveIfError(iRepository->Get(KDbHomeIdIndex, iHomeId));
+	HBufC* homeText = HBufC::NewLC(Bookmark::KMaxDescriptorLength);
+	TPtr16 ptr = homeText->Des();
+	User::LeaveIfError(iRepository->Get(KDbHomeTextIndex, ptr));
+	SetHomePageTextL(*homeText);
+	CleanupStack::PopAndDestroy(homeText);
+
+
+	HBufC8* searchUri = HBufC8::NewLC(Bookmark::KMaxDataLength);
+	TPtr8 ptr8 = searchUri->Des();
+	User::LeaveIfError(iRepository->Get(KDbSearchUriIndex, ptr8));
+	SetSearchUriL(*searchUri);
+	CleanupStack::PopAndDestroy(searchUri);
+
+	User::LeaveIfError(iRepository->Get(KDbDefaultProxyIndex, iDefaultProxy));
+	User::LeaveIfError(iRepository->Get(KDbDefaultNapIndex, iDefaultNap));
+
+	iCustomProperties->TransLoadL();
+	SetClean();
+	iTreeSync = ETrue;
+	}
+
+void CBookmarkDb::TransRemoveL()
+	{
+	iDatabaseRepository->Delete(KVersionIndex);
+	iDatabaseRepository->Delete(KDbHomeIdIndex);
+	iDatabaseRepository->Delete(KDbHomeTextIndex);
+	iDatabaseRepository->Delete(KDbSearchUriIndex);
+	iDatabaseRepository->Delete(KDbDefaultProxyIndex);
+	iDatabaseRepository->Delete(KDbDefaultNapIndex);
+	iDatabaseRepository->Delete(KRepBkmrkPropertyStart);
+	iDatabaseRepository->Delete(KRepFldrPropertyStart);
+	iDatabaseRepository->Delete(KRepDbPropertyStart);
+	}
+
+TUint32 CBookmarkDb::IndexBase()
+	{
+	return KIndexBaseZero;
+	}
+
+void CBookmarkDb::SetIdFromIndexBase(TUint32 /*aIndexBase*/)
+	{
+	// the id and index base is always 0 so do nothing
+	}
+
+void CBookmarkDb::ResetAndDestroyBkmrkList ( TAny* aPtr )
+	{
+	TBkmrkList& bkList = *( TBkmrkList* )aPtr;
+ 	
+	// Delete all items added. Otherwise these items will not get deleted and there will
+	// be a memory leak.
+	for ( TInt index = bkList.Count() - 1; index >= 0; --index )
+		{
+		delete bkList[ index ];			
+		}
+	bkList.Reset ();	
+	}
+
+void CBookmarkDb::CreateDefaultRepositoriesL ()
+	{
+	if ( !iBkmrkDbInitialized )
+		{		
+		TransactionL ( ETransNew );		
+		InitialiseRepL ( *iFolderRepository );
+		InitialiseRepL ( *iBookmarkRepository );
+		InitialiseRepL ( *iIconRepository );		
+		iBkmrkDbInitialized = ETrue;		
+		}
+	}
+
+TBool CBookmarkDb::HasDataInRepositoryL ()
+	{	
+	if ( !iBkmrkDbInitialized )
+		{
+		const TUint32 KNullKey = 0x00000000;
+		RArray<TUint32> foundKeys;
+		CleanupClosePushL ( foundKeys );	
+		iDatabaseRepository->FindL ( KNullKey, KNullKey, foundKeys );	
+		if ( foundKeys.Count () > 0 )
+			{
+			// Repository has data.
+			iBkmrkDbInitialized = ETrue;			
+			}	
+		CleanupStack::PopAndDestroy (); // foundKeys		
+		}	
+	return iBkmrkDbInitialized;
+	}
+	
+#ifndef EKA2
+GLDEF_C TInt E32Dll(TDllReason /*aReason*/)
+	{
+	return(KErrNone);
+	}
+#endif // EKA2