diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgr/usbman/server/SRC/CUsbDummyClassController.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usbmgmt/usbmgr/usbman/server/SRC/CUsbDummyClassController.cpp	Tue Feb 02 02:02:59 2010 +0200
@@ -0,0 +1,502 @@
+/*
+* 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 part of UsbMan USB Class Framework.
+*
+*/
+
+/**
+ @file
+*/
+
+#include "CUsbDummyClassController.h"
+#include <usb_std.h>
+#include "inifile.h"
+#include <usb/usblogger.h>
+
+#ifdef __FLOG_ACTIVE
+_LIT8(KLogComponent, "USBSVR");
+#endif
+
+_LIT(KDummyControllerPanic, "UsbDummyCC"); // must be <=16 chars
+// Panic codes
+enum
+	{
+	// Bad value for the iSynchronicity member.
+	EDummyPanicBadSynchronicity = 0,
+	
+	// Used for environment errors we do not handle.
+	EDummyPanicUnhandledError = 1,
+	
+	// Used for bad iStatus and other state errors.
+	EDummyPanicBadState = 2,
+	
+	// Error reading ini file.
+	EDummyPanicBadIniFile = 3,
+	
+	// We already have our async request active.
+	EDummyPanicAlreadyActive = 4,
+	
+	// We already have a request outstanding from the device class. 
+	EDummyPanicOutstandingRequestFromDevice = 5,
+	
+	// Attempt to call Start() when in illegal state
+	EDummyPanicBadApiCallStart = 6,
+	
+	// Attempt to call Stop() when in illegal state
+	EDummyPanicBadApiCallStop = 7,
+	};
+
+const TInt KDummyClassPriority = 1;
+
+// Keys for reading the ini file.
+_LIT(KStartup, "Startup");
+_LIT(KShutdown, "Shutdown");
+_LIT(KType, "Type");
+_LIT(KTime, "Time");
+_LIT(KError, "Error");
+_LIT(KSync, "sync");
+_LIT(KAsync, "async");
+_LIT(KNever, "never");
+
+CUsbDummyClassController* CUsbDummyClassController::NewL(
+		MUsbClassControllerNotify& aOwner,
+		TUint aIndex)
+/**
+ * Constructs a CUsbDummyClassController object.
+ *
+ * @param aOwner USB Device that owns and manages the class
+ * @param aIndex The index number of the instance
+ * @return Ownership of a new CUsbDummyClassController object
+ */
+	{
+	LOG_STATIC_FUNC_ENTRY
+
+	CUsbDummyClassController* self = new(ELeave) CUsbDummyClassController(aOwner, aIndex);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+
+CUsbDummyClassController* CUsbDummyClassController::NewL(
+	MUsbClassControllerNotify& aOwner, 
+	TUint aIndex, TInt aPriority)
+/**
+ * Constructs a CUsbDummyClassController object.
+ *
+ * @param aOwner USB Device that owns and manages the class
+ * @param aIndex The index number of the instance
+ * @param aPriority The startup priority of the instance
+ * @return Ownership of a new CUsbDummyClassController object
+ */
+ 	{
+	LOG_STATIC_FUNC_ENTRY
+
+ 	CUsbDummyClassController* self = new(ELeave) CUsbDummyClassController(aOwner, aIndex, aPriority);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+ 	}
+ 
+CUsbDummyClassController::CUsbDummyClassController(
+		MUsbClassControllerNotify& aOwner,
+		TUint aIndex)
+/**
+ * Constructor.
+ *
+ * @param aOwner USB Device that owns and manages the class
+ * @param aIndex The index number of the instance
+ */
+ :	CUsbClassControllerBase(aOwner, KDummyClassPriority),
+	iIndex(aIndex)
+	{
+	iState = EUsbServiceIdle; // needs explicit initialisation as non-zero
+	}
+
+CUsbDummyClassController::CUsbDummyClassController(
+		MUsbClassControllerNotify& aOwner,
+		TUint aIndex, TInt aPriority)
+		
+/**
+ * Constructor.
+ *
+ * @param aOwner USB Device that owns and manages the class
+ * @param aIndex The index number of the instance
+ * @param aPriority a startup priority for the class controller
+ */		
+ : 	CUsbClassControllerBase(aOwner, aPriority),
+ 	iIndex(aIndex)
+ 	{
+ 	iState = EUsbServiceIdle; // needs explicit initialisation as non-zero
+ 	}
+		
+void CUsbDummyClassController::ConstructL()
+/**
+ * Method to perform second phase construction.
+ */
+	{
+	LEAVEIFERRORL(iTimer.CreateLocal());
+	}
+
+CUsbDummyClassController::~CUsbDummyClassController()
+/**
+ * Destructor.
+ */
+	{
+	Cancel();
+
+	iTimer.Close();
+	}
+	
+void CUsbDummyClassController::GetBehaviour(CIniFile& aIniFile, 
+											const TDesC& aSection, 
+											TBehaviour& aBehaviour)
+/**
+ * Reads information from the ini file, from a given section, to the given 
+ * behaviour structure.
+ *
+ * @param aIniFile The ini file to read from.
+ * @param aSection The section to reads from.
+ * @param aBehaviour The behaviour struct to read to.
+ */
+	{
+	LOG_FUNC
+#ifdef __FLOG_ACTIVE
+	TBuf8<KMaxName> buf;
+	buf.Copy(aSection);
+	LOGTEXT2(_L8("\taSection = %S"), &buf);
+#endif // __FLOG_ACTIVE
+
+	TPtrC temp;
+	if ( !aIniFile.FindVar(aSection, KType(), temp) )
+		{
+		LOGTEXT2(_L8("\tPANICKING: can't find Type item in section %S"), &aSection);
+		_USB_PANIC(KDummyControllerPanic, EDummyPanicBadIniFile);
+		}
+	if ( temp == KSync )
+		{
+		aBehaviour.iSynchronicity = ESynchronous;
+		}
+	else if ( temp == KAsync )
+		{
+		aBehaviour.iSynchronicity = EAsynchronous;
+		}
+	else if ( temp == KNever )
+		{
+		aBehaviour.iSynchronicity = ENever;
+		}
+	else
+		{
+		LOGTEXT3(_L8("\tPANICKING: bad Type value (%S) in section %S"), &temp, &aSection);
+		_USB_PANIC(KDummyControllerPanic, EDummyPanicBadIniFile);
+		}
+	TInt delay;
+	if ( !aIniFile.FindVar(aSection, KTime(), delay) )
+		{
+		LOGTEXT2(_L8("\tPANICKING: can't find Time item in section %S"), &aSection);
+		_USB_PANIC(KDummyControllerPanic, EDummyPanicBadIniFile);
+		}
+	aBehaviour.iDelay = delay;
+	if ( !aIniFile.FindVar(aSection, KError(), aBehaviour.iErrorCode) )
+		{
+		LOGTEXT2(_L8("\tPANICKING: can't find Error item in section %S"), &aSection);
+		_USB_PANIC(KDummyControllerPanic, EDummyPanicBadIniFile);
+		}
+	}
+
+void CUsbDummyClassController::DoGetConfigL()
+/**
+ * Reads the config from the ini file.
+ */
+	{
+	LOG_FUNC
+
+	CIniFile* iniFile = CIniFile::NewL(_L("dummy.ini"));
+	CleanupStack::PushL(iniFile);
+	TName section;
+
+	// Read startup behaviour
+	section.Format(_L("%S.%d"), &KStartup(), iIndex);
+	GetBehaviour(*iniFile, section, iStartupBehaviour);
+	// Read shutdown behaviour
+	section.Format(_L("%S.%d"), &KShutdown(), iIndex);
+	GetBehaviour(*iniFile, section, iShutdownBehaviour);
+
+	CleanupStack::PopAndDestroy(iniFile);
+	}
+
+void CUsbDummyClassController::GetConfig()
+/**
+ * Reads the config from the ini file.
+ * Note that this is assumed to succeed. Any failure will break the test and 
+ * it's much cleaner to panic out of the test entirely rather than leave it to 
+ * the user to figure out what's gone wrong.
+ */
+	{
+	LOG_FUNC
+
+	// Always use dummy.ini. The entity setting up the test is responsible for 
+	// copying the correct file to c:\\dummy.ini. The first found 
+	// by FindByDir will be used. TODO: enforce c:\\.
+	TRAPD(err, DoGetConfigL());
+	if ( err != KErrNone )
+		{
+		_USB_PANIC(KDummyControllerPanic, EDummyPanicUnhandledError);
+		}
+	
+	LOGTEXT2(_L8("\tLogging dummy class controller behaviour for instance %d"), iIndex);
+	LOGTEXT2(_L8("\tiStartupBehaviour.iSynchronicity = %d"), iStartupBehaviour.iSynchronicity);
+	LOGTEXT2(_L8("\tiStartupBehaviour.iDelay = %d"), iStartupBehaviour.iDelay.Int());
+	LOGTEXT2(_L8("\tiStartupBehaviour.iErrorCode = %d"), iStartupBehaviour.iErrorCode);
+	LOGTEXT2(_L8("\tiShutdownBehaviour.iSynchronicity = %d"), iShutdownBehaviour.iSynchronicity);
+	LOGTEXT2(_L8("\tiShutdownBehaviour.iDelay = %d"), iShutdownBehaviour.iDelay.Int());
+	LOGTEXT2(_L8("\tiShutdownBehaviour.iErrorCode = %d"), iShutdownBehaviour.iErrorCode);
+	}
+
+void CUsbDummyClassController::Start(TRequestStatus& aStatus)
+/**
+ * Called by UsbMan to start this class.
+ *
+ * @param aStatus Will be completed with success or failure.
+ */
+	{
+	LOG_FUNC
+	
+	//Start() should only be called if the CC is idle or started		
+	__ASSERT_DEBUG((iState == EUsbServiceIdle || iState == EUsbServiceStarted), 
+							_USB_PANIC(KDummyControllerPanic, EDummyPanicBadApiCallStart) );
+
+	// Get config from ini file. Note that can't be done once in ConstructL 
+	// because then, in the case of a CC which doesn't Stop, we'd never be 
+	// able to shut down USBMAN!
+	GetConfig();
+
+	// NB We enforce that the device doesn't re-post requests on us.
+	__ASSERT_DEBUG(!iReportStatus, 
+		_USB_PANIC(KDummyControllerPanic, EDummyPanicOutstandingRequestFromDevice));
+	aStatus = KRequestPending;
+	iReportStatus = &aStatus;
+	
+	iState = EUsbServiceStarting;
+
+	switch ( iStartupBehaviour.iSynchronicity )
+		{
+	case ESynchronous:
+		User::After(iStartupBehaviour.iDelay);
+		iState = EUsbServiceStarted;
+		User::RequestComplete(iReportStatus, iStartupBehaviour.iErrorCode);
+		iReportStatus = NULL;
+		break;
+
+	case EAsynchronous:
+		iTimer.After(iStatus, iStartupBehaviour.iDelay);
+		__ASSERT_DEBUG(!IsActive(), _USB_PANIC(KDummyControllerPanic, EDummyPanicAlreadyActive));		
+		SetActive();
+		break;
+
+	case ENever:
+		// Don't do anything and never complete
+		break;
+
+	default:
+		_USB_PANIC(KDummyControllerPanic, EDummyPanicBadSynchronicity);
+		break;
+		}
+	}
+
+void CUsbDummyClassController::Stop(TRequestStatus& aStatus)
+/**
+ * Called by UsbMan to stop this class.
+ *
+ * @param aStatus Will be completed with success or failure.
+ */
+	{
+	LOG_FUNC
+		
+	//Stop() should only be called if the CC is Started or Idle
+	__ASSERT_DEBUG((iState == EUsbServiceStarted || iState == EUsbServiceIdle), 
+				_USB_PANIC(KDummyControllerPanic, EDummyPanicBadApiCallStop));
+	
+	// Get config from ini file. Note that can't be done once in ConstructL 
+	// because then, in the case of a CC which doesn't Stop, we'd never be 
+	// able to shutdown USBMAN!
+	GetConfig();
+
+	// NB We enforce that the device doesn't re-post requests on us.
+	__ASSERT_DEBUG(!iReportStatus, 
+		_USB_PANIC(KDummyControllerPanic, EDummyPanicOutstandingRequestFromDevice));
+	aStatus = KRequestPending;
+	iReportStatus = &aStatus;
+
+	iState = EUsbServiceStopping;
+
+	switch ( iShutdownBehaviour.iSynchronicity )
+		{
+	case ESynchronous:
+		User::After(iShutdownBehaviour.iDelay);
+		iState = EUsbServiceIdle;
+		User::RequestComplete(iReportStatus, iShutdownBehaviour.iErrorCode);
+		iReportStatus = NULL;
+		break;
+
+	case EAsynchronous:
+		iTimer.After(iStatus, iShutdownBehaviour.iDelay);
+    	__ASSERT_DEBUG(!IsActive(), _USB_PANIC(KDummyControllerPanic, EDummyPanicAlreadyActive));		
+		SetActive();
+		break;
+
+	case ENever:
+		// Don't do anything and never complete
+		break;
+
+	default:
+		_USB_PANIC(KDummyControllerPanic, EDummyPanicBadSynchronicity);
+		break;
+		}
+	}
+
+void CUsbDummyClassController::GetDescriptorInfo(TUsbDescriptor& aDescriptorInfo) const
+/**
+ * Returns information about the interfaces supported by this class.
+ *
+ * @param aDescriptorInfo Will be filled in with interface information.
+ */
+	{
+	aDescriptorInfo.iNumInterfaces = 0;
+	aDescriptorInfo.iLength = 0;
+	}
+
+void CUsbDummyClassController::RunL()
+/**
+ * Standard active object RunL. 
+ */
+	{
+	LOGTEXT3(_L8(">>CUsbDummyClassController::RunL [iStatus=%d,iState=%d]"),
+			iStatus.Int(), iState);
+
+	if ( iStatus != KErrNone )
+		{
+		// Panic runtime errors from the timer. We can't ignore them, and 
+		// there's no point trying to code round them. This is part of the 
+		// test framework and if it's failing we want to alert the user 
+		// without faffing around. (It invalidates the test.)
+		_USB_PANIC(KDummyControllerPanic, EDummyPanicUnhandledError);
+		}								  
+
+	__ASSERT_DEBUG(iReportStatus, 
+		_USB_PANIC(KDummyControllerPanic, EDummyPanicBadState));
+
+	switch ( iState )
+		{
+	case EUsbServiceStarting:
+		// Completion of asynchronous startup...
+		__ASSERT_DEBUG(iStartupBehaviour.iSynchronicity == EAsynchronous, 
+			_USB_PANIC(KDummyControllerPanic, EDummyPanicBadSynchronicity));
+		iState = EUsbServiceStarted;
+		User::RequestComplete(iReportStatus, iStartupBehaviour.iErrorCode);
+		iReportStatus = NULL;
+		break;
+
+	case EUsbServiceStopping:
+		// Completion of asynchronous shutdown...
+		__ASSERT_DEBUG(iShutdownBehaviour.iSynchronicity == EAsynchronous, 
+			_USB_PANIC(KDummyControllerPanic, EDummyPanicBadSynchronicity));
+		iState = EUsbServiceIdle;
+		User::RequestComplete(iReportStatus, iShutdownBehaviour.iErrorCode);
+		iReportStatus = NULL;
+		break;
+
+	case EUsbServiceIdle:
+	case EUsbServiceStarted:
+	default:
+		_USB_PANIC(KDummyControllerPanic, EDummyPanicBadState);
+		break;
+		}
+
+	LOGTEXT(_L8("<<CUsbDummyClassController::RunL"));
+	}
+
+void CUsbDummyClassController::DoCancel()
+/**
+ * Standard active object cancellation function. 
+ */
+	{
+	LOG_FUNC
+
+	// Note that CActive::Cancel does not call DoCancel unless we are active. 
+	// Therefore we are at this point active. Therefore, we should have 
+	// iReportStatus pointing to something. This is true whether we are in 
+	// our destructor or being cancelled by the device. It is also true that 
+	// (for us to be active at all) our synchronicity should be set to async 
+	// and the timer must have been CreateLocal'd successfully.
+
+	// Cancel may be called in one of the following situations: 
+	// 1/ In our destructor. 
+	// 2/ The device wants to cancel us in the middle of a Start before 
+	// issuing a Stop (or vice versa). Note that the device may cancel us in 
+	// the middle of a Start, then immediately issue another Start.
+	
+	// Cancel our own asynchronous operation.
+	__ASSERT_DEBUG(iTimer.Handle(), 
+		_USB_PANIC(KDummyControllerPanic, EDummyPanicBadState));
+	iTimer.Cancel();
+
+	// Update our iState. If we're starting, then roll back to idle. If we're 
+	// stopping, role back to started. Nothing else is legal.
+	switch ( iState )
+		{
+	case EUsbServiceStarting:
+		__ASSERT_DEBUG(iStartupBehaviour.iSynchronicity == EAsynchronous, 
+			_USB_PANIC(KDummyControllerPanic, EDummyPanicBadSynchronicity));
+		iState = EUsbServiceIdle;
+		break;
+
+	case EUsbServiceStopping:
+		__ASSERT_DEBUG(iShutdownBehaviour.iSynchronicity == EAsynchronous, 
+			_USB_PANIC(KDummyControllerPanic, EDummyPanicBadSynchronicity));
+		iState = EUsbServiceStarted;
+		break;
+
+	case EUsbServiceIdle:
+	case EUsbServiceStarted:
+	default:
+		_USB_PANIC(KDummyControllerPanic, EDummyPanicBadState);
+		break;
+		}
+
+	// Complete the client's request.	
+	__ASSERT_DEBUG(iReportStatus, 
+		_USB_PANIC(KDummyControllerPanic, EDummyPanicBadState));
+	User::RequestComplete(iReportStatus, KErrCancel); 
+	iReportStatus = NULL;
+	}
+
+TInt CUsbDummyClassController::RunError(TInt /*aError*/)
+/**
+ * Standard active object error-handling function. 
+ *
+ * Should return KErrNone to avoid an active scheduler panic. This function
+ * should never be called as there is another mechanism for catching errors.
+ */
+	{
+	__ASSERT_DEBUG(EFalse, 
+		_USB_PANIC(KDummyControllerPanic, EDummyPanicBadState));
+	return KErrNone;
+	}
+
+//
+// End of file