diff -r fa2fd8b2d6cc -r 2611c08ee28e httpfilters/cookie/ManagerSrc/CookieManagerClient.cpp
--- a/httpfilters/cookie/ManagerSrc/CookieManagerClient.cpp	Mon Mar 15 12:42:40 2010 +0200
+++ b/httpfilters/cookie/ManagerSrc/CookieManagerClient.cpp	Wed Mar 31 22:32:15 2010 +0300
@@ -23,6 +23,7 @@
 
 	// User includes
 #include "cookie.h"
+#include "CookieArray.h"
 #include "cookieipc.h"
 #include "CookieCommonConstants.h"
 #include "CookieLogger.h"
@@ -30,9 +31,9 @@
 #include "CookieManagerServer.h"
 #include "CookieManagerStart.h"
 #include "CookieServerDef.h"
-
+#include "CookieClientDataArray.h"
+#include "CookieClientData.h"
 // CONSTANTS
-
 // TBD : do we have to set limits to the number of cookies at all?
 // Possible answer : as we store cookies in an RPointerArray that has a
 // restriction on the number of elements (max. 640 can be stored in an RArray
@@ -80,7 +81,7 @@
 EXPORT_C TInt RCookieManager::Connect()
     {
     CLOG( ( EClientConnect, 0, _L( "-> RCookieManager::Connect" ) ) );
-
+    CCookieClientDataArray::GetInstance()->Ref();
     TInt error = KErrNone;
     RProcess server;
     error = server.Create( KCookieServerExe, TPtr( NULL, 0 ),
@@ -116,7 +117,7 @@
     }
 
 // ---------------------------------------------------------
-// RCookieManager::GetCookies
+// RCookieManager::DoGetCookies
 // ---------------------------------------------------------
 //
 TInt RCookieManager::DoGetCookies( TDes8& aBuffer ) const
@@ -125,25 +126,53 @@
 	}
 
 // ---------------------------------------------------------
-// RCookieManager::GetCookieSize
+// RCookieManager::GetCookieSharableFlagFromServer
+// ---------------------------------------------------------
+//
+TInt RCookieManager::GetCookieSharableFlagFromServer(TBool& aCookieSharableFlag )const
+    {
+    TPckg<TBool> cookieSharableFlag(aCookieSharableFlag);
+    return SendReceive( EGetCookieSharableFlag, TIpcArgs( &cookieSharableFlag ) );
+    }
+
+// ---------------------------------------------------------
+// RCookieManager::DoGetCookieSize
 // ---------------------------------------------------------
 //
 TInt RCookieManager::DoGetCookieSize( const TDesC8& aRequestUri,
-									  TPckg<TInt>& aPkgSize ) const
+									  TPckg<TInt>& aPkgSize,TDesC& aAppuidPtr ) const
 	{
-    return SendReceive( EGetCookieSize, TIpcArgs( aRequestUri.Length(), 
+    return SendReceive( EGetCookieSize, TIpcArgs( &aAppuidPtr,aRequestUri.Length(), 
                                                   &aRequestUri, &aPkgSize ) );
 	}
+// ---------------------------------------------------------
+// RCookieManager::DestroyCookiesFromMemory
+// ---------------------------------------------------------
+//
+TInt RCookieManager::DestroyCookiesFromMemory( TInt& aDeleteStatus )
+    {
+    CLOG(( EClient, 0, _L("-> RCookieManager::DestroyCookies") ));
+
+    TPckg<TInt> pkgStatus( aDeleteStatus );
+    TInt ret = SendReceive( EDestroyCookies, TIpcArgs( &pkgStatus ) ) ;
+
+    CLOG(( EClient, 0, 
+        _L("<- RCookieManager::DestroyCookies cleared %d cookies, errcode%d"),
+        aDeleteStatus, ret ) );
+
+    return ret;
+
+    }
 
 // ---------------------------------------------------------
 // RCookieManager::DoStoreCookie
 // ---------------------------------------------------------
 //
 TInt RCookieManager::DoStoreCookie( const TDesC8& aPackedCookie,
-								   const TDesC8& aUri ) const
+								   const TDesC8& aUri,TDesC& aAppUidPtr ) const
 	{
     return SendReceive( EStoreCookie, TIpcArgs( aPackedCookie.Length(), 
-                                      &aPackedCookie, aUri.Length(), &aUri ) );
+                                      &aPackedCookie, &aUri,&aAppUidPtr ) );
 	}
 
 // ---------------------------------------------------------
