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

// Implementation of the CLoadManager class

// 

//

/**

 @internalComponent

 @file

*/

#include "EComDebug.h"

#include "UnloadPolicy.h"

#include "LoadManager.h"

#include "EComUidCodes.h"

#include <ecom/ecomerrorcodes.h>

#include "e32math.h"

#include "EComInternalErrorCodes.h"

#include <ecom/ecomextendedinterfaceerrorcodes.h>

/**

Standardized safe construction which leaves nothing on the cleanup stack.

@return			A pointer to the new class

@post			CLoadManager is fully constructed, and initialized.

 */

CLoadManager* CLoadManager::NewL()

	{

	return new(ELeave) CLoadManager();

	}

CLoadManager::~CLoadManager()

	{

	iInstanceInfoList.ResetAndDestroy();

	iAllUnloadPolicies.ResetAndDestroy();

	ClearGarbage();

	}

/**

Notifies the interface implementation DLL that one of its objects has been destroyed if it exists,

otherwise returns false to indicate no exist aImplementationUid.

@param          aInstanceKey A key specifying a previously created implementation.

@pre 			CLoadManager is fully constructed,

@post			CLoadManager's interface implementation DLL references

				are decreased by one. The instance info representing the implementation

				is destroyed.

*/

TBool CLoadManager::DestroyedThis(TUid aInstanceKey)

	{

	// Clear the garbage list because we know we have finished with them

	ClearGarbage();

	__ECOM_TRACE1("ECOM: Implementation Instance destroyed %x", aInstanceKey.iUid);

	// Sanity check that the pointer is divisible by four. A binary number is divisible

	// by four if and only if the two rightmost bits are both zero.

	// This is a compromised check for checking that the pointer is an address.

    if ((aInstanceKey.iUid == 0) || ((aInstanceKey.iUid & 0x00000003) != 0))

        {

	    __ASSERT_DEBUG(EFalse, User::Panic(KEComClientDLLPanicCategory, EEComPanic_InvalidImplementationInstanceKey));

	    User::Leave(KErrNotFound);

        }

	// The instance info pointer is stored in the instance key.

	CInstanceInfo* instanceInfo = reinterpret_cast<CInstanceInfo*>(aInstanceKey.iUid);

	// Check that the pointer exists before using it

	TInt position = iInstanceInfoList.FindInAddressOrder(instanceInfo);

	if(position == KErrNotFound)

		{

		return EFalse;

		}

	CUnloadPolicy* policy = instanceInfo->UnloadPolicy();

	if (policy != NULL)

		{

		// If needed, will move the policy to the garbage list, and remove policy from the unload policy list.

		Cleanup(policy);

		}

	iInstanceInfoList.Remove(position);

	// Remove the instance info item, finished with it.

	delete instanceInfo;

	return ETrue;

	}

/**

Check whether the policy Arrays are empty or not.

@return            Returns True if the policy Arrays are empty, otherwise return False.

@pre             CLoadManager is fully constructed,

@post            CLoadManager remains the same.

*/

