diff -r 000000000000 -r e4d67989cc36 lowlevellibsandfws/pluginfw/Framework/frame/RegistryData.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lowlevellibsandfws/pluginfw/Framework/frame/RegistryData.h	Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,493 @@
+// Copyright (c) 1997-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:
+// Implements Registry data handling.
+// Registry structure...
+// iRegistrations
+// -> CDriveData					(Drive number 1)
+// -> CDllData						(Dll number 1)
+// |	 -> CInterfaceData				(Interface number 1)
+// |	|	 -> CImplementationData -> CImplementationInformation	(Implementation 1)
+// |	|	 -> CImplementationData -> CImplementationInformation	(Implementation 2)
+// |	 -> CInterfaceData			
+// -> CDllData						(Dll number 2)
+// -> CInterfaceData				(Interface number 1)
+// -> CImplementationData -> CImplementationInformation	(Implementation 1)
+// 
+//
+
+/**
+ @code
+ @endcode
+*/
+
+#ifndef __REGISTRYDATA_H__
+#define __REGISTRYDATA_H__
+
+#include <e32base.h>
+#include <f32file.h>
+#include <barsread2.h> // RResourceReader
+#include <s32std.h>
+#include <s32file.h>
+#include <badesca.h>
+#include "clientrequest.h"
+#include <ecom/ecom.h>
+#include <ecom/ecomerrorcodes.h>
+#include <ecom/ecomresolverparams.h>
+#include <ecom/implementationinformation.h>
+#include <ecom/publicregistry.h>
+#include "EComEntry.h"
+#include "DiscovererObserver.h"
+#include "EComPerformance.h"
+#include "callback.h"
+
+/** 
+The index of the uid which is used for matching dlls 
+@internalComponent
+*/
+const TInt KTEntryDllUniqueIdIndex = 2;
+
+/**
+Default path to Interface Implementation Collection resource files.
+@internalComponent
+*/
+_LIT(KEComResourceFilePath,"\\resource\\plugins\\");
+
+/** The granularities of two arrays, iInterfaceImplIndex and
+iImplIndex, have huge impact on
+discovery time on boot up. Larger granularity does not
+always shorten discovery time. The two default granularities
+below are chosen empirically to optimize discovery time
+while as much as possible, not to waste too much memory.
+
+@internalComponent
+*/
+const TInt KDefaultInterfaceImplIndexGranularity = 23;
+
+/** @internalComponent */
+const TInt KDefaultImplIndexGranularity = 29;
+
+// Forward declaration
+class CEComCachedDriveInfo;
+
+//
+// CRegistryData class
+
+/**
+@internalComponent
+class CRegistryData.
+This class manages the entire data of the registry.
+*/
+class CRegistryData : public CBase
+	{
+public:
+	// Make the test State Accessor a friend
+	friend class TRegistryData_StateAccessor;
+	friend class CRegistrar;
+	
+	class CDriveData;
+	class CDllData;
+	class CInterfaceData;
+	class CImplementationData;	
+
+	// The implemented structure for the registry data 
+	typedef CRegistryData::CImplementationData* CImplementationDataPtr;
+	
+	typedef RArray<CImplementationDataPtr> RImplDataArray;
+	/** whether the implementation to be added to the registry data
+	is a newcomer, or upgrade of an existing implementation, or
+	downgrade of an existing implementation. 
+ 	*/
+	enum TInsertImplMode
+		{
+		EInsertImplUndefinedMode,
+		EInsertImplAsNewcomerOfInterface,
+		EInsertImplAsUpgradeOfExistingImpl,
+		EInsertImplAsUnusedImpl
+		};
+		
+public:	
+	static CRegistryData* NewL(RFs& aFs);
+
+	/** This overload is provided for ECom performance test to find
+	the optimum granularity settings.
+	@see CEComImplIndexPerfTest
+	*/
+	static CRegistryData* NewL(RFs& aFs, 
+		TInt aInterfaceImplIndexGranularity, TInt aImplIndexGranularity);
+
+	virtual ~CRegistryData();
+	void ListImplementationsL(TUid aInterfaceUid,
+							  RImplDataArray& aImplementationData) const;
+	TInt SetEnabledState(TUid aImplementationUid, TBool aState);
+	void TemporaryUninstallL(const TDriveUnit& aDrive);
+	void UndoTemporaryUninstallL(const TDriveUnit& aDrive);
+	TBool IsRegisteredWithDate(TUid aDllUid, 
+								const TTime& aModified, 
+								TBool& aUpdate, 
+								CDriveData* aDriveData);
+	void AddDllDataL(const TDriveUnit& aDrive, TInt aFoundDriveIndex, CDllData* aDllData);
+	void UpdateDllDataL(const TDriveUnit& aDrive,TInt aFoundDriveIndex, CDllData* aDllData);
+	void DiscoveriesBeginning() const;
+	void DiscoveriesCompleteL(TBool aSuccessful, TPluginProcessingTypeIdentifier aProcessingType, TBool& aHasRegistryChanged);
+	TBool IndexValid() const;
+	TInt GetImplementationDllInfoForServer(	const TCapabilitySet& aCapabilitySet,
+											const TUid aImplUid,
+											const TUid aInterfaceUid,
+											TEntry& aEntry,
+											CImplementationInformation*& aImplInfo,
+											TBool& aIsOnRWDrive) const;
+	TInt GetImplementationDllInfoForClientL(const TClientRequest& aClientRequest,
+											const TUid aImplUid,
+											const TUid aInterfaceUid,
+											TEntry& aEntry,
+											CImplementationInformation*& aImplInfo,
+											TBool aSecurityCheckNeeded)const;
+	TBool HasLanguageChanged() const;
+	TBool InsertIntoIndexL(CImplementationData* aImplPtr, TBool aCheckIsNeeded);
+	void RemoveFromIndexL(CDllData* aDllData) const;
+	TBool IsAnyDllRegisteredWithDriveL(const TDriveUnit& aDrive)const;
+	TInt FindDriveL(const TDriveUnit& aDrive, CDriveData*& aDriveData)const;
+	void SetDiscoveryFlagL(const TDriveUnit& aDriveUnit);
+	void LanguageChangedL(TBool& aLanguageChanged);
+	void SetImplUpgradeCallBack(const TCallBackWithArg& aCallBack);
+	
+#ifdef __ECOM_SERVER_PERFORMANCE__
+	void GetRegistryCountsL(TInt aType, RegistryCounts::TRegistryCounts& aCounts) const;
+#endif // __ECOM_SERVER_PERFORMANCE__
+
+private:
+	typedef RPointerArray<CDriveData> TRegistration;
+
+	/** 
+	Implementation structure containing the current in use implementation and
+	a list of unused implementations with the same uid held in the registry tree.
+	The unused list is used to allow efficient rollback to previous impl in the event
+	that the current impl is removed.
+	*/	
+	typedef struct TImplStruct
+		{
+		/** Constructor */
+		TImplStruct();
+		/** Resets iUnusedImpls*/
+		inline void Reset();
+		/** Comparer*/
+		static TInt CompareImplStructUid(const TImplStruct& aEntry1,const TImplStruct& aEntry2);
+		/** Comparer to search TImplStruct with just the Impl. UID */
+		static TInt CompareUidAgainstImplStruct(const TUid* aUid, const TImplStruct& aEntry);
+		/**
+		Current Impl. This is not held in an array with the unused implementations because the array is not
+		sorted. See comment for iUnusedImpls.
+		*/
+		CImplementationDataPtr iCurrentImpl;
+		/**
+		List of additional unused implementations. This list is not ordered as the processing required to sort
+		the list when adding is more than that required to determine which should be used on rollback.
+		Also this additional processing is not wanted during startup.
+		*/
+		RImplDataArray iUnusedImpls;
+		}TImplContainer;
+	
+	typedef RArray<TImplContainer> TImplContainerArray;
+
+	/** 
+	Interface used by all implementation index
+	*/
+	typedef struct TInterfaceStruct
+		{
+		/** Constructor */
+		TInterfaceStruct();
+		/** Resets iImplementationInfo */
+		inline void Reset();
+		/** Comparer*/
+		static TInt CompareInfUid(const TInterfaceStruct& aIndexEntry1,const TInterfaceStruct& aIndexEntry2);
+		/** Unique Id of this interface */
+		TUid	iInterfaceUid;
+		/** List of the implementations of this interface */
+		TImplContainerArray iImpData;
+		}TInterfaceIndex;
+
+private:
+	explicit CRegistryData(RFs& aFs, TInt aInterfaceImplIndexGranularity, TInt aImplIndexGranularity);
+	void ConstructL();
+
+	TInt IndexedFind(TUid aInterfaceUid) const;
+	static TBool MatchOnDrive(const CRegistryData::CDriveData& aIndexOne, 
+							  const CRegistryData::CDriveData& aIndexTwo);
+
+	TInt FindImplementation(const TUid aImplUid, const TUid aInterfaceUid, CImplementationData*& aImplData) const;
+	CImplementationData* SelectDuplicatedImpl(const CImplementationData* aImpl1, const CImplementationData* aImpl2) const;
+
+	void ValidateRegistryL();
+	
+	CImplementationData* SelectPreferredImplL(CImplementationData* aOldImpl,
+											CImplementationData* aNewImpl,
+											TBool& aLigitimateImpl,
+											TBool aCheckIsNeeded) const;
+
+	void FilterForLatestLegitimateImplL(TImplContainerArray& aIdxArray,
+										CImplementationData* aNewImpl,
+										TInsertImplMode& aInsertMode,
+										TInt&  aPosOfImplInArray,
+										TBool& aLigitimateImpl,
+										TBool aCheckIsNeeded);
+	void DeleteDllL(CDllData* aDllData) const;
+	void AddImplDataL(CDriveData* aDriveData);
+
+	void InsertImplInIndexesL(TInsertImplMode	aInsertMode,
+							  TInt				aIfPosInInterfaceImplIndex,
+							  TInterfaceIndex&  aNewIfIndexEl,
+							  TInt				aImplPosInContainerArray,
+							  CImplementationData* aNewImpl,
+							  TBool aLegitimateImpl);
+	static void ResetTInterfaceIndex(TAny* aObject);
+
+	/** Remove the pointer from iImplIndex */
+	TBool RemoveImplFromImplIndex(CImplementationData* aPtr) const;
+	/** Insert aNewImpl into iImplIndex. */
+	TInt InsertImplIntoImplIndex(CImplementationData* aNewImpl) const;
+	/** Store change in drive state - addition or removal*/
+	void DriveChanged(const TDriveUnit& aDrive, TBool aDriveRemoved);
+
+// Attributes / Properties
+private:
+	/** A reference to a connected file server instance */
+	RFs& iFs;
+	/** The flag to indicate that we are in the middle of discoveries and therefore
+	the index list is probably out of date */
+	mutable TBool iCurrentlyDiscovering;
+	/** A boolean, indicating if the language downgrade path has changed */
+	TBool iLanguageChanged;
+	/** The entire registration data */ 
+	TRegistration* iRegistrations;
+	/** The index of all registered implementations sorted by interface UID.*/
+	mutable RArray<TInterfaceIndex> iInterfaceImplIndex;
+	/** Index of all implementations available to clients sorted by
+	 Implementation UID.
+	 Majority of clients do not specify the interface UID in 
+	 their create requests. Thus ECOM needs this auxiliary index.
+	 Note that if multiple entries have the same Impl. UID, they are
+	 ordered by the interface UID.
+	*/
+	mutable RPointerArray<CImplementationData> iImplIndex;
+	/**Bitmap indicating any drives removed */
+	TInt iRemovedDrives;
+
+	TCallBackWithArg iImplUpgradeCallBack;
+
+public:
+	/** System Drive cache to allow access by CEComServer*/
+	TDriveNumber iSystemDrive;	
+
+	/** cached info on drivelist */
+	CEComCachedDriveInfo*  iCachedDriveInfo;	
+	};  // End of CRegistryData definition
+	
+
+//
+// CRegistryData::CImplementationData class
+/**
+This wrapper class is needed, to create a 2 way relationship between CInterfaceData and the public 
+CImplementationInformation objects. It holds a reference to an implementation and a reference to its 
+parent interface data. 
+@internalComponent
+*/
+class CRegistryData::CImplementationData : public CBase
+	{
+public:
+	static CImplementationData* NewLC(CInterfaceData* aParent);
+	static CImplementationData* NewL(CInterfaceData* aParent,
+											TUid	aUid,
+											TInt	aVersion, 
+											HBufC*  aName,
+											HBufC8* aDataType,
+											HBufC8* aOpaqueData,
+											TDriveUnit aDrive,
+											TBool aRomOnly,
+											TBool aRomBased);
+	static CImplementationData* NewL(CInterfaceData* aParent,
+											TUid	aUid,
+											TInt	aVersion, 
+											HBufC*  aName,
+											HBufC8* aDataType,
+											HBufC8* aOpaqueData,
+											TDriveUnit aDrive,
+											TBool aRomOnly,
+											TBool aRomBased,
+											RExtendedInterfacesArray* aExtendedInterfaces);											
+	~CImplementationData();
+	void ExternalizeL(RWriteStream& aStore) const;
+	void InternalizeL(RReadStream& aStore);
+	static TInt CompareImplUid(const CImplementationData& aImpl1,const CImplementationData& aImpl2);
+	static TInt CompareImplUidIgnoreIfUid(const CImplementationData& aImpl1,const CImplementationData& aImpl2);
+	static TInt CompareUidAgainstImplData(const CImplementationData& aUid, const CImplementationData& aImplData);
+private:
+	CImplementationData(CInterfaceData* aParent);
+	void ConstructL(TUid	aUid,
+					TInt	aVersion, 
+					HBufC*  aName,
+					HBufC8* aDataType,
+					HBufC8* aOpaqueData,
+					TDriveUnit aDrive,
+					TBool aRomOnly,
+					TBool aRomBased);
+	void ConstructL(TUid	aUid,
+					TInt	aVersion, 
+					HBufC*  aName,
+					HBufC8* aDataType,
+					HBufC8* aOpaqueData,
+					TDriveUnit aDrive,
+					TBool aRomOnly,
+					TBool aRomBased,
+					RExtendedInterfacesArray* aExtendedInterfaces);				
+public:
+	/** A pointer to the implementation */
+	CImplementationInformation* iImplInfo;
+	/**Pointer to the parent CInterfaceData */
+	CInterfaceData* iParent;
+	};
+
+//
+// CRegistryData::CInterfaceData class
+
+/**
+This class manages the entire data for an interface of a dll.
+@internalComponent
+*/
+class CRegistryData::CInterfaceData : public CBase
+	{
+public:
+	static CInterfaceData* NewLC(CDllData* aParent);
+	static CInterfaceData* NewLC(TUid aInterfaceUid, CDllData* aParent);
+	~CInterfaceData();
+	void AddL(const CImplementationData* aImplementation);
+	void SetInterfaceUid(TUid aInterfaceUid);
+	void ExternalizeL(RWriteStream& aStore) const;
+	void InternalizeL(RReadStream& aStore);
+private:
+	CInterfaceData(CDllData* aParent);
+	CInterfaceData(TUid aInterfaceUid,CDllData* aParent);
+	void ConstructL();
+public:
+	/** The interface UID */
+	TUid		iInterfaceUid;
+	/** The implementations related to this interface */
+	RPointerArray<CImplementationData>* iImplementations;
+	/** Pointer to the parent DLL data */
+	CDllData* iParent;
+	};	// End CRegistryData::CInterfaceData
+
+/**
+@internalComponent
+*/
+typedef RPointerArray<CRegistryData::CInterfaceData> RInterfaceList ;
+
+//
+// CRegistryData::CDllData class
+
+/**
+This class manages the entire data of a registered dll.
+@internalComponent
+*/
+class CRegistryData::CDllData : public CBase
+	{
+public:
+	static CDllData* NewLC( CDriveData* iParent);//
+	static CDllData* NewLC(const TDesC& aDllName,const TTime& aDllModTime,const TUid& aSecondUid,const TUid& aThirdUid, CDriveData* iParent);
+	~CDllData();
+	void AddL(const CInterfaceData* aInterface);
+	void ExternalizeL(RWriteStream& aStore) const;
+	void InternalizeL(RReadStream& aStore);
+	void PopulateAnEntry(TEntry& aEntry) const;
+	TBool ProcessSecurityCheckL();
+	TBool SaveSecurityInfoL();
+	void SetResourceExtL(const TDesC& aExt);
+private:
+	CDllData( CDriveData* iParent);//
+	void ConstructL();//
+	/** See CDllData* NewLC */
+	void ConstructL(const TDesC& aDllName,const TTime& aDllModTime,const TUid& aSecondUid,const TUid& aThirdUid);
+
+public:
+	/** Information on the DLL */
+	CEComEntry* iDllEntry;
+	/** The list of interfaces within the dll */
+	RInterfaceList*	iIfList;
+	/** Capability set of this dll */
+	TCapabilitySet iCapSet;
+	/** A flag to tell if the DLL's security has been previously checked or not.*/
+	TBool iSecurityChecked;
+	/** A pointer to the parent drive data. */
+	CDriveData* iParent;
+	/** The VendorId of the DLL. */
+	TVendorId iVid;
+	/** The plugin resource file extension  - not set for plugins residing on RO Internal drives*/
+	HBufC* iRscFileExtension;
+	}; // End CRegistryData::CDllData
+
+/**
+@internalComponent
+*/
+typedef RPointerArray<CRegistryData::CDllData> TDll ;
+
+//
+// CRegistryData::CDriveData class
+
+/**
+This class manages the entire data of a registered dll.
+*/
+class CRegistryData::CDriveData : public CBase
+	{
+public:
+	static CDriveData* NewLC(TDriveUnit aDrive,CRegistryData* aParent);
+	~CDriveData();
+	void AddL(const CDllData* aDll);
+	void ExternalizeL(RFs& aFs,const TDesC& aDatFileName);
+	void InternalizeL(RFs& aFs,const TDesC& aDatFileName);
+	TInt FindDllIndex(const TUid aDllUid) const;
+private:
+	void DoInternalizeL(RFs& aFs, const TDesC& aFileName);
+	CDriveData(TDriveUnit aDrive,CRegistryData* aParent);
+	void ConstructL();
+
+public:
+	/** A reference to the drive. */
+	TDriveUnit	iDrive;
+	/** The list of Interface Implementation Collections upon the drive */
+	TDll*		iDllList;
+	/** The registry data. */
+    CRegistryData* iParent;
+    /**indicate the drive has change */
+    TBool iDriveChanged;
+    /**indiacate the registry data on the drive has changed */
+    TBool iRegistryChanged;
+
+	}; // End CRegistryData::CDriveData
+
+void CRegistryData::TInterfaceIndex::Reset()
+ 	{
+ 	TInt count = iImpData.Count();
+ 	while(count > 0)
+ 		{
+ 		--count;
+ 		iImpData[count].Reset();
+ 		}
+ 	iImpData.Reset();
+   	}
+
+void CRegistryData::TImplContainer::Reset()
+ 	{
+ 	iUnusedImpls.Reset();
+   	}
+
+#endif //__REGISTRYDATA_H__