@@ -155,13 +184,30 @@
 										TBool& aCookie2Reqd )
     {
     CLOG( ( EClient, 0, _L( "-> RCookieManager::GetCookiesL" ) ) );
+    TBool cookiefound(EFalse);
+    CCookieClientDataArray* cookieclientdataarray = CCookieClientDataArray::GetInstance();
+    if(cookieclientdataarray) // redundant check
+        {
+    TInt clientarraycount = cookieclientdataarray->Count();
+    if ( clientarraycount!=0 )
+        {
+        TInt clerr = GetClientSideCookies(aUri,aCookies,cookiefound,0);
+        }
+      } 
 
+    if(!cookiefound)
+        {
 	aCookie2Reqd = EFalse;
 
 	TInt size = 0;
 	TPckg<TInt> pkgSize( size );
-	User::LeaveIfError( DoGetCookieSize( aUri, pkgSize ) );
-
+	//Appuid value only takes 8 chars
+    HBufC* appbuf = HBufC::New(8);
+    TPtr ptr(appbuf->Des());
+    TUint32 appUid(0);
+    ptr.AppendNum(appUid,EHex);    
+	User::LeaveIfError( DoGetCookieSize( aUri, pkgSize,ptr ) );
+    delete appbuf;
 	if ( size )
 		{
 		HBufC8* buf = HBufC8::NewLC( size );
@@ -196,7 +242,7 @@
 
 		CleanupStack::PopAndDestroy();	// buf
 		}
-
+      }
     CLOG( ( EClient, 0, _L( "<- RCookieManager::GetCookiesL" ) ) );
     }
 
@@ -223,7 +269,14 @@
 		err = iCookiePacker.CliPackCookie( bufDes, aCookie );
 		if ( !err )
 			{
-			err = DoStoreCookie( *buf, aUri.UriDes() );
+			//Appuid value only takes 8 chars
+            HBufC* appbuf = HBufC::New(8); // harendra: 8 chars needed
+            TPtr ptr(appbuf->Des());
+            TUint32 appUid(0);
+            ptr.AppendNum(appUid,EHex);    
+            err = DoStoreCookie( *buf, aUri.UriDes(),ptr );
+            delete appbuf;
+			//err = DoStoreCookie( *buf, aUri.UriDes() );
 			}
 
 		delete buf;
@@ -253,13 +306,30 @@
     }
     
 // ---------------------------------------------------------
-// RCookieManager::SetAppUidL
+// RCookieManager::SetAppUidL This method is no longer being 
+// used in CookieFilter.As this method is exported so in order
+// to provide backward compatibilty this API implementation is changed 
 // ---------------------------------------------------------
 //
 EXPORT_C TInt RCookieManager::SetAppUidL( const TUint32& aAppUid )
     {
     CLOG(( EClient, 0, _L("->RCookieManager::SetAppUid") ));   
-    HBufC* buf = HBufC::NewLC(128);
+    TUint32 groupid = RProcess().SecureId().iId;
+    CCookieClientData* cookieclientdata = CCookieClientDataArray::GetInstance()->Find(groupid, const_cast<TUint32&> (aAppUid));
+    if(cookieclientdata)
+        {
+        cookieclientdata->SetWidgetUid(aAppUid);
+        }
+    else
+        {
+        TBool cookieSharableFlag(EFalse);
+        TInt err = GetCookieSharableFlagFromServer(cookieSharableFlag);
+        CCookieClientData* cookieclientdata = CCookieClientData::NewL(groupid, aAppUid, cookieSharableFlag,ETrue);
+        cookieclientdata->SetInitFlag(ETrue);
+        CCookieClientDataArray::GetInstance()->AddClientGroupDataL(cookieclientdata);
+        }
+    //Appuid value only takes 8 chars
+    HBufC* buf = HBufC::NewLC(8);
     TPtr ptr(buf->Des());
     ptr.AppendNum(aAppUid,EHex);    
     TInt error = SendReceive(ESetAppUid,TIpcArgs(ptr.Length(),&ptr)); 
@@ -267,4 +337,255 @@
     CLOG(( EClient, 0, _L("<-RCookieManager::SetAppUid") ));
     return error;
     }
