MCL/sf/mw/web: comparison webengine/osswebengine/cache/src/HttpCacheLookupTable.cpp

equal deleted inserted replaced

-:10e98eab6f85
+:a359256acfc6
 // Symbian 2nd phase constructor can leave.
 // -----------------------------------------------------------------------------
 //
 void CHttpCacheLookupTable::ConstructL()
 {
 iEntries = new( ELeave )CArrayPtrFlat<CHttpCacheEntry>( KHttpCacheLookupTableSize );
-for( TInt i = 0; i < KHttpCacheLookupTableSize; i++ )
+for ( TInt i = 0; i < KHttpCacheLookupTableSize; i++ )
 {
 iEntries->AppendL( NULL );
 }
 }
 }
 iEntries->Reset();
 }
 delete iEntries;
 }
 // -----------------------------------------------------------------------------
 // CHttpCacheLookupTable::InsertL
 //
 CleanupStack::PopAndDestroy(); // entry
 entry = NULL;
 }
 else
 {
+#ifdef __CACHELOG__
+HttpCacheUtil::WriteFormatLog(0, _L("  Added entry %08x to list."), entry);
+#endif
 entry->Accessed();
+iStreamHandler->InitialiseCacheEntryL(*entry);
 // lookuptable takes ownership
 CleanupStack::Pop(); // entry
 }
 return entry;
 }
 //
 CHttpCacheEntry* CHttpCacheLookupTable::Find( const TDesC8& aUrl )
 {
 CHttpCacheEntry* entry = NULL;
 TInt pos( Probe( aUrl, EFalse ) );
+#ifdef __CACHELOG__
+HttpCacheUtil::WriteUrlToLog(0, _L("CHttpCacheLookupTable::Find"), aUrl);
+HttpCacheUtil::WriteFormatLog(0, _L("  Probe returned position %d"), pos);
+#endif
 if ( Valid( pos ) )
 {
+#ifdef __CACHELOG__
+HttpCacheUtil::WriteFormatLog(0, _L("  Entry %d valid."), pos);
+#endif
 entry = iEntries->At( pos );
 if ( entry )
 {
+#ifdef __CACHELOG__
+HttpCacheUtil::WriteFormatLog(0, _L("  BodySize is %d\n  State is %d"), entry->BodySize(), entry->State());
+#endif
 if ( entry->BodySize() == 0 &&
 entry->State() == CHttpCacheEntry::ECacheComplete )
 {
 #ifdef __CACHELOG__
 HttpCacheUtil::WriteLogFilenameAndUrl( 0,
-_L("CHttpCacheLookupTable::Find - Found ZERO size"),
+_L("CHttpCacheLookupTable::Find - Found ZERO size (can't reuse)"),
 entry->Filename(),
 entry->Url(),
 pos,
 ELogLookupTablePos );
 #endif
 return NULL;
 }
 }
 }
+#ifdef __CACHELOG__
+HttpCacheUtil::WriteFormatLog(0, _L("  returning entry pointer 0x%08x"), entry);
+#endif
 return entry;
 }
 // -----------------------------------------------------------------------------
 //
 TInt CHttpCacheLookupTable::Remove( const TDesC8& aUrl )
 {
 TInt status( KErrNotFound );
 TInt pos( Probe( aUrl, EFalse ) );
+#ifdef __CACHELOG__
+HttpCacheUtil::WriteUrlToLog(0, _L("CHttpCacheLookupTable::Remove"), aUrl);
+HttpCacheUtil::WriteFormatLog(0, _L("  Probe returned position %d"), pos);
+#endif
 if( Valid( pos ) )
 {
 // remove only nonactive entry
 CHttpCacheEntry* entry = iEntries->At( pos );
 if ( entry->State() == CHttpCacheEntry::ECacheComplete )
 ELogLookupTablePos );
 }
 }
 else
 {
-HttpCacheUtil::WriteLog( 0, _L( "CHttpCacheLookupTable::Remove - item is not valid. cannot be removed" ), pos );
+HttpCacheUtil::WriteFormatLog( 0, _L( "CHttpCacheLookupTable::Remove - item %d is not valid. cannot be removed" ), pos );
 }
 #endif // __CACHELOG__
 return status;
 }
 // -----------------------------------------------------------------------------
