diff -r 000000000000 -r bde4ae8d615e os/ossrv/lowlevellibsandfws/pluginfw/Framework/frame/LoadManager.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/ossrv/lowlevellibsandfws/pluginfw/Framework/frame/LoadManager.h	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,192 @@
+// 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:
+//
+
+
+#ifndef __LOADMANAGER_H__
+#define __LOADMANAGER_H__
+
+#include <e32base.h>
+#include <ecom/extendedinterfaceimplementationproxy.h>
+//Forward declarations
+class CUnloadPolicy;
+
+/**
+@internalComponent
+Represents an instance of an implementation
+*/
+NONSHARABLE_CLASS(CInstanceInfo): public CBase
+	{
+public:
+	virtual ~CInstanceInfo();
+	CUnloadPolicy* UnloadPolicy() {return iUnloadPolicy;};
+public:
+	virtual TUid ImplementationUid() = 0;
+    virtual TProxyExtendedInterfaceGetPtrL ProxyExtendedIntGetPtr() = 0;
+    virtual TProxyExtendedInterfaceReleasePtr ProxyExtendedIntReleasePtr() = 0;
+    virtual TAny* CreateExtObjectL(const TUid& aExtendedInterfaceUID) = 0;
+    virtual void DestroyExtObject(const TUid& aExtendedInterfaceUID) = 0;
+    virtual TAny* ImplementationObject() = 0;
+protected:
+    CInstanceInfo(CUnloadPolicy* aUnloadPolicy);
+private:
+   	// The Unload Policy for the dll which contains this implementation
+	CUnloadPolicy*	iUnloadPolicy;
+	};
+
+/**
+@internalComponent
+Represents an instance of a PLUGIN3 type implementation
+*/
+NONSHARABLE_CLASS(CInstanceInfoExtended): public CInstanceInfo
+{
+public:
+	static CInstanceInfoExtended* NewL(CUnloadPolicy* aUnloadPolicy,const TImplementationProxy3* aRow);
+	void SetObject(TAny* aImplementationObject);
+	~CInstanceInfoExtended(); // Release all extended objects (if not already released)
+public:
+    TUid ImplementationUid() {return iImplementationProxyRow->iImplementationUid;};
+    TProxyExtendedInterfaceGetPtrL ProxyExtendedIntGetPtr() {return iImplementationProxyRow->iFuncPtrInterfaceGetL;};
+    TProxyExtendedInterfaceReleasePtr ProxyExtendedIntReleasePtr() {return iImplementationProxyRow->iFuncPtrInterfaceRelease;};
+    TAny* CreateExtObjectL(const TUid& aExtendedInterfaceUID);
+    void DestroyExtObject(const TUid& aExtendedInterfaceUID);
+    TAny* ImplementationObject() {return iImplementationObject;};
+private:
+	CInstanceInfoExtended(CUnloadPolicy* aUnloadPolicy,const TImplementationProxy3* aImplementationProxyRow);
+private:
+   // Pointer to proxy implementation table row entry that this instance corresponds to.
+   // This is where the implementation UID, get and release extended interface function
+   // pointers reside.
+   const TImplementationProxy3* iImplementationProxyRow;
+   // The instantiation interface object for the dll which contains this implementation
+   TAny*	iImplementationObject;
+   // The created extended object information structure.
+   struct TExtendedObjectInfo
+	   {
+	   // The extended interface UID
+       TUid    iExtendedInterfaceUID;
+	   // The extended interface object for the this implementation
+	   TAny*   iExtendedInterfaceObject;
+	   };
+
+    // List of all of the created extended objects for this implementation
+	RArray<TExtendedObjectInfo> iExtendedObjectInfo;
+
+	// Friend classes
+	friend class TLoadManager_StateAccessor;
+};
+
+/**
+@internalComponent
+Represents an instance of a PLUGIN1 type implementation
+*/
+NONSHARABLE_CLASS(CInstanceInfoSimple): public CInstanceInfo
+{
+public:
+	static CInstanceInfoSimple* NewL(CUnloadPolicy* aUnloadPolicy,const TImplementationProxy* aImplementationProxyRow);
+public:
+    TUid ImplementationUid() {return iImplementationProxyRow->iImplementationUid;};
+	// The following functions are not required for CInstanceInfoSimple.
+	// PLUGIN1 type is not meant to extend interfaces.  	
+  	TProxyExtendedInterfaceGetPtrL ProxyExtendedIntGetPtr(){return NULL;};
+ 	TProxyExtendedInterfaceReleasePtr ProxyExtendedIntReleasePtr(){return NULL;};
+ 	TAny* CreateExtObjectL(const TUid& /*aExtendedInterfaceUID*/) {return NULL;};
+ 	void DestroyExtObject(const TUid& /* aExtendedInterfaceUID*/) {};
+	TAny* ImplementationObject() {return NULL;}; 
+
+private:
+	CInstanceInfoSimple(CUnloadPolicy* aUnloadPolicy,const TImplementationProxy* aImplementationProxyRow);
+
+private:
+   // Pointer to proxy implementation table row entry that this instance corresponds to.
+   // This is where the implementation UID resides.
+   const TImplementationProxy* iImplementationProxyRow;
+
+};
+
+/**
+@internalComponent
+Manages the loading and unloading of interface implementation groupings.
+*/
+NONSHARABLE_CLASS(CLoadManager) : public CBase
+{
+public:
+	static CLoadManager* NewL();
+	~CLoadManager();
+	TBool DestroyedThis(TUid aInstanceKey);
+
+	TBool PolicyArraysEmpty() const ;
+	
+	TAny* ImplementationObjectL(const TUid& aUniqueImplementationUid,
+							   const TEntry& aEntry,
+							   TAny* aCreationParameters,
+							   TBool aCreationParamsFlag,
+							   TUid& aInstanceKey);
+
+	TAny* GetExtendedInterfaceL(const TUid& aInstanceKey, const TUid& aExtendedInterfaceUid);
+	void ManuallyReleaseExtendedInterfaceL(const TUid& aInstanceKey, const TUid& aExtendedInterfaceUid);
+	void ClearGarbage();
+
+	TUid GetImplementationUidL(TUid aInstanceKey);
+
+private:
+	CLoadManager();
+
+	void GetUnloadPolicy(TUid aUniqueImplementationUid,
+						 const TEntry& aEntry,
+						 CUnloadPolicy*& aPolicy);
+
+	template<typename TImpProxy,typename T> TAny* GetNewLPointerAndProxyTableRowL(TUid aUniqueImplementationUid,
+										 TImpProxy*& aImplementationTableEntry,
+										 const T aProxy);
+
+	TAny* ImplementationObject1L(const TUid& aUniqueImplementationUid,
+						   	     TAny* aCreationParameters,
+								 TBool aCreationParamsFlag,
+								 TUid& aInstanceKey,
+								 CUnloadPolicy* aPolicy,
+								 TLibraryFunction& aLibFunctionProxy);
+
+	TAny* ImplementationObject3L(const TUid& aUniqueImplementationUid,
+						   	     TAny* aCreationParameters,
+								 TBool aCreationParamsFlag,
+								 TUid& aInstanceKey,
+								 CUnloadPolicy* aPolicy,
+								 TLibraryFunction& aLibFunctionProxy);
+
+	TAny* ImplementationObjectL(TAny* aCreationParameters,
+								TBool aCreationParamsFlag,
+								const TAny* aNewLpointer);
+
+	void CleanupAfterFailure(CUnloadPolicy* aPolicy);
+	void Cleanup(CUnloadPolicy* aPolicy);
+private:
+#ifdef ECOM_TRACE
+	/** Instantiation counter for debug trace */
+	TInt iDebugInstantiationCounter;
+#endif
+	/** List of all the UnloadPolicies for objects which have been created */
+	RPointerArray<CUnloadPolicy> iAllUnloadPolicies;
+	/** Garbage UnloadPolicy which is not in use anymore */
+	CUnloadPolicy* iGarbagePolicy;
+	// Array of instance information
+	RPointerArray<CInstanceInfo> iInstanceInfoList;
+
+	// Make the test State Accessor a friend
+	friend class TLoadManager_StateAccessor;
+};
+
+#include "loadmanager.inl"
+
+#endif //__LOADMANAGER_H__