// 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:
// The Implementation of the CEComServer singleton class which
// instantiates an instance of the requested ECom Interface Implementation.
// 
//

/**
 @internalComponent
 @file
*/
#include <e32base.h>
#include <bautils.h>
#include <startupdomaindefs.h>
#include "EComDebug.h"
#include <ecom/ecom.h>
#include <ecom/ecomerrorcodes.h>
#include <ecom/ecomresolverparams.h>
#include <ecom/implementationinformation.h>

#include "ServerStartupManager.h"
#include "RegistryData.h"
#include "Registrar.h"
#include "DefaultResolver.h"
#include "RomOnlyResolver.h"
#include "TlsData.h"
#include "EComServerStart.h"
#include "EComMessageIds.h"
#include "EComServerSession.h"
#include "EComServer.h"
#include "EComUidCodes.h"
#include "EComPerformance.h"
#include "DriveInfo.h"
#include "FileUtils.h"
#include "RegistryResolveTransaction.h"
#include "resolvercache.h"
#include "EComPatchDataConstantv2.h"

#define UNUSED_VAR(a) a = a

/** enum for special system events */
enum TSpecialEvents
	{
	EBURInProgress,
	ESWIInProgress
	};

/** The location of server INI file. */
_LIT(KEComSrvrIniFile,"_:\\private\\10009D8F\\EComSrvr.ini");
/** Buffer descriptor to hold full path and name of server INI file. */
typedef TBuf<32> TEComSrvrIniFileName;

_LIT(KEComSrvrIniFileROM,"Z:\\private\\10009D8F\\EComSrvr.ini");

static void CloseAndDeleteImplInfoArray(TAny* aObject)
	{
	RImplInfoArray* array=reinterpret_cast<RImplInfoArray*>(aObject);
	if (array)
		{
		array->Close();
		}
	delete array;
	}
//
// Initiate server exit when the timer expires
// by stopping the local scheduler.
void CShutdown::RunL()
	{
	CActiveScheduler::Stop();
	}

CEComServer* CEComServer::NewLC()
	{
	// Standard 2 phase construction code
	CEComServer* instance = new(ELeave) CEComServer;
	CleanupStack::PushL(instance);
	instance->ConstructL();
	return instance;
	}


CEComServer::~CEComServer()
	{
	// Uninstall callbacks first. Do not want to receive any callback
	// in destructor. TCallBackWithArg constructed with no argument
	// is a null callback.
	TCallBackWithArg nullCallback;
	if (iRegistrar)
		{
		iRegistrar->InstallSwiEventCallBack(nullCallback);
		iRegistrar->InstallBurEventCallBack(nullCallback);
		}
	if (iRegistryData)
		{
		iRegistryData->SetImplUpgradeCallBack(nullCallback);
		}

	// Ensure this deletion order is maintained - in particular the registrydata 
	// must last longer than the others which hold a reference to it.

	//remove the CServerStartupMgr
	delete iServerStartupMgr;
	// Then destroy the registrar object
	delete iRegistrar;
	// remove the registry data
	delete iRegistryData;
	
	delete iResolverCache;

	// Finally close down the file server connection
	iFs.Close();
	// Make sure the non-default resolver library is closed
	iResolverLibrary.Close();
	}


CEComServer::CEComServer()
: CServer2(CActive::EPriorityStandard)
	{
	// Do nothing
	}