-// CHttpCacheLookupTable::RemoveByPosition
-//
-// -----------------------------------------------------------------------------
-//
-TInt CHttpCacheLookupTable::RemoveByPosition( TInt aPos )
-{
-TInt status( KErrNotFound );
-if ( Valid( aPos ) )
-{
-CHttpCacheEntry* entry = iEntries->At( aPos );
-SetDeleted( aPos );
-delete entry;
-iCount--;
-status = KErrNone;
-}
-return status;
-}
-// -----------------------------------------------------------------------------
 // CHttpCacheLookupTable::EraseCacheEntry
 //
 // -----------------------------------------------------------------------------
 //
 void CHttpCacheLookupTable::EraseCacheEntry( const TDesC8& aUrl )
 {
 TInt pos( Probe( aUrl, EFalse ) );
 if ( Valid( pos ) )
 {
 Erase( pos );
 }
 #ifdef __CACHELOG__
 TInt CHttpCacheLookupTable::ListFiles(RPointerArray<TDesC>& aFilenameList)
 {
 TInt count( 0 );
 TInt error( KErrNone );
 //1. Tally up
 for (TInt i = 0; i < iEntries->Count(); i++)
 {
 if (Valid(i)) count++;
 }
 //2. Preallocation.
 TInt existing( aFilenameList.Count() );
 error = aFilenameList.Reserve( existing + count );
 if (error == KErrNone)
 {
 //3. Iterate once more and add pointers to filename strings
 for (TInt i = 0; i < iEntries->Count(); i++)
 {
 if (Valid(i))
 {
 //add filename pointer to the array.
 const TDesC* ptr = &(iEntries->At(i)->Filename());
 aFilenameList.Append( ptr ); // no ownership transfer happens here
 }
 }
 }
 return error;
 }
 // -----------------------------------------------------------------------------
 // CHttpCacheLookupTable::InternalizeL
 //
 // -----------------------------------------------------------------------------
 //
 void CHttpCacheLookupTable::InternalizeL(
-RFileReadStream& aReadStream,
+RReadStream& aReadStream,
-const TDesC& /*aDirectory*/ )
+const TDesC& aDirectory )
 {
 // get number of entries
 TInt version = 0;
 version = aReadStream.ReadInt32L();
-if( version == KCacheVersionNumber )
+if ( version == KCacheVersionNumber )
 {
+// read directory stub and validate it
+TInt len = aReadStream.ReadInt32L();
+HBufC* dirstub = HBufC::NewLC(len);
+TPtr dirstubptr = dirstub->Des();
+aReadStream.ReadL( dirstubptr, len );
+ASSERT( aDirectory.CompareF( dirstubptr ) == 0 );
+CleanupStack::PopAndDestroy( dirstub );
 TInt count( aReadStream.ReadInt32L() );
 TInt contentSize( 0 );
 TInt err;
 for( TInt i = 0; i < count; i++ )
 {
 // create empty object
 CHttpCacheEntry* entry = CHttpCacheEntry::NewLC( KNullDesC8, *iEvictionHandler );
 // read it
-err = entry->Internalize( aReadStream );
+err = entry->Internalize( aReadStream, aDirectory );
+// leave only on no memory
-if ( err == KErrNone && entry->BodySize() > 0 )
+if( err == KErrNone )
 {
-// cacheEntry is valid, insert into the table
+// insert to the table
 InsertL( entry );
 contentSize += entry->HeaderSize();
 contentSize += entry->BodySize();
 }
 else if ( err == KErrNoMemory )
 {
-// Only leave if no memory
 User::Leave( KErrNoMemory );
 }
-else if ( entry->BodySize() == 0 )
+else
 {
-// This is an empty cache entry, remove it from file system.
+// suggestions
-				// Use CreateNewFilesL() to open file handles, so we can delete
-				// the files associated with the cache entry.
-iStreamHandler->CreateNewFilesL( *entry );
-iStreamHandler->EraseCacheFile( *entry );
 }
 // takes ownership
 CleanupStack::Pop(); // entry
 }
 // CHttpCacheLookupTable::Externalize
 //
 // -----------------------------------------------------------------------------
 //
 void CHttpCacheLookupTable::ExternalizeL(
-RFileWriteStream& aWriteStream )
+RWriteStream& aWriteStream, const TDesC& aDirectory )
 {
 // write version number and the number of entries
-TRAP_IGNORE( aWriteStream.WriteInt32L( KCacheVersionNumber );
+TRAP_IGNORE( aWriteStream.WriteInt32L( KCacheVersionNumber ) );
-aWriteStream.WriteInt32L( iCount ) );
+// directory stub length
+aWriteStream.WriteInt32L( aDirectory.Length() ) ;
+// directory stub
+aWriteStream.WriteL( aDirectory );
+// entry count - don't write entries with zero body length, so precalculate this.
+TInt goingToWrite = 0;
 for( TInt i = 0; i < iEntries->Count(); i++ )
 {
 CHttpCacheEntry* entry = iEntries->At( i );
 // save complete entries only
-if( Valid( i ) )
+if( Valid( i ) && entry->BodySize() > 0 )
+{
+goingToWrite++;
+}
+}
+aWriteStream.WriteInt32L( goingToWrite );
+for( TInt i = 0; i < iEntries->Count(); i++ )
+{
+CHttpCacheEntry* entry = iEntries->At( i );
+// save complete entries only
+if( Valid( i ) && entry->BodySize() > 0 )
 {
 // save entry
 TInt err;
-err = entry->Externalize( aWriteStream );
+err = entry->Externalize( aWriteStream, aDirectory );
 // leave only on no memory
-if( err == KErrNoMemory )
+if ( err == KErrNoMemory )
 {
 User::Leave( KErrNoMemory );
 }
 }
 }
 TInt pos( -1 );
 if ( aCacheEntry )
 {
 pos = Probe( aCacheEntry->Url(), ETrue );
+#ifdef __CACHELOG__
+HttpCacheUtil::WriteUrlToLog(0, _L("CHttpCacheLookupTable::InsertL"), aCacheEntry->Url());
+HttpCacheUtil::WriteFormatLog(0, _L("  Probe returned position %d"), pos);
+#endif
 // double check
 if( Valid( pos ) )
 {
+#ifdef __CACHELOG__
+HttpCacheUtil::WriteLog(0, _L("  Valid entry already exists according to Valid(). Rehash table."));
+#endif
 // try to rehash the table if probe failed
 ReHashL();
 pos = Probe( aCacheEntry->Url(), ETrue );
+#ifdef __CACHELOG__
+HttpCacheUtil::WriteFormatLog(0, _L("  ReProbe after rehash returned new position %d"), pos);
+#endif
 if( pos == -1 || Valid( pos ) )
 {
+#ifdef __CACHELOG__
+HttpCacheUtil::WriteLog(0, _L("  Pos already filled (or == -1) - Couldn't find an empty slot to store it."));
+#endif
 // completly failed
 pos = -1;
 }
 }
 // insert
 if( pos != -1 )
 {
 iEntries->At( pos ) = aCacheEntry;
 iCount++;
+#ifdef __CACHELOG__
-#ifdef __CACHELOG__
+HttpCacheUtil::WriteFormatLog( 0, _L( "insert new item at %d in the lookuptable" ), pos );
-HttpCacheUtil::WriteLog( 0, _L( "insert new item to the lookuptable" ), pos );
 #endif
 // check if the hashtable is full
 if ( iCount > ( iEntries->Count() >> 1 ) )
 {
+#ifdef __CACHELOG__
+HttpCacheUtil::WriteLog(0, _L("  But! hashtable is full - rehash."));
+#endif
 ReHashL();
 }
 }
 else
 {
 CHttpCacheEntry* entry = iEntries->At( aPos );
 if( entry )
 {
-// delete file associated with this entry
-TBool attached( EFalse );
 #ifdef __CACHELOG__
 HttpCacheUtil::WriteLogFilenameAndUrl( 0,
 _L("CHttpCacheLookupTable::Erase"),
 entry->Filename(),
 entry->Url(),
 aPos,
 ELogLookupTablePos );
 #endif
-TRAPD( err, attached = iStreamHandler->AttachL( *entry ) );
+iStreamHandler->Erase( *entry );
-if ( err == KErrNone && attached )
-{
-iStreamHandler->EraseCacheFile( *entry );
-iStreamHandler->Detach( *entry );
-}
 SetDeleted( aPos );
 delete entry;
 iCount--;
 }
 }
 if (aRfs.Att(newEntry->Filename(), att) == KErrNone)
 {
 CHttpCacheEntry* myEntry = InsertL(newEntry->Url());
 myEntry->SetState( CHttpCacheEntry::ECacheComplete );
 myEntry->Accessed(newEntry->LastAccessed(), newEntry->Ref());
 }
 aHttpCacheLookupTable->SetDeleted(pos);
 delete newEntry;
 aHttpCacheLookupTable->iCount--;
 }
 }
 }
 // -----------------------------------------------------------------------------