TBool CLoadManager::PolicyArraysEmpty() const 

    {

    if( (iAllUnloadPolicies.Count() == 0)&&(iInstanceInfoList.Count() == 0) )

        {

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }

/**

Returns an implementation object to satisfy the specified interface.

@param			aUniqueImplementationUid The implementation to find.

@param			aEntry Information on the dll containing the implementation

@param			aCreationParameters A pointer to the creation parameter

				structure passed to the creation method when called.

@param			aCreationParamsFlag A boolean flag to indicate the existence or non-existence

				of aCreationParameters. Will be ETrue even for if the value of

				aCreationParameters is NULL.

@param          aInstanceKey A key specifying a previously created implementation.

@return			TAny* a pointer to the fully constructed instantiation. The pointer is

				guaranteed to be valid only until DestroyedThis is called.

@pre 			CLoadManager is fully constructed,

@post			Fully constructed implementation is returned to the

				caller, and aUniqueUid contains the implementation Dll's

				unique UID.

*/

TAny* CLoadManager::ImplementationObjectL(const TUid& aUniqueImplementationUid,

										 const TEntry& aEntry,

										 TAny* aCreationParameters,

										 TBool aCreationParamsFlag,

										 TUid& aInstanceKey)

	{

	//if the implementation Uid here is Null or the entry returned by the ecomserver

	//contains nothing, we should leave with KErrNotFound

	if(aUniqueImplementationUid == KNullUid || (aEntry.iName).Length()==0)

		{

		User::Leave(KErrNotFound);

		}

	TAny* object = NULL;               // Instantiation object

	CUnloadPolicy* policy = NULL;      // Policy of implementation

	TLibraryFunction libFunctionProxy; // Library function proxy pointer

	GetUnloadPolicy(aUniqueImplementationUid,aEntry,policy);

	if (policy == NULL)

		{

		// No policy found, so create a new CUnloadPolicy and load DLL.

		policy = CUnloadPolicy::NewLC(aEntry);

		libFunctionProxy = policy->LoadDllAndReturnProxyL();

		if (libFunctionProxy==NULL)

			{

			User::Leave(KErrNotFound);

			}

		iAllUnloadPolicies.AppendL(policy);

		CleanupStack::Pop(policy);	// owned by iAllUnloadPolicies

		}

	else

		{

		// Found a policy. Load Dll if not already loaded.

		libFunctionProxy = policy->LoadDllAndReturnProxyL();

		if (libFunctionProxy==NULL)

			{

			User::Leave(KErrNotFound);

			}

		}

	// Initial count of instances. This is used for cleanup purposes, to see if an instance

	// was added to the instance info list during the object creation. If a failure occurs

	// than the instance info that was added to the list will be removed.

	TInt initialCount = iInstanceInfoList.Count();

	TInt err = KErrNone;

	if (aEntry[1] == KUidInterfaceImplementationCollection)

		{

		// PLUGIN1 dll. Create the implementation object.

		TRAP(err,object = ImplementationObject1L(aUniqueImplementationUid,aCreationParameters,

			aCreationParamsFlag,aInstanceKey,policy,libFunctionProxy));

		}

	else if (aEntry[1] == KUidInterfaceImplementationCollection3)

		{

		// PLUGIN3 dll. Create the implementation object.

		TRAP(err,object = ImplementationObject3L(aUniqueImplementationUid,aCreationParameters,

			aCreationParamsFlag, aInstanceKey,policy, libFunctionProxy));

		}

	else

		{

		err = KErrNotSupported;

		}

	if (err != KErrNone)

		{

		if (iInstanceInfoList.Count() > initialCount)

			{

			// If an instance was added to the instance list, remove it here.

			// The instance info pointer is stored in the instance key. We know its

			// valid because it was set by ecom in call to ImplementationObject1L or

			// ImplementationObject3L

			CInstanceInfo* instanceInfo = reinterpret_cast<CInstanceInfo*>(aInstanceKey.iUid);

			TInt pos = iInstanceInfoList.FindInAddressOrder(instanceInfo);

			if(pos != KErrNotFound)

				{

				iInstanceInfoList.Remove(pos);

				}

			}

		ClearGarbage();

		// If needed, will move the policy to the garbage list, and remove policy from the unload policy list.

		Cleanup(policy);

		User::Leave(err);

		}

	__ECOM_TRACE2("ECOM: Implementation created (%03d) %x", ++iDebugInstantiationCounter, aUniqueImplementationUid.iUid);

	return object;

	}

/**

Returns an implementation object to satisfy the specified interface.

@param			aUniqueImplementationUid The implementation to find.

@param			aCreationParameters A pointer to the creation parameter

				structure passed to the creation method when called.

@param			aCreationParamsFlag A boolean flag to indicate the existence or non-existence

				of aCreationParameters. Will be ETrue even for if the value of

				aCreationParameters is NULL.

@param          aInstanceKey A key specifying a previously created implementation.

@param          aPolicy policy of implementation

@param          aLibFunctionProxy Library function proxy pointer.

@return			TAny* a pointer to the fully constructed instantiation. The pointer is

				guaranteed to be valid only until DestroyedThis is called.

*/

TAny* CLoadManager::ImplementationObject1L(const TUid& aUniqueImplementationUid,

										 TAny* aCreationParameters,

										 TBool aCreationParamsFlag,

										 TUid& aInstanceKey,

										 CUnloadPolicy* aPolicy,

										 TLibraryFunction& aLibFunctionProxy)

	{

	TAny* object = NULL; // Instantiation object

	TInstantiationL proxy = reinterpret_cast<TInstantiationL>(aLibFunctionProxy);

	TImplementationProxy* implementationProxyRow = NULL;

	TAny* newLPointer = GetNewLPointerAndProxyTableRowL<TImplementationProxy,TInstantiationL>(aUniqueImplementationUid,implementationProxyRow,proxy);

	// Now create an instance info object to store the information about this instance derived from

	// the parameters just fetched. This must be created here since no leaves can occur after the object

	// instantiation below.

	CInstanceInfoSimple* instanceInfoSimple = CInstanceInfoSimple::NewL(aPolicy,implementationProxyRow);

	CleanupStack::PushL(instanceInfoSimple);

	// The pointer to instanceInfo will be used to identify this instance, and will

	// be returned to the caller for future identification of this instance.

	aInstanceKey.iUid = reinterpret_cast<TInt32>(instanceInfoSimple);

	// Add item to instance info list. This list will contain all of the instance objects.

	iInstanceInfoList.InsertInAddressOrderL(instanceInfoSimple);

	// Get the implementation object using the instantiation pointer fetched earlier. Note

	// that the object creation must be the last leaving operation to be performed. No leaves can occur

	// after this operation, as the instantiation object cannnot be deleted on the cleanup stack if

	// a leave occurs (cannot delete a TAny* pointer, the type is not known within ECOM).

	object = ImplementationObjectL(aCreationParameters, 

	 aCreationParamsFlag,newLPointer);

	CleanupStack::Pop(instanceInfoSimple);

	return object;

	}

/**

Returns an implementation object to satisfy the specified interface.

@param			aUniqueImplementationUid The implementation to find.

@param			aCreationParameters A pointer to the creation parameter

				structure passed to the creation method when called.

@param			aCreationParamsFlag A boolean flag to indicate the existence or non-existence

				of aCreationParameters. Will be ETrue even for if the value of

				aCreationParameters is NULL.

@param          aInstanceKey A key specifying a previously created implementation.

@param          aPolicy policy of implementation

@param          aLibFunctionProxy Library function proxy pointer.

@return			TAny* a pointer to the fully constructed instantiation. The pointer is

				guaranteed to be valid only until DestroyedThis is called.

*/

TAny* CLoadManager::ImplementationObject3L(const TUid& aUniqueImplementationUid,

										 TAny* aCreationParameters,

										 TBool aCreationParamsFlag,

										 TUid& aInstanceKey,

										 CUnloadPolicy* aPolicy,

										 TLibraryFunction& aLibFunctionProxy)

	{

	TAny* object = NULL;  // Instantiation object

	TInstantiation3L proxy = reinterpret_cast<TInstantiation3L>(aLibFunctionProxy);

	TImplementationProxy3* implementationProxyRow = NULL;

	TAny* newLPointer = GetNewLPointerAndProxyTableRowL<TImplementationProxy3,TInstantiation3L>(aUniqueImplementationUid,implementationProxyRow,proxy);

	// Now create an instance info object to store the information about this instance derived from

	// the parameters just fetched. This must be created here since no leaves can occur after the object

	// instantiation below.

	CInstanceInfoExtended* instanceInfoExtended = CInstanceInfoExtended::NewL(aPolicy,implementationProxyRow);

	CleanupStack::PushL(instanceInfoExtended);

	// The pointer to instanceInfo will be used to identify this instance, and will

	// be returned to the caller for future identification of this instance.

	aInstanceKey.iUid = reinterpret_cast<TInt32>(instanceInfoExtended);

	// Add item to instance info list. This list will contain all of the instance objects.

	iInstanceInfoList.InsertInAddressOrderL(instanceInfoExtended);

	// Get the implementation object using the instantiation pointer fetched earlier. Note

	// that the object creation must be the last leaving operation to be performed. No leaves can occur

	// after this operation, as the instantiation object cannnot be deleted on the cleanup stack if

	// a leave occurs (cannot delete a TAny* pointer, the type is not known within ECOM).

	object = ImplementationObjectL(aCreationParameters, 

	 aCreationParamsFlag,newLPointer);

	// The extended instance info requires an object set. This is done here

	// as the object is not known until now, but the instance info object was required to

	// be created earlier to avoid a leave after the object creation.

	instanceInfoExtended->SetObject(object);

	CleanupStack::Pop(instanceInfoExtended);

	return object;

	}

/**

Gets the main implementation object using the instantiation pointer provided

@param			aCreationParameters A pointer to the creation parameter

				structure passed to the creation method when called.

@param			aCreationParamsFlag A boolean flag to indicate the existence or non-existence

				of aCreationParameters. Will be ETrue even for if the value of

				aCreationParameters is NULL.

@param			aNewLpointer Instantation pointer.

				aCreationParameters is NULL.

@return			TAny* a pointer to the fully constructed instantiation.

*/

TAny* CLoadManager::ImplementationObjectL(TAny* aCreationParameters,

										 TBool aCreationParamsFlag,

										 const TAny* aNewLpointer)

	{

	TAny* object=NULL;

	// So cast to the correct type : This gives an ANSI C++ warning

	// When using a REINTERPRET_CAST so simply cast instead

	// Two different object creation one with creation parameters

	if (aCreationParamsFlag)

		{

		typedef TAny* (*TNewL)(TAny*);

		TNewL creationL = (TNewL)(aNewLpointer);

		object=creationL(aCreationParameters);

		}

	else

		{

		typedef TAny* (*TNewL)();

		TNewL creationL = (TNewL)(aNewLpointer);

		object=creationL();

		}

	return object;

	}

/**

Get the unload policy.

@param			aUniqueImplementationUid The implementation to find.

@param			aEntry Information on the dll containing the implementation

@param			aPolicy Return parameter containing the policy

@return			None

*/

void CLoadManager::GetUnloadPolicy(TUid aUniqueImplementationUid,

							  const TEntry& aEntry,

							  CUnloadPolicy*& aPolicy)

	{

	const TInt numImps = iInstanceInfoList.Count();

	TBool foundImp = EFalse;

	TInt matchingDllIndex=0;

	TBool matchingDllFound=EFalse;

	CUnloadPolicy* policy = NULL;

	for (TInt index = 0; (index<numImps) && !foundImp; ++index)

		{

		//Check if there is existing mapping between the supplied implUid and a policy

		if(iInstanceInfoList[index]->ImplementationUid() == aUniqueImplementationUid)

			{

			policy = iInstanceInfoList[index]->UnloadPolicy();

			foundImp = ETrue;

			}

		else

			{

			//if cannot find a mapping entry but current index has the same DLL as the one requested from

			//the client, store the index to this unloadPolicy for use later on if we have finished

			//searching the entire mapping list

			if (!matchingDllFound && (iInstanceInfoList[index]->UnloadPolicy()->DllEntryInformation().GetName()).CompareF(aEntry.iName)==0)

				{

				matchingDllIndex=index;

				matchingDllFound=ETrue;

				}

			}

		}

	//If we cannot find any mapping in the policy index array(iUnloadPolicyMapping)

	if(!foundImp)

		{

		//if not found but there is a matching DLL,we can simply create a new policy index mapping without

		//having to load the library again.

		if (matchingDllFound)

			{

			policy = iInstanceInfoList[matchingDllIndex]->UnloadPolicy();

			}

		}

	aPolicy = policy;

	}

/**

Clears the policy inside the iGarbagePolicies attribute.

@pre			CLoadManager is fully constructed

@post			CLoadManager iGarbagePolicies is zero'd

*/

void CLoadManager::ClearGarbage()

	{

	if (iGarbagePolicy != NULL)

		{

		delete iGarbagePolicy;

		iGarbagePolicy=0;

		}

	}

CLoadManager::CLoadManager() :

	CBase()

	{

	// Do nothing here

	}

/**

Returns the implementation ID for a given instance Key.

@leave			KErrNotFound

@param			aInstanceKey A key specifying a previously created implementation instance.

@return			TUid The uid of the corresponding implementation.

@pre 			CLoadManager is fully constructed,

@post			CLoadManager remains the same.

*/

TUid CLoadManager::GetImplementationUidL(TUid aInstanceKey)

	{

	// Sanity check that the pointer is divisible by four. A binary number is divisible

	// by four if and only if the two rightmost bits are both zero.

	// This is a compromised check for checking that the pointer is an address.

    if ((aInstanceKey.iUid == 0) || ((aInstanceKey.iUid & 0x00000003) != 0))

        {

	    __ASSERT_DEBUG(EFalse, User::Panic(KEComClientDLLPanicCategory, EEComPanic_InvalidImplementationInstanceKey));

	    User::Leave(KErrNotFound);

        }

	// The instance info pointer is stored in the instance key.

	CInstanceInfo* instanceInfo = reinterpret_cast<CInstanceInfo*>(aInstanceKey.iUid);

	// Check that the pointer exists before using it - leaves with KErrNotFound

	iInstanceInfoList.FindInAddressOrderL(instanceInfo);

	return instanceInfo->ImplementationUid();

	}

/**

Fetches the requested extended interface from a specified implementation instance.

@leave			KErrNotFound

@param 			aInstanceKey A key specifying a previously created implementation.

@param 			aExtendedInterfaceUid Identifies an interface to fetch from the plug-in instance.

@return			TAny* A pointer to the extended interface, will be NULL if it does not exist.

*/

TAny* CLoadManager::GetExtendedInterfaceL(const TUid& aInstanceKey, const TUid& aExtendedInterfaceUid)

	{

	// Sanity check that the pointer is divisible by four. A binary number is divisible

	// by four if and only if the two rightmost bits are both zero.

	// This is a compromised check for checking that the pointer is an address.

    if ((aInstanceKey.iUid == 0) || ((aInstanceKey.iUid & 0x00000003) != 0))

        {

	    __ASSERT_DEBUG(EFalse, User::Panic(KEComClientDLLPanicCategory, EEComPanic_InvalidImplementationInstanceKey));

	    User::Leave(KErrNotFound);

        }

	// The instance info pointer is stored in the instance key.

	CInstanceInfo* instanceInfo = reinterpret_cast<CInstanceInfo*>(aInstanceKey.iUid);

	// Check that the pointer exists before using it - leaves with KErrNotFound

	iInstanceInfoList.FindInAddressOrderL(instanceInfo);

	// Create the extension object. The instance info object will be populated with

	// the extension info during creation.

	TAny* object = instanceInfo->CreateExtObjectL(aExtendedInterfaceUid);

	return object;

	}

/**

Manually releases the requested interface. Does nothing if it does not exist.

This interface is optional, normally the interfaces are cleaned up automatically.

@leave			KErrNotFound

@param			aInstanceKey A key specifying a previously created implementation.

@param			aExtendedInterfaceUid Identifies the interface to release

@return None.

*/

void CLoadManager::ManuallyReleaseExtendedInterfaceL(const TUid& aInstanceKey, const TUid& aExtendedInterfaceUid)

	{

	// Sanity check that the pointer is divisible by four. A binary number is divisible

	// by four if and only if the two rightmost bits are both zero.

	// This is a compromised check for checking that the pointer is an address.

    if ((aInstanceKey.iUid == 0) || ((aInstanceKey.iUid & 0x00000003) != 0))

        {

	    __ASSERT_DEBUG(EFalse, User::Panic(KEComClientDLLPanicCategory, EEComPanic_InvalidImplementationInstanceKey));

	    User::Leave(KErrNotFound);

        }

	// The instance info pointer is stored in the instance key.

	CInstanceInfo* instanceInfo = reinterpret_cast<CInstanceInfo*>(aInstanceKey.iUid);

	// Check that the pointer exists before using it - leaves with KErrNotFound

	iInstanceInfoList.FindInAddressOrderL(instanceInfo);

	instanceInfo->DestroyExtObject(aExtendedInterfaceUid);

	}

/**

Utility method to move the policy to the garbage list, remove

policy from the unload policy list.

@param aPolicy Unload policy to clean up

@return None.

*/

void CLoadManager::Cleanup(CUnloadPolicy* aPolicy)

	{

	if (aPolicy->DecreaseReference() == EDeleteMe)

		{

		// Move the policy to the garbage list

		iGarbagePolicy=aPolicy;

		TInt index = iAllUnloadPolicies.Find(aPolicy);

		if (index != KErrNotFound)

			{

			iAllUnloadPolicies.Remove(index);

			}

		}

	}

//

// CInstanceInfo

/**

Default constructor of CInstanceInfo

@param			aUnloadPolicy The CUnloadPolicy of the dll

*/

CInstanceInfo::CInstanceInfo(CUnloadPolicy* aUnloadPolicy):

	iUnloadPolicy(aUnloadPolicy)

	{

	// Do nothing here

	}

/** 

Destructor of CInstanceInfo

*/

CInstanceInfo::~CInstanceInfo()

	{

	// Do nothing here

	}

//

// CInstanceInfoExtended

/**

Default constructor of CInstanceInfoExtended

@param			aUnloadPolicy The CUnloadPolicy of the dll

@param			aImplementationProxyRow The interface implementation proxy row entry

*/

CInstanceInfoExtended::CInstanceInfoExtended(CUnloadPolicy* aUnloadPolicy,const TImplementationProxy3* aImplementationProxyRow):

	CInstanceInfo(aUnloadPolicy),iImplementationProxyRow(aImplementationProxyRow)

	{

	// Do nothing here

	}

/**

create an instance of CInstanceInfoExtended

@param			aUnloadPolicy The CUnloadPolicy of the dll

@param			aImplementationProxyRow The interface implementation proxy row entry

@return			A pointer to the newly created object.

*/

CInstanceInfoExtended* CInstanceInfoExtended::NewL(CUnloadPolicy* aUnloadPolicy,const TImplementationProxy3* aImplementationProxyRow)

	{

	return new(ELeave) CInstanceInfoExtended(aUnloadPolicy,aImplementationProxyRow);

	}

/**

Sets the implementation object.

@param			aImplementationObject The object instance of this instances' implementation

@return			None

*/

void CInstanceInfoExtended::SetObject(TAny* aImplementationObject)

	{

	iImplementationObject = aImplementationObject;

	}

/**

Creates the extension interface object. This will use the get extended interface

function pointer from the proxy table to fetch the extended interface from the

plug-in implementation.

@param			aExtendedInterfaceUID The extended interface UID

@return			TAny* A pointer to an instance of an extended interface created

*/

TAny* CInstanceInfoExtended::CreateExtObjectL(const TUid& aExtendedInterfaceUID)

	{

	// Fetch the function pointer to create the extended interface

	TProxyExtendedInterfaceGetPtrL createFunctionPtrL = iImplementationProxyRow->iFuncPtrInterfaceGetL;

	if (createFunctionPtrL == NULL)

		{

		// No extension interface object can be created. Return NULL indicating that

		// no extended interface object is available.

		return NULL;

		}

	// Valid function pointer exists in proxy table.

	TAny* object = NULL;         // Extended interface object (this points to the interface

							     // within the object)

	TAny* releaseObject = NULL;  // Eextended interface object (this points to the extended

								 // object itself). Used to delete the extended interface

								 // object later.

	TUint32 flags = 0;           // Flags to allow the plug-in and ECOM to communicate

	// Create the extension object.

	object = createFunctionPtrL(iImplementationObject,aExtendedInterfaceUID,flags,releaseObject);

	if (flags & KReleaseRequiredMask)

		{

		// If release of the extended interface is required then save the release object pointer.

		// The interface object (returned by the function pointer call) and the release object

		// are not necessarily the same pointer. This is because the  interface pointer is not

		// guaranteed to be the same as the pointer to the extended interface object. That

		// is why the release object is required to be fetched from the plug-in.

        // First perform some checks to ensure that the plugin is consistent 

        TProxyExtendedInterfaceReleasePtr release = iImplementationProxyRow->iFuncPtrInterfaceRelease;

        if (release == NULL)

            {

            // ...the release object pointer must not be non null

            __ECOM_TRACE("ECOM: PANIC in CInstanceInfoExtended::CreateExtObjectL, release required but release function missing");

	        __ASSERT_DEBUG(EFalse, User::Panic (KEComClientDLLPanicCategory, EEComPanic_CInstanceInfoExtended_CreateExtObjectL_NoReleaseFunc));

            User::Leave(KEComErrNoExtendedInterfaceReleaseFunction);

            }

        if (releaseObject == NULL)

            {

            // ... the releaseObject must be non null

            __ECOM_TRACE("ECOM: PANIC in CInstanceInfoExtended::CreateExtObjectL, release required but release object missing");

	        __ASSERT_DEBUG(EFalse, User::Panic (KEComClientDLLPanicCategory, EEComPanic_CInstanceInfoExtended_CreateExtObjectL_NoReleaseObj));

           User::Leave(KEComErrNoExtendedInterfaceReleaseObject);

 		    }

		//Create the extended object info type and add it to the extended object info array.

		TExtendedObjectInfo extendedObjectInfo;

		extendedObjectInfo.iExtendedInterfaceObject = releaseObject;

		extendedObjectInfo.iExtendedInterfaceUID = aExtendedInterfaceUID;

		TInt err = iExtendedObjectInfo.Append(extendedObjectInfo);

		if (err != KErrNone)

			{

			if (release != NULL)

				{

				// Release the extended interface. Release must not leave.

				release(extendedObjectInfo.iExtendedInterfaceObject,extendedObjectInfo.iExtendedInterfaceUID);

				}

			User::Leave(err);

			}

		}

	return object;

	}

/**

Destroys the extension interface object.

@param			aExtendedInterfaceUID The extended interface UID

@return			None

*/

void CInstanceInfoExtended::DestroyExtObject(const TUid& aExtendedInterfaceUID)

	{

	// Get release interface

	TProxyExtendedInterfaceReleasePtr release = iImplementationProxyRow->iFuncPtrInterfaceRelease;

	if (release != NULL)

		{

		// Release extended interface. Find the extended object info.

		for(TInt i = 0; i < iExtendedObjectInfo.Count(); i++)

			{

			if (iExtendedObjectInfo[i].iExtendedInterfaceUID == aExtendedInterfaceUID)

				{

				TAny* releaseObject = iExtendedObjectInfo[i].iExtendedInterfaceObject;

                if (releaseObject == NULL)

                    {

                    // ... the releaseObject must be non null

                    __ECOM_TRACE("ECOM: PANIC in CInstanceInfoExtended::DestroyExtObject, release required but release object missing");

	                __ASSERT_DEBUG(EFalse, User::Panic (KEComClientDLLPanicCategory, EEComPanic_CInstanceInfoExtended_DestroyExtObject_NoReleaseObj));	              

		            }

				// Release the extended interface. Release should not be leaving.

				release(releaseObject, iExtendedObjectInfo[i].iExtendedInterfaceUID);

				// Remove the extended object info element from the array.

				iExtendedObjectInfo.Remove(i);

				break;

				}

			}

		}

	}

/**

Destructor of CInstanceInfoExtended

*/

CInstanceInfoExtended::~CInstanceInfoExtended()

	{

	// Get release interface

	if (iImplementationProxyRow != NULL)

		{

		TProxyExtendedInterfaceReleasePtr release = iImplementationProxyRow->iFuncPtrInterfaceRelease;

		if (release != NULL)

			{

			// Release all extended interfaces (if any still to be released)

			for(TInt i = 0; i < iExtendedObjectInfo.Count(); i++)

				{

				// Release is supposed to be non-leavable.

				release(iExtendedObjectInfo[i].iExtendedInterfaceObject,iExtendedObjectInfo[i].iExtendedInterfaceUID);

				}

			}

		}

	iExtendedObjectInfo.Close();

	}

//

// CInstanceInfoSimple

/**

Default constructor of CInstanceInfoSimple

@param			aUnloadPolicy The CUnloadPolicy of the dll

@param			aImplementationProxyRow The interface implementation proxy row entry

*/

CInstanceInfoSimple::CInstanceInfoSimple(CUnloadPolicy* aUnloadPolicy,const TImplementationProxy* aImplementationProxyRow):

	CInstanceInfo(aUnloadPolicy),iImplementationProxyRow(aImplementationProxyRow)

	{

	// Do nothing here

	}

/**

Create an instance of CInstanceInfoSimple

@param			aUnloadPolicy The CUnloadPolicy of the dll

@param			aImplementationProxyRow The interface implementation proxy row entry

@return			A pointer to the newly created object.

*/

CInstanceInfoSimple* CInstanceInfoSimple::NewL(CUnloadPolicy* aUnloadPolicy,const TImplementationProxy* aImplementationProxyRow)

	{

	return new(ELeave) CInstanceInfoSimple(aUnloadPolicy,aImplementationProxyRow);

	}