void CEComServer::ConstructL()
	{
	START_TIMER
	START_HEAP
	StartL(KEComServerName);
	// Connect to the file server
	User::LeaveIfError(iFs.Connect());
	__ECOM_TRACE("ECOM: Server INIT - File Server session initialised");
	// construct the registry data handling object here
	iRegistryData = CRegistryData::NewL(iFs);
	__ECOM_TRACE("ECOM: Server INIT - Registry Data initialised");
	// Then the registrar
	iRegistrar = CRegistrar::NewL(*iRegistryData, *this, iFs);
	__ECOM_TRACE("ECOM: Server INIT - Registrar initialised");
	
	//Then the CServerStartupMgr

#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT
	iServerStartupMgr = new(ELeave) CServerStartupMgr(KDmHierarchyIdStartup, KSM2OSServicesDomain3, iFs);
#else
	iServerStartupMgr = new(ELeave) CServerStartupMgr(KDmHierarchyIdStartup, KBaseServicesDomain3, iFs);
#endif //SYMBIAN_SYSTEM_STATE_MANAGEMENT

	__ECOM_TRACE("ECOM: Server INIT - ServerStartupMgr initialised");
	iServerStartupMgr->RegisterObserverL(iRegistrar);
	
	iServerStartupMgr->InitialiseL(IsSSA(iFs));
	
	iResolverCache = CCustomResolverCache::NewL(KCustomResolverCacheSize,
		KCustomResolverCacheTimeout);

	TCallBackWithArg eventCallback(&CEComServer::NotifyEvents, this);
	iRegistrar->InstallSwiEventCallBack(eventCallback);
	iRegistrar->InstallBurEventCallBack(eventCallback);
	iRegistryData->SetImplUpgradeCallBack(eventCallback);

	// The server is about to start so construct the transient shutdown guy
	iShutdown.ConstructL();
	// ensure that the server still exits even
	// if the server start fails or the
	// 1st client fails to connect
	iShutdown.Start();
	RECORD_INITIALISE_HEAP
	RECORD_INITIALISE_RESULT
	}
	
TBool CEComServer::IsSSA(RFs& aFs)
	{
	// Check Z drive first.
	TBool isFileExisting = BaflUtils::FileExists(aFs, KEComSrvrIniFileROM);
	// Check system drive next
	if(!isFileExisting)
		{
		TEComSrvrIniFileName iniFile(KEComSrvrIniFile);
		TEComFileUtils::SetToDrive(iniFile,iRegistryData->iSystemDrive);
		isFileExisting = BaflUtils::FileExists(aFs, iniFile);
		}
	return !isFileExisting;		
	}

// Get implementation info for one implementation, and return to client
void CEComServer::GetImplementationInformationL(const TUid& aImplementationUid,
												CImplementationInformation*& aImplInfo,
												const TClientRequest& aClientRequest)
	{
	TEntry dllInfo;
	User::LeaveIfError(iRegistryData->GetImplementationDllInfoForClientL(
		aClientRequest, aImplementationUid, KNullUid, dllInfo, aImplInfo, ETrue));
	}

RImplInfoArray* CEComServer::ListImplementationsL(TUid aInterfaceUid, 
												   const TEComResolverParams& aAdditionalParameters, 
												   TUid aResolverUid,
												   const RExtendedInterfacesArray& aExtendedInterfaces,
												   const TClientRequest& aMessage
												   ) 
	{
	RImplInfoArray* result = NULL;
	CResolver* resolver = NULL;
	//create registry resolver transaction
	//get the TListImplParam parameters
	TBool capability= ETrue;
	if(!(aMessage.IsNull()))
		{
		TListImplParam listParam;
  		TPckg<TListImplParam> listParamPkg(listParam);
  		aMessage.ReadL(2,listParamPkg);
  		capability=listParam.iCapabilityCheck;
		}
  	
  	
	CRegistryResolveTransaction* registryResolveTransaction = CRegistryResolveTransaction::NewL(*iRegistryData,
																								aExtendedInterfaces,
																								aMessage,capability);
	CleanupStack::PushL(registryResolveTransaction);
	//create resolver
	resolver = CreateResolverLC(aResolverUid,registryResolveTransaction);
	result = ListImplementationsL(aInterfaceUid, aAdditionalParameters, resolver);
	//clean up
	CleanupStack::PopAndDestroy(resolver);
	CleanupStack::PopAndDestroy(registryResolveTransaction);
	if ((aResolverUid != KDefaultResolverUid) && (aResolverUid != KRomOnlyResolverUid))
		{
		iResolverLibrary.Close();
		}
	return result;
	}