-// CHttpCacheLookupTable::FindCacheEntryIndex
+// CHttpCacheLookupTable::BeginEntryIteration
 //
 // -----------------------------------------------------------------------------
 //
-void CHttpCacheLookupTable::FindCacheEntryIndex(
+void CHttpCacheLookupTable::BeginEntryIteration(THttpCacheLookupTableEntryIterator& aIter)
-const CHttpCacheEntry& aCacheEntry,
+{
-TInt* aIndex )
+aIter.iPos = 0;
-{
+aIter.iCount = iCount;
-*aIndex = -1;
+}
-for ( TInt i = 0; i < iEntries->Count(); i++ )
-{
+// -----------------------------------------------------------------------------
-CHttpCacheEntry* entry = iEntries->At( i );
+// CHttpCacheLookupTable::NextEntry
+//
-if ( entry == &aCacheEntry )
+// -----------------------------------------------------------------------------
-{
+//
-if ( aIndex )
+const CHttpCacheEntry* CHttpCacheLookupTable::NextEntry(THttpCacheLookupTableEntryIterator& aIter)
 {
-*aIndex = i;
+const CHttpCacheEntry *entry = NULL;
-}
-break;
+while ( !entry && aIter.iPos < iEntries->Count() )
-}
+{
-}
+entry = Valid(aIter.iPos) ? iEntries->At(aIter.iPos) : NULL;
+aIter.iPos++;
+}
+return entry;
 }
 //  End of File

changeset 10	a359256acfc6
parent 5	10e98eab6f85
child 11	c8a366e56285