+// ---------------------------------------------------------
+// RCookieManager::Close
+// ---------------------------------------------------------
+//
+
+EXPORT_C void RCookieManager::Close()
+    {
+    CLOG(( EClient, 0, _L("-> RCookieManager::Close") ));
+    CCookieClientDataArray::GetInstance()->DeRef();
+    TInt deletestatus =0;
+    DestroyCookiesFromMemory(deletestatus);
+    CLOG(( EClient, 0, _L("-> RCookieManager::Close deletestatus = %d"), deletestatus ));
+    RSessionBase::Close();
+    CLOG(( EClient, 0, _L("<- RCookieManager::Close") ));
+    }
+// ---------------------------------------------------------
+// RCookieManager::StoreCookie Newly Added
+// ---------------------------------------------------------
+//
+EXPORT_C TInt RCookieManager::StoreCookie( const CCookie& aCookie,
+                                 const TUriC8& aUri,TUint32& aAppUid )
+    {
+    CLOG( ( EClient, 0, _L( "-> RCookieManager::StoreCookie" ) ) );
+    StoreCookieAtClientSide(&aCookie,aUri.UriDes(),aAppUid);
+    TInt err;
+
+    TInt cookieSize = aCookie.Size( EFalse );
+    HBufC8* buf = HBufC8::New( cookieSize );
+    if ( buf )
+        {
+        CLOG( ( EClient, 0,
+                _L( "RCookieManager::StoreCookie, cookie size:%d" ), 
+                cookieSize ) );
+
+        TPtr8 bufDes( buf->Des() );
+        err = iCookiePacker.CliPackCookie( bufDes, aCookie );
+        
+        if ( !err )
+            {
+            //Appuid value only takes 8 chars
+            HBufC* appbuf = HBufC::New(8);
+            TPtr ptr(appbuf->Des());
+            ptr.AppendNum(aAppUid,EHex);    
+            err = DoStoreCookie( *buf, aUri.UriDes(),ptr );
+            delete appbuf;
+            }
+
+        delete buf;
+        }
+    else
+        {
+        err = KErrNoMemory;
+        }
+
+    CLOG( ( EClient, 0,
+            _L( "<- RCookieManager::StoreCookie errcode%d" ), err ) );
+
+    return err;
+    }
+
+// ---------------------------------------------------------
+// RCookieManager::GetCookiesL Newly Added
+// ---------------------------------------------------------
+//
+EXPORT_C void RCookieManager::GetCookiesL( const TDesC8& aUri,
+                                        RPointerArray<CCookie>& aCookies,
+                                        TBool& aCookie2Reqd,TUint32& aAppUid )
+    {
+    CLOG( ( EClient, 0, _L( "-> RCookieManager::GetCookiesL" ) ) );
+    TBool cookiefound(EFalse);
+    CCookieClientDataArray* cookieclientdataarray = CCookieClientDataArray::GetInstance();
+    if(cookieclientdataarray)
+        {
+         TInt clientarraycount = cookieclientdataarray->Count();
+         if (clientarraycount == 0)
+           {
+            TUint32 groupid = RProcess().SecureId().iId;
+            TBool cookieSharableFlag(EFalse);
+            TInt err = GetCookieSharableFlagFromServer(cookieSharableFlag);
+            CCookieClientData* cookieclientdata = CCookieClientData::NewL(groupid, aAppUid, cookieSharableFlag,ETrue);
+            cookieclientdata->SetInitFlag(ETrue);
+            cookieclientdataarray->AddClientGroupDataL(cookieclientdata);
+           }
+         else
+           {
+        
+            CLOG( ( EClient, 0, _L( "-> RCookieManager::GetClientSideCookies:" ) ) );
+            //Gets the Cookie objects for aUri in case it is present
+            //TInt clerr = cookieclientdata->GetClientSideCookies(aUri,aCookies,cookiefound);
+            TInt clerr = GetClientSideCookies(aUri,aCookies,cookiefound,aAppUid);
+            CLOG( ( EClient, 0, _L( "RCookieManager::GetClientSideCookies:cookiefound = %d" ), cookiefound ) );
+        
+           }
+        } 
+    if(!cookiefound)
+        {
+            aCookie2Reqd = EFalse;
+            //Appuid value only takes 8 chars
+            HBufC* appuidbuf = HBufC::NewL(8);
+            TPtr ptr(appuidbuf->Des());
+            ptr.AppendNum(aAppUid,EHex);    
+            TInt size = 0;
+            TPckg<TInt> pkgSize( size );
+            User::LeaveIfError( DoGetCookieSize( aUri, pkgSize, ptr ) );
+            delete appuidbuf;
+        if ( size )
+            {
+            HBufC8* buf = HBufC8::NewLC( size );
+    
+            TPtr8 des( buf->Des() );
+            User::LeaveIfError( DoGetCookies( des ) );
+    
+            // it seems this is the only place where we cannot avoid leaving
+            // ==> we allocate memory for cookies when we fill up the cookie array.
+            iCookiePacker.UnpackCookiesFromBufferL( *buf, aCookies );
+    
+            TInt count = aCookies.Count();
+            for(TInt j=0; j<count; j++)
+                {
+                CLOG( ( EClient, 0, _L( "-> RCookieManager::StoreClientSideCookies: aUri=%S" ), &aUri ) );
+                //cookieclientdata->StoreCookieAtClientSide( aCookies[j],aUri );
+                StoreCookieAtClientSide( aCookies[j],aUri,aAppUid );
+                }
+            TInt i = 0;
+            TBool anyCookie2( EFalse );
+            TBool anyUnknownVersion( EFalse );
+            for ( ; i < count; i++ )
+                {
+                if ( aCookies[i]->FromCookie2() )
+                    {
+                    anyCookie2 = ETrue;
+                    anyUnknownVersion |= aCookies[i]->IsUnknownVersion();
+                    }
+                }
+    
+            // if there were no new-style cookies or a new version info is detected
+            // then we have to send an extra cookie header indicating that we're 
+            // able to process new-style cookies
+            if ( !anyCookie2 || anyUnknownVersion )
+                {
+                aCookie2Reqd = ETrue;
+                }
+    
+            CleanupStack::PopAndDestroy();  // buf
+            }
+      }
+    CLOG( ( EClient, 0, _L( "<- RCookieManager::GetCookiesL" ) ) );
+    }
+
+// ---------------------------------------------------------
+// RCookieManager::Close for Widget related destruction during 
+//uninstallation process of a widget
+// ---------------------------------------------------------
+//
+EXPORT_C TInt RCookieManager::ClearAllAppUidCookies(const TUint32& aAppUid)
+    {
+    CLOG(( EClient, 0, _L("-> RCookieManager::ClearCookies") ));
+    //Client side cookie deletion specific to a appuid
+    CCookieClientDataArray::GetInstance()->DestroyClientData(aAppUid);
+    //Server side Cookie deletion specific to a appuid
+    //Appuid value only takes 8 chars
+    HBufC* buf = HBufC::NewLC(8);
+    TPtr ptr(buf->Des());
+    ptr.AppendNum(aAppUid,EHex);
+    TInt error = SendReceive(EClearAppUidCookies,TIpcArgs(ptr.Length(),&ptr)); 
+    CleanupStack::PopAndDestroy();
+    return error;
+    }
+
+// ---------------------------------------------------------
+// RCookieManager::StoreCookieAtClientSide
+// ---------------------------------------------------------
+//
+void RCookieManager::StoreCookieAtClientSide( const CCookie* aCookie, const TDesC8& aUri,TUint32 aWidgetUid )
+    {
+    CLOG( ( EClient, 0, _L( "-> RCookieManager::StoreCookieAtClientSide" ) ) );
+    TUint32 groupid = RProcess().SecureId().iId;
+    CCookieClientDataArray* cookieclientdataarray = CCookieClientDataArray::GetInstance();
+    TInt count = cookieclientdataarray->Count();
+    TInt itemIndex =0;
+    for(TInt i=0; i<count; i++)
+        {
+          if (cookieclientdataarray->At(i)->GetGroupId() == groupid 
+                  && cookieclientdataarray->At(i)->GetCookieSharableFlag())
+              {
+              itemIndex = i;
+              break;
+              }
+          else if(cookieclientdataarray->At(i)->GetGroupId() == groupid
+                  && !(cookieclientdataarray->At(i)->GetCookieSharableFlag()) 
+                  && cookieclientdataarray->At(i)->GetWidgetUid() == aWidgetUid)
+              {
+              itemIndex = i;
+              break;
+              }
+        }
+    CCookieClientData* cookieclientdata = cookieclientdataarray->At(itemIndex);
+    cookieclientdata->StoreCookieAtClientSideL(aCookie,aUri);
+    CLOG( ( EClient, 0, _L( "<- RCookieManager::StoreCookieAtClientSide" ) ) );
+    }
+
+// ---------------------------------------------------------
+// RCookieManager::GetClientSideCookies
+// ---------------------------------------------------------
+//
+TInt RCookieManager::GetClientSideCookies( const TDesC8& aRequestUri,RPointerArray<CCookie>& aCookies
+                ,TBool& aCookieFound, TUint32 aWidgetUid )
+    {
+    CLOG( ( EClient, 0, _L( "-> RCookieManager::GetClientSideCookies" ) ) );
+    TUint32 groupid = RProcess().SecureId().iId;
+    //TInt itemIndex =0;
+    CCookieClientData* cookieclientdata = NULL;
+    CCookieClientDataArray* cookieclientdataarray = CCookieClientDataArray::GetInstance();
+    TInt count = cookieclientdataarray->Count();
+    if (count == 0)
+        {
+        TBool cookieSharableFlag(EFalse);
+        TInt err = GetCookieSharableFlagFromServer(cookieSharableFlag);
+        cookieclientdata = CCookieClientData::NewL(groupid, aWidgetUid, cookieSharableFlag,ETrue);
+        cookieclientdata->SetInitFlag(ETrue);
+        cookieclientdataarray->AddClientGroupDataL(cookieclientdata);
+        } else 
+           {
+           //harendra: move this for loop in CCookieClientDataArray::Find(), it should index or object
+           cookieclientdata = cookieclientdataarray->Find(groupid, aWidgetUid);
+           }
+     if(cookieclientdata)
+        {
+         if(!cookieclientdata->GetInitFlag())
+           {
+            TBool cookieSharableFlag(EFalse);
+            TInt err = GetCookieSharableFlagFromServer(cookieSharableFlag);
+            cookieclientdata->SetCookieCookieSharableFlag(cookieSharableFlag);
+           }
+           //cookieclientdata->SetInitFlag(ETrue);
+           return cookieclientdata->GetClientSideCookies( aRequestUri,aCookies, aCookieFound );
+         } else 
+              {
+               TBool cookieSharableFlag(EFalse);
+               TInt err = GetCookieSharableFlagFromServer(cookieSharableFlag);
+               if(err == KErrNone)
+                 {
+                   CCookieClientData* cookieclientdata 
+                    = CCookieClientData::NewL(groupid, aWidgetUid, cookieSharableFlag,ETrue);
+                    cookieclientdataarray->AddClientGroupDataL(cookieclientdata);
+                  }
+               }
+    CLOG( ( EClient, 0, _L( "<- RCookieManager::GetClientSideCookies" ) ) );
+    return KErrNone;
+    }
+
 // End of file