--- a/vpnengine/sit/src/taskarrivalobserver.cpp Wed Sep 01 12:23:21 2010 +0100
+++ b/vpnengine/sit/src/taskarrivalobserver.cpp Tue Sep 14 23:16:15 2010 +0300
@@ -33,7 +33,6 @@
}
CTaskArrivalObserver::CTaskArrivalObserver()
- : CAsyncOneShot(EPriorityNormal)
{
}
@@ -49,8 +48,9 @@
LOG(Log::Printf(_L("CTaskArrivalObserver::~CTaskArrivalObserver\n")));
Cancel();
iEventMediator.Close();
+
if (iTaskHandlerList)
- {
+ {
iTaskHandlerList->ResetAndDestroy();
delete iTaskHandlerList;
}
@@ -116,62 +116,25 @@
{
LOG(Log::Printf(_L("CTaskArrivalObserver::LaunchTaskHandlerL\n")));
// A new task has arrived so create a task handler for it
- CTaskHandler* taskHandler = CreateTaskHandlerL(aEventSpec);
- // Add the handler to the list of active handlers
- iTaskHandlerList->AppendL(taskHandler);
-
- // And start performing the task
- taskHandler->Start();
- }
-
-CTaskHandler* CTaskArrivalObserver::CreateTaskHandlerL(const TTaskArrivedEventData& aEventSpec)
- {
- LOG(Log::Printf(_L("CTaskArrivalObserver::CreateTaskHandlerL\n")));
- CTaskHandler* taskHandler = NULL;
-
- taskHandler = TaskHandlerCreator::CreateTaskHandlerL(this, aEventSpec);
-
+ CTaskHandler* taskHandler = TaskHandlerCreator::CreateTaskHandlerL(this, aEventSpec);
if (!taskHandler)
{
User::Panic(KSitName, EPanicUnknownEventType);
}
-
- return taskHandler;
- }
+
+ // Add the handler to the list of active handlers
+ iTaskHandlerList->AppendL(taskHandler);
-TInt CTaskArrivalObserver::FindTaskHandler(CTaskHandler* aTaskHandler)
- {
- TInt foundIndex = KUnfoundIndex;
-
- for (TInt i = 0; i < iTaskHandlerList->Count(); i++)
- {
- if (iTaskHandlerList->At(i) == aTaskHandler)
- {
- foundIndex = i;
- break;
- };
- }
-
- return foundIndex;
+ //Create the asyncleaner for cleaning the task handler, when the
+ //task is done.
+ CAsyncCleaner* asyncCleaner = new (ELeave) CAsyncCleaner(this, taskHandler);
+ iAsyncCleanerList->AppendL(asyncCleaner);
+
+ // And start performing the task
+ taskHandler->Start();
}
-TInt CTaskArrivalObserver::FindAsyncCleaner(CAsyncCleaner* aAsyncCleaner)
- {
- TInt foundIndex = KUnfoundIndex;
-
- for (TInt i = 0; i < iAsyncCleanerList->Count(); i++)
- {
- if (iAsyncCleanerList->At(i) == aAsyncCleaner)
- {
- foundIndex = i;
- break;
- };
- }
-
- return foundIndex;
- }
-
void CTaskArrivalObserver::TaskHandlerComplete(CTaskHandler* aTaskHandler)
{
LOG(Log::Printf(_L("CTaskArrivalObserver::TaskHandlerComplete\n")));
@@ -181,98 +144,73 @@
// Otherwise we'll get panic E32USER-CBase 42 (SetActive called
// while active object is already active).
- // NOTE. Each asyncCleaner instance will cause itself to be deleted
- CAsyncCleaner* asyncCleaner = new CAsyncCleaner(this, aTaskHandler);
- if (asyncCleaner)
- {
- // Add the handler to a list of cleaners. This list
- // is needed to handle some rare cases where the SIT
- // thread dies before one or more async cleaners get
- // the chance to delete themselves. Such cleaner
- // instances get destroyed by the CTaskArrivalObserver
- // destructor.
- TRAP_IGNORE(iAsyncCleanerList->AppendL(asyncCleaner));
- // Initiate the task handler delete operation
- asyncCleaner->Start();
- }
- else
+ //Find the async cleaner for the task handler:
+ TInt i = 0;
+ for (i = 0; i < iAsyncCleanerList->Count(); ++i)
{
- // Backup - just in case asyncCleaner could not be created
- AsyncDeleteTaskHandler(aTaskHandler);
+ if (iAsyncCleanerList->At(i)->IsMatchingCleaner(*aTaskHandler))
+ {
+ iAsyncCleanerList->At(i)->Start();
+ }
}
- }
-
-void CTaskArrivalObserver::AsyncDeleteTaskHandler(CTaskHandler* aTaskHandler)
- {
- LOG(Log::Printf(_L("CTaskArrivalObserver::AsyncDeleteTaskHandler\n")));
- iTaskHandlerToDelete = aTaskHandler;
- Call();
- }
-
-void CTaskArrivalObserver::RunL() // Called as a result of AsyncDeleteTaskHandler
- {
- LOG(Log::Printf(_L("CTaskArrivalObserver::RunL\n")));
-
- DeleteTaskHandler(iTaskHandlerToDelete);
-
- iTaskHandlerToDelete = NULL;
+ __ASSERT_DEBUG(i <= iAsyncCleanerList->Count(), User::Invariant());
+
}
void CTaskArrivalObserver::DeleteTaskHandler(CTaskHandler* aTaskHandler)
{
LOG(Log::Printf(_L("CTaskArrivalObserver::DeleteTaskHandler\n")));
+ __ASSERT_DEBUG(aTaskHandler != NULL, User::Invariant());
+
// The specified task handler has done its
// job succesfully so it can be deleted
- TInt taskHandlerIndex = FindTaskHandler(aTaskHandler);
-
- if (taskHandlerIndex != KUnfoundIndex)
+ TInt taskHandlerIndex = KErrNotFound;
+
+ for (TInt i = 0; i < iTaskHandlerList->Count(); i++)
{
- LOG(Log::Printf(_L("CTaskArrivalObserver::DeleteTaskHandler - deleting task handler\n")));
- // Delete the task handler
- delete iTaskHandlerList->At(taskHandlerIndex);
- // Delete the list item
- iTaskHandlerList->Delete(taskHandlerIndex);
- // Deleting elements from the array does not cause
- // the array buffer to be automatically compressed.
- // Compress it to return excess space to the heap
- // as task handlers come and go.
- iTaskHandlerList->Compress();
+ if (iTaskHandlerList->At(i) == aTaskHandler)
+ {
+ taskHandlerIndex = i;
+ break;
+ };
}
- else
- {
- //
- delete aTaskHandler;
- }
+
+ __ASSERT_DEBUG(taskHandlerIndex >= 0, User::Invariant());
+
+ LOG(Log::Printf(_L("CTaskArrivalObserver::DeleteTaskHandler - deleting task handler\n")));
+ // Delete the task handler
+ delete aTaskHandler;
+ iTaskHandlerList->Delete(taskHandlerIndex);
+ iTaskHandlerList->Compress();
}
void CTaskArrivalObserver::DeleteAsyncCleaner(CAsyncCleaner* aAsyncCleaner)
{
LOG(Log::Printf(_L("CTaskArrivalObserver::DeleteAsyncCleaner\n")));
+ __ASSERT_DEBUG(aAsyncCleaner != NULL, User::Invariant());
+
// The specified asynchronous cleaner
// has done its job and be deleted
- TInt asyncCleanerIndex = FindAsyncCleaner(aAsyncCleaner);
- if (asyncCleanerIndex != KUnfoundIndex)
+ TInt asyncCleanerIndex = KErrNotFound;
+ for (TInt i = 0; i < iAsyncCleanerList->Count(); i++)
{
- LOG(Log::Printf(_L("CTaskArrivalObserver::DeleteAsyncCleaner - deleting async cleaner\n")));
- // Delete the cleaner object
- delete iAsyncCleanerList->At(asyncCleanerIndex);
- // Delete the list item
- iAsyncCleanerList->Delete(asyncCleanerIndex);
- // Deleting elements from the array does not cause
- // the array buffer to be automatically compressed.
- // Compress it to return excess space to the heap
- // as cleaner objects come and go.
- iAsyncCleanerList->Compress();
+ if (iAsyncCleanerList->At(i) == aAsyncCleaner)
+ {
+ asyncCleanerIndex = i;
+ break;
+ };
}
- else
- {
- // Always delete the cleaner instance even
- // though it have not been added to the list
- delete aAsyncCleaner;
- }
+
+ __ASSERT_DEBUG(asyncCleanerIndex >= 0, User::Invariant());
+
+ // Delete the cleaner object
+ delete aAsyncCleaner;
+ iAsyncCleanerList->Delete(asyncCleanerIndex);
+ iAsyncCleanerList->Compress();
+
}
void CTaskArrivalObserver::TaskHandlerFatalError(CTaskHandler* /*aTaskHandler*/, TInt /*aError*/)
@@ -310,3 +248,8 @@
// Delete this cleaner object instance as well
iTaskArrivalObserver->DeleteAsyncCleaner(this);
}
+
+TBool CAsyncCleaner::IsMatchingCleaner(const CTaskHandler& aTaskHandler) const
+ {
+ return iTaskHandlerToDelete == &aTaskHandler;
+ }