RImplInfoArray* CEComServer::ListImplementationsL(TUid aInterfaceUid, 
												   TUid aResolverUid,
												   const RExtendedInterfacesArray& aExtendedInterfaces,
												   const TClientRequest& aMessage
												   ) 
	{
	RImplInfoArray* result = NULL;
	CResolver* resolver = NULL;
	//create registry resolver transaction
	//get the TListImplParam parameters
  		//get the TListImplParam parameters
	TBool capability= ETrue;
	if(!(aMessage.IsNull()))
		{
		TListImplParam listParam;
  		TPckg<TListImplParam> listParamPkg(listParam);
  		aMessage.ReadL(2,listParamPkg);
  		capability=listParam.iCapabilityCheck;
		}
	CRegistryResolveTransaction* registryResolveTransaction = CRegistryResolveTransaction::NewL(*iRegistryData,
																								aExtendedInterfaces,
																								aMessage,capability);
	CleanupStack::PushL(registryResolveTransaction);
	//create resolver
	resolver = CreateResolverLC(aResolverUid,registryResolveTransaction);
	result = ListImplementationsL(aInterfaceUid, resolver);
	//clean up
	CleanupStack::PopAndDestroy(resolver);
	CleanupStack::PopAndDestroy(registryResolveTransaction);
	if ((aResolverUid != KDefaultResolverUid) && (aResolverUid != KRomOnlyResolverUid))
		{
		iResolverLibrary.Close();
		}
	return result;
	}


RImplInfoArray* CEComServer::ListImplementationsL(TUid aInterfaceUid, 
												   const TEComResolverParams& aAdditionalParameters,
												   const RExtendedInterfacesArray& aExtendedInterfaces,
												   const TClientRequest& aMessage) 
	{
	// Use the default resolver in the overloaded method.
	return ListImplementationsL(aInterfaceUid, aAdditionalParameters, KDefaultResolverUid,aExtendedInterfaces, aMessage);
	}

RImplInfoArray* CEComServer::ListImplementationsL(TUid aInterfaceUid,
												  const RExtendedInterfacesArray& aExtendedInterfaces,	
												  const TClientRequest& aMessage) 
	{
	// Use the default resolver in the overloaded method.
	return ListImplementationsL(aInterfaceUid, KDefaultResolverUid,aExtendedInterfaces, aMessage);
	}

// The private helper

RImplInfoArray* CEComServer::ListImplementationsL(TUid aInterfaceUid, 
												   const TEComResolverParams& aAdditionalParameters, 
												   CResolver* aResolver) const
	{
	if(!aResolver)
		User::Leave(KEComErrNoResolver);
	// Use the client provided resolver to build up the list.
	RImplInfoArray* infoArray = aResolver->ListAllL(aInterfaceUid, aAdditionalParameters);
	return infoArray;
	}

RImplInfoArray* CEComServer::ListImplementationsL(TUid aInterfaceUid, 
												  CResolver* aResolver) const
	{
	if(!aResolver)
		User::Leave(KEComErrNoResolver);
	// Use the provided resolver to build up the list.
	RImplInfoArray* infoArray = &aResolver->ListAllL(aInterfaceUid);
	// infoArray points to iImplementationInfo, which is owned by CRegistryResolveTransaction. 
	// CRegistryResolveTransaction object is transient and will be destroyed before return the implementation
	// info list to the CEComServerSession. Therefore, we need to have a copy to return
	RImplInfoArray* retList = new (ELeave) RImplInfoArray;
	CleanupStack::PushL(TCleanupItem(CloseAndDeleteImplInfoArray,retList));
	const TInt numImps = infoArray->Count();
	for(TInt index = 0; index < numImps; ++index)
		{	
		retList->AppendL((*infoArray)[index]);
		}
	// Reset the member variable because we are passing ownership back
	CleanupStack::Pop();
	return retList;
	}

void CEComServer::GetResolvedDllInfoL(	const TUid aImplementationUid,
										TEntry& aDllInfo,
										TUid& aDtor_Key,
										const TClientRequest& aClientRequest)
	{
	// No resolution to do create directly.
	aDtor_Key = aImplementationUid;
	CImplementationInformation* implInfo = NULL;
	TUid dummyUid={0x00000000};
	//We need to do the security check for the case that implementationUid is known.
	//if implementationUid is unknown, the security check will be done in ListImplementationsL.
	User::LeaveIfError(iRegistryData->GetImplementationDllInfoForClientL(
		aClientRequest, aImplementationUid, dummyUid, aDllInfo, implInfo, ETrue));
	}


