webengine/osswebengine/cache/inc/HttpCacheManager.h
changeset 11 c8a366e56285
parent 10 a359256acfc6
child 25 0ed94ceaa377
equal deleted inserted replaced
10:a359256acfc6 11:c8a366e56285
    38 class CCenRepNotifyHandler;
    38 class CCenRepNotifyHandler;
    39 class CRepository;
    39 class CRepository;
    40 class RHTTPTransaction;
    40 class RHTTPTransaction;
    41 class MHTTPDataSupplier;
    41 class MHTTPDataSupplier;
    42 class CHttpCacheFileWriteHandler;
    42 class CHttpCacheFileWriteHandler;
       
    43 class CHttpCacheFileHash;
       
    44 class THttpCachePostponeParameters;
    43 
    45 
    44 // CLASS DECLARATION
    46 // CLASS DECLARATION
    45 
    47 
    46 /**
    48 /**
    47 *
    49 *
   216         * @param
   218         * @param
   217         * @return
   219         * @return
   218         */
   220         */
   219         void CreateCacheHandlersL();
   221         void CreateCacheHandlersL();
   220 
   222 
   221          /**
   223         /**
   222         *
   224         *
   223         * @since 7.1
   225         * @since 7.1
   224         * @param
   226         * @param
   225         * @return
   227         * @return
   226         */
   228         */
   227         void RemoveOrphanedFilesL();
   229         void RemoveOrphanedFilesL();    // remove all orphan files.
       
   230         /**
       
   231         *
       
   232         * @since 7.1
       
   233         * @param
       
   234         * @return
       
   235         */
       
   236         // perform phase 2 of orphan file removal. Mark any files 
       
   237         void MarkAllCacheContentAsNoDelete( CHttpCacheFileHash* aOnDiskFilesMap );
       
   238         /**
       
   239         *
       
   240         * @since 7.1
       
   241         * @param
       
   242         * @return
       
   243         */
       
   244         // perform phase 3 of orphan file removal.
       
   245         // Write an 'empty cache' index file over the top of any unknown index files to let any running clients
       
   246         // prepare for their data to disappear.
       
   247         void WipeAllOtherIndexFilesL( CHttpCacheFileHash* aOnDiskFilesMap, RFs& aRfs );
       
   248         /**
       
   249         *
       
   250         * @since 7.1
       
   251         * @param
       
   252         * @return
       
   253         */
       
   254         // perform phase 4 of orphan file removal. Remove any files not referenced in the loaded caches.
       
   255         void DeleteMarkedFilesL( CHttpCacheFileHash* aOnDiskFilesMap, RFs& aRfs );
       
   256         /**
       
   257         *
       
   258         * @since 7.1
       
   259         * @param
       
   260         * @return
       
   261         */
       
   262         // utility fn for phase 3 of orphan file removal.
       
   263         void GenerateEmptyIndexFileL(const TDesC& aIndexFile, RFs& aRfs );
       
   264 
       
   265         /**
       
   266          * @since 7.1
       
   267          * override cache parameters according to application using DLL and any config in Centrep
       
   268          */
       
   269         void ApplyCacheOverridesL(CRepository& aRepository, const TUint32& aSecIdInt, TBool& aCacheEnabled, TInt& aCacheSize, TBool& aOpCacheEnabled, TBool& aVssCacheEnabled, TDes& aPath, const TDesC& aDefaultDrive);
   228 
   270 
   229         /**
   271         /**
   230         *
   272         *
   231         * @since 3.1
   273         * @since 3.1
   232         * @param
   274         * @param
   250         * @return
   292         * @return
   251         */
   293         */
   252 
   294 
   253         TBool VSSHeaderCheck(  TDes8*  aHttpHeaderString ) const ;
   295         TBool VSSHeaderCheck(  TDes8*  aHttpHeaderString ) const ;
   254 
   296 
       
   297         /**
       
   298          * @since 7.1
       
   299          * 
       
   300          */
       
   301         void GetPostponeParamsL( TBool& aNewCentrepPresent, THttpCachePostponeParameters& aParams, CRepository* aRepo );
       
   302 
       
   303         /**
       
   304          * @since 7.1
       
   305          * 
       
   306          */
       
   307         void GetHttpCacheConfigL( CRepository& aRepository, TBool& aCacheEnabled, TInt& aCacheSize, TDes& aCacheFolder );
       
   308 
       
   309         /**
       
   310          * @since 7.1
       
   311          * 
       
   312          */
       
   313         void GetOperatorCacheConfigL( CRepository& aRepository, TBool& aOpCacheEnabled, TInt& aOpCacheSize, TDes& aOpCacheFolder );
       
   314 
       
   315         /**
       
   316          * @since 7.1
       
   317          * 
       
   318          */
       
   319         void GetVSSCacheConfigL( CRepository& aRepository, TBool& aVSSCacheEnabled, TInt& aVssCacheSize, TDes& aVssCacheFolder );
       
   320         
       
   321         /**
       
   322          * @since 7.1
       
   323          * 
       
   324          */
       
   325         void GetCriticalDriveLevelsL( CRepository& aRepository, const TDesC& aCacheFolder, TInt& aCriticalLevel );
       
   326 
       
   327         /**
       
   328          * @since 7.1
       
   329          * 
       
   330          */
       
   331         void CreateHttpCacheL( const TInt& aSecIdInt, const TInt& aCacheSize, const TInt& aCriticalLevel, const THttpCachePostponeParameters& aPostpone );
       
   332 
       
   333         /**
       
   334          * @since 7.1
       
   335          * 
       
   336          */
       
   337         void CreateOperatorCacheL( CRepository& aRepository, const TDesC& aOpCacheFolder, const TInt& aOpCacheSize, const TInt& aCriticalLevel, const THttpCachePostponeParameters& aPostpone );
       
   338 
       
   339         /**
       
   340          * @since 7.1
       
   341          * 
       
   342          */
       
   343         void CreateVssCacheL( CRepository& aRepository, const TDesC& aVssCacheFolder, const TInt& aVssCacheSize, const TInt& aCriticalLevel, const THttpCachePostponeParameters& aPostpone );
       
   344 
       
   345         /**
       
   346          * @since 7.1
       
   347          * 
       
   348          */
       
   349         void CrashCheckL( const TInt& aSecIdInt );
       
   350 
       
   351 
   255     private:    // Data
   352     private:    // Data
   256 
   353 
   257         CHttpCacheHandler*                         iCache;      // owned
   354         CHttpCacheHandler*                         iCache;      // owned
   258 
   355 
   259         TPath                                      iCacheFolder;
   356         TPath                                      iCacheFolder;