diff -r 10e98eab6f85 -r a359256acfc6 webengine/osswebengine/cache/inc/HttpCacheFileWriteHandler.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/webengine/osswebengine/cache/inc/HttpCacheFileWriteHandler.h	Thu Aug 27 07:44:59 2009 +0300
@@ -0,0 +1,192 @@
+/*
+* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "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:  Implementation of CHttpCacheFileWriteHandler
+*
+*/
+
+#ifndef CHTTPCACHEFILEWRITEHANDLER_H
+#define CHTTPCACHEFILEWRITEHANDLER_H
+
+//  INCLUDES
+#include <e32base.h>
+#include <f32file.h>
+#include "HttpCacheHandler.h"
+#include "MemoryManager.h"
+
+// CONSTANTS
+
+// MACROS
+
+// DATA TYPES
+
+// FUNCTION PROTOTYPES
+class CAsyncFileWriter;
+class CHttpCacheWriteTimeout;
+
+// FORWARD DECLARATIONS
+
+// CLASS DECLARATION
+
+/**
+*
+*  @lib
+*  @since 5.0
+*/
+NONSHARABLE_CLASS(CHttpCacheFileWriteHandler) : public CActive, public MMemoryCollector
+    {
+    public:  // Constructors and destructor
+
+        /**
+        * Two-phased constructor.
+        * @since 5.0
+        * @param
+        * @param
+        * @return CacheFileWriteHandler object.
+        */
+        static CHttpCacheFileWriteHandler* NewL(CHttpCacheHandler* aManager, CHttpCacheStreamHandler* aStreamHandler, RFs& aRfs, const TInt aWriteTimeout);
+
+        /**
+        * Destructor.
+        */
+        virtual ~CHttpCacheFileWriteHandler();
+
+    public: // From MMemoryCollector
+        /**
+        * Collect free memory, this function is called when allocation from
+        * System heap fails
+        * @since 3.1
+        * @param amount of memory needs to be collected
+        * @return amount of memory collected
+        */
+        virtual TUint Collect(TUint aRequired);
+
+        /**
+        * restore the entity controlled memory collector when there is enough memory
+        * System heap fails
+        * @since 3.1
+        * @param
+        * @return
+        */
+        virtual void Restore();
+
+        /**
+        * Priority of this collector, 0 - lowest, 10 - highest;
+        * the lower the priority, the earlier this collector is executed.
+        * @since 3.1
+        * @param
+        * @return
+        */
+        virtual TOOMPriority Priority();
+
+        /**
+         *
+         * @since 7.1
+         * @param
+         * @return
+         */
+        TBool IsCacheEntryPostponed(const CHttpCacheEntry* aEntry);
+
+    public: // new functions
+        enum TAddStatus {
+            EAddedOk,
+            EBodySmallerThanThreshold,
+            ENotEnoughFreeMemory,
+            ECheckReturn
+        };
+
+        /**
+         * Add a cache entry to write out when possible
+         *
+         */
+        TInt AddEntry(TAddStatus& aAddStatus, CHttpCacheEntry *aEntry);
+
+        /**
+         * Remove a stream entry from the list
+         */
+        CHttpCacheEntry* RemoveEntry(CHttpCacheEntry *aEntry);
+
+        /**
+         * Remove all stream entries from the list
+         */
+        void RemoveAll();
+
+        /**
+         * Emergency method if memory is short - write everything
+         * to disk *now* and wait for it. Or maybe just dump it all
+         * and delete the headers...
+         */
+        void DumpAllObjects();
+
+        /**
+         * Signal called by the timer callback to indicate that we
+         * should begin writing out the cached data.
+         */
+        void BeginWriting();
+
+    private:
+
+        /**
+        * Construct.
+        * @since 5.0
+        * @param
+        * @param
+        * @return CacheFileWriteHandler object.
+        */
+        CHttpCacheFileWriteHandler(CHttpCacheHandler* aHandler, CHttpCacheStreamHandler* aStreamHandler, RFs& aRfs);
+
+        /**
+        * By default Symbian 2nd phase constructor is private.
+        */
+        void ConstructL(const TInt aWriteTimeout);
+
+        /**
+         * from CActive
+         */
+        void DoCancel();
+
+        /**
+         * from CActive
+         */
+        void RunL();
+
+        void ContinueFlushing();
+
+        void OutputQueueContentToDebug();
+
+        // sort by size function for arrays of CHttpCacheEntry objects.
+        static TInt CompareHttpCacheEntrySize( const CHttpCacheEntry& aFirst, const CHttpCacheEntry& aSecond );
+        void CollectMemory( TUint aRequired );
+
+        /**
+         * Callback function for timer to activate writing.
+         */
+        static TInt WriteTimeout(TAny* aParam);
+
+    private:    // Data
+        CHttpCacheHandler*                  iCacheHandler;
+        CHttpCacheStreamHandler*            iCacheStreamHandler;
+        TInt                                iFreeRamThreshold;
+        TInt                                iImmediateWriteThreshold;
+        TBool                               iLowMemoryState;
+        RFs                                 iFs;
+        CHttpCacheWriteTimeout*             iWaitTimer;
+        // objects in this array are not owned.
+        RPointerArray<CHttpCacheEntry>      iObjectQueue;
+        // contains a pointer to the object that flush was called for
+        CHttpCacheEntry*                    iObjectFlushing;
+    };
+
+#endif      // CHttpCacheFileWriteHandler_H
+
+// End of File