void CEComServer::GetResolvedDllInfoL(  const TUid aInterfaceUid,
										const TEComResolverParams& aAdditionalParameters,
										const RExtendedInterfacesArray& aExtendedInterfaces,
										TEntry& aDllInfo, 
										TUid& aDtor_Key,
										const TClientRequest& aClientRequest)
	{
	GetResolvedDllInfoL(aInterfaceUid, aAdditionalParameters, KDefaultResolverUid, aExtendedInterfaces, aDllInfo, aDtor_Key, aClientRequest);
	}


void CEComServer::GetResolvedDllInfoL(  const TUid aInterfaceUid,
										const TEComResolverParams& aAdditionalParameters,
										const TUid aResolverUid,
										const RExtendedInterfacesArray& aExtendedInterfaces,
										TEntry& aDllInfo,
										TUid& aDtor_Key,
										const TClientRequest& aClientRequest)
	{
	CResolver* resolver = NULL;
	TBool capability= ETrue;
	//create registry resolver transaction
	CRegistryResolveTransaction* registryResolveTransaction = CRegistryResolveTransaction::NewL(*iRegistryData,
																								aExtendedInterfaces,
																								aClientRequest,capability);
	CleanupStack::PushL(registryResolveTransaction);
	//create resolver
	resolver = CreateResolverLC(aResolverUid,registryResolveTransaction);
	aDtor_Key = resolver->IdentifyImplementationL(aInterfaceUid, aAdditionalParameters);

	//clean up
	CleanupStack::PopAndDestroy(resolver);
	CleanupStack::PopAndDestroy(registryResolveTransaction);
	if ((aResolverUid != KDefaultResolverUid) && (aResolverUid != KRomOnlyResolverUid))
		{
		iResolverLibrary.Close();
		}
	CImplementationInformation* implInfo = NULL;
	//Don't need to do the security check because it has been done in IdentifyImplementationL.
	User::LeaveIfError(iRegistryData->GetImplementationDllInfoForClientL(
		aClientRequest, aDtor_Key, aInterfaceUid, aDllInfo, implInfo, EFalse));
	}

// Server Session management
CSession2* CEComServer::NewSessionL(const TVersion& aVersion,const RMessage2& /* aMessage*/) const
	{
	const TVersionName version = CONST_CAST(TVersion&,aVersion).Name();
	const TVersionName thisVersion = TVersion(KEComServerMajorVN,KEComServerMinorVN,KEComServerBuildVN).Name();
	if(thisVersion != version)
		User::Leave(KErrNotSupported);
	return new(ELeave) CEComServerSession();
	}

//
// A new session is being created
// Cancel the shutdown timer if it was running
//
void CEComServer::AddSession()
	{
	++iSessionCount;
	iShutdown.Cancel();
	}

//
// A session is being destroyed
// Start the shutdown timer if it is the last session.
//
void CEComServer::DropSession()
	{
	if (--iSessionCount==0)
		iShutdown.Start();
	}

void CEComServer::Notification(TInt aCompletionCode)
//
// Pass on the signal to all clients
//
	{
	iSessionIter.SetToFirst();
	CSession2* s;
	while ((s = iSessionIter++)!=0)
		STATIC_CAST(CEComServerSession*,s)->CompleteNotifications(aCompletionCode);
	}

TInt CEComServer::RunError(TInt aError)
//
// Handle an error from CMySession::ServiceL()
// A bad descriptor error implies a badly programmed client, so panic it;
// otherwise report the error to the client
//
	{
	if (aError == KErrBadDescriptor)
		{
		PanicClient(Message(), aError);
		}
	else
		{
		Message().Complete(aError);
		}
	//
	// The leave will result in an early return from CServer::RunL(), skipping
	// the call to request another message. So do that now in order to keep the
	// server running.
	ReStart();
	return KErrNone;	// handled the error fully
	}

/**
Creates resolver object with aResolverUid UID.
The method leaves resolver onto the cleanup stack.
@param aResolverUid Resolver UID.
@param			aRegistryResolveTransaction A pointer to Registry resolve transaction object
@return A pointer to the created CResolver object.
@leave System-wide error codes, including KErrNoMemory.
*/
CResolver* CEComServer::CreateResolverLC(const TUid& aResolverUid,CRegistryResolveTransaction* aRegistryResolveTransaction)
	{
	CResolver* resolver = NULL;
	if(aResolverUid == KDefaultResolverUid)
		{
		// Create default resolver
		resolver = static_cast<CResolver*>(CDefaultResolver::NewL(*aRegistryResolveTransaction));
		CleanupStack::PushL(resolver);
		}
	else if(aResolverUid == KRomOnlyResolverUid)
		{
		// Create Rom Only resolver
		resolver = static_cast<CResolver*>(CRomOnlyResolver::NewL(*aRegistryResolveTransaction));
		CleanupStack::PushL(resolver);
		}
	else
		{
		// Create Custom Resolver
		resolver = CreateCustomResolverLC(aResolverUid, aRegistryResolveTransaction);
		}
	return resolver;
	}

