// 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__