/**
Creates custom resolver object with aResolverUid UID.
The method leaves custom resolver onto the cleanup stack.
@param aResolverUid Custom resolver UID.
@param			aRegistryResolveTransaction A pointer to Registry resolve transaction object
@return A pointer to the created CResolver object.
@leave System-wide error codes, including KErrNoMemory.
*/
CResolver* CEComServer::CreateCustomResolverLC(TUid aResolverUid,CRegistryResolveTransaction* aRegistryResolveTransaction)
	{
	typedef CResolver* (*TNewL)(MPublicRegistry&);
	TNewL newL = NULL;
	CResolver* resolver=NULL;

	TProxyNewLPtr tmpPtr;
	if (iResolverCache->CacheLookup(aResolverUid, tmpPtr)) // cache hit
		{
		newL = reinterpret_cast<TNewL>(tmpPtr);
		resolver = newL(*aRegistryResolveTransaction);
		CleanupStack::PushL(resolver);
		return resolver;
		}

	TEntry resolverDllInfo;
	// We should only load custom resolvers that are in the ROM
	//Initialize the server cap to ProtServ
	TCapabilitySet servercap(ECapabilityProtServ);
	CImplementationInformation* implInfo = NULL;
	TBool onWritableDrv = EFalse;  
	User::LeaveIfError(iRegistryData->GetImplementationDllInfoForServer(
		servercap, aResolverUid, KEComResolverInterfaceUid, resolverDllInfo,
		implInfo, onWritableDrv));

	// Type of the function pointer which is the proxy into the interface implementation collection
	typedef TImplementationProxy* (*TInstantiationL)(TInt&);
	// Function at ordinal 1 is InstantiationMethodL()
	const TInt KImplementationGroupProxy = 1;
	// So cast to the correct type : This gives an ANSI C++ warning
	// When using a REINTERPRET_CAST so simply cast instead

	const TDesC& libraryPath = resolverDllInfo.iName;
	// Make sure the non-default resolver library is closed
	iResolverLibrary.Close();
	User::LeaveIfError(iResolverLibrary.Load(libraryPath, resolverDllInfo.iType));
	__ECOM_TRACE2("ECOM: Resolver Loaded UID:0x%X - %S", aResolverUid.iUid, &resolverDllInfo.iName);
	TInstantiationL proxy= REINTERPRET_CAST(TInstantiationL, iResolverLibrary.Lookup(KImplementationGroupProxy));

	// Scan the returned table for a UID match, and return the associated
	// creation method if found.
	TInt count = 0;
	TImplementationProxy* implementationTable = proxy(count);
	for(TInt i = 0; i < count; ++i)
		{
		if(aResolverUid == implementationTable[i].iImplementationUid)
			{
			newL = (TNewL)(implementationTable[i].iNewLFuncPtr);
			}
		}

	if(newL)
		{
		if (IsCachable(onWritableDrv))
			{
			TUint32 flags = (onWritableDrv) ? EEntryIsOnReadWriteDrive : EEntryFlagsNone;
			User::LeaveIfError(iResolverCache->CacheResolver(aResolverUid,
				iResolverLibrary, (TProxyNewLPtr)newL, flags));
			// Handle is now owned by iResolverCache.
			iResolverLibrary.SetHandle(KNullHandle);
			}

		// Create the non-default resolver
		resolver = newL(*aRegistryResolveTransaction);
		CleanupStack::PushL(resolver);
		}
	else
		{
		User::Leave(KEComErrNoResolver);
		}
	return resolver;
	}


TBool CEComServer::RegistryIndexValid() const
	{
	return iRegistryData->IndexValid();
	}
	
/** Callback function. CRegistryData uses this to notify of implementation
upgrade. CDiscoverer uses this to notify state changes in SWI/BUR.
@param aObj Pointer to CEComServer object.
@param aEvent Identify the event.
@param aData Data associated with the callback.
@return none, not-used, ignored.
*/
TInt CEComServer::NotifyEvents(TAny* aObj, TInt aEvent, TAny* aData)
	{
	CEComServer* self = static_cast<CEComServer*>(aObj);
	switch (aEvent)
		{
		case ECallBackId_ImplUpgrade:
			{
			TUid* uid = static_cast<TUid*>(aData);
			self->NotifyUpgrade(*uid);
			}
			break;
		case ECallBackId_SwiEvent:
			self->NotifySWIEvent(aData);
			break;
		case ECallBackId_BurEvent:
			self->NotifyBUREvent(aData);
			break;
		default:
			__ECOM_TRACE1("ECOM: CEComServer::NotifyEvents received unknown event %d", aEvent);
		}

	return 0;
	}

/** This method is called when an implementation is upgraded.
@param aImplementationUid identify the implementation being upgraded.
*/
void CEComServer::NotifyUpgrade(const TUid aImplementationUid)
	{
	// Ignore return code which indicates if the UID is actually in cache.
	(void)iResolverCache->Remove(aImplementationUid);
	}

/** Called when there is SWI status change.
@param aData is TCallBackState* indicating start or end of SWI. 
*/
void CEComServer::NotifySWIEvent(TAny* aData)
	{
	TCallBackState* state = static_cast<TCallBackState*>(aData);
	UpdateSpecialEvents(ESWIInProgress, *state);
	}

/** Called when there is BUR status change.
@param aData is TCallBackState* indicating start or end of BUR. 
*/
void CEComServer::NotifyBUREvent(TAny* aData)
	{
	TCallBackState* state = static_cast<TCallBackState*>(aData);
	UpdateSpecialEvents(EBURInProgress, *state);
	}

/** Updates the BUR/SWI status.
@param aBit Indicate which bit to update.
@param aState Indicate start or end of event.
*/
void CEComServer::UpdateSpecialEvents(TUint32 aBit, TCallBackState aState)
	{
	TBitFlags32 oldstate = iSpecialEvents;

	if (aState == ECallBackState_EventStart)
		{
		iSpecialEvents.Set( aBit );
		}
	else
		{
		iSpecialEvents.Clear( aBit );
		}

	if (oldstate.Value() == 0 && iSpecialEvents.Value() != 0)
		{
		// BUR or SWI start. Need to evict cached resolvers on RW drives.
		iResolverCache->RemoveItemsWithFlags(EEntryIsOnReadWriteDrive);
		}
	}

/** Determine if a resolver entry is cachable.
@param aResolverEntry the resolver to check.
@return ETrue if the resolver should be added to cache. EFalse otherwise.
*/
TBool CEComServer::IsCachable(TBool aEntryIsOnRWDrive)
	{
	// Check the following conditions:
	// 1. DLL is on RW drive with BUR or SWI in progress.
	// 2. Cache size and cache timeout non-zero.
	return	iResolverCache->CachingEnabled() &&
			!(iSpecialEvents.Value() && aEntryIsOnRWDrive);
	}

#ifdef __ECOM_SERVER_TESTABILITY__
void CEComServer::ChangeStartupStateL(TInt aState) const
	{
	iServerStartupMgr->ChangeStartupStateL(aState);
	}

void CEComServer::ProcessCurrentStartupStateL() const
	{
	iServerStartupMgr->ResetRequestTransitionNotificationL();
	iServerStartupMgr->ResetLastStateAcknowledgedL();
	iServerStartupMgr->RunL();
	}
	
TInt CEComServer::GetCurrentStartupState() const
	{
	return iServerStartupMgr->CurrentStartupState();
	}
#endif //__ECOM_SERVER_TESTABILITY__

#ifdef __ECOM_SERVER_PERFORMANCE__
void CEComServer::GetRegistryCountsL(TInt aType, RegistryCounts::TRegistryCounts& aCounts) const
	{
	iRegistryData->GetRegistryCountsL(aType, aCounts);
	}	
#endif //__ECOM_SERVER_PERFORMANCE__