gecko/netwerk/cache2/CacheEntriesEnumerator.cpp

187 lines
3.8 KiB
C++
Raw Normal View History

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "CacheEntriesEnumerator.h"
#include "CacheFileIOManager.h"
#include "CacheFile.h"
#include "nsIDirectoryEnumerator.h"
#include "nsIFile.h"
#include "nsIThread.h"
#include "nsISimpleEnumerator.h"
#include "nsThreadUtils.h"
namespace mozilla {
namespace net {
CacheEntriesEnumerator::CacheEntriesEnumerator(nsIFile* aEntriesDirectory)
: mEntriesDirectory(aEntriesDirectory)
{
MOZ_COUNT_CTOR(CacheEntriesEnumerator);
}
CacheEntriesEnumerator::~CacheEntriesEnumerator()
{
MOZ_COUNT_DTOR(CacheEntriesEnumerator);
if (mEnumerator) {
mEnumerator->Close();
ProxyReleaseMainThread(mEnumerator);
}
}
nsresult CacheEntriesEnumerator::Init()
{
nsresult rv;
nsCOMPtr<nsISimpleEnumerator> e;
rv = mEntriesDirectory->GetDirectoryEntries(getter_AddRefs(e));
if (NS_ERROR_FILE_NOT_FOUND == rv || NS_ERROR_FILE_TARGET_DOES_NOT_EXIST == rv) {
return NS_OK;
}
NS_ENSURE_SUCCESS(rv, rv);
mEnumerator = do_QueryInterface(e, &rv);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
bool CacheEntriesEnumerator::HasMore()
{
#ifdef DEBUG
if (!mThreadCheck)
mThreadCheck = NS_GetCurrentThread();
else
MOZ_ASSERT(mThreadCheck == NS_GetCurrentThread());
#endif
if (!mEnumerator) {
return false;
}
if (mCurrentFile)
return true;
nsresult rv;
rv = mEnumerator->GetNextFile(getter_AddRefs(mCurrentFile));
if (NS_FAILED(rv)) {
mEnumerator->Close();
mEnumerator = nullptr;
return false;
}
return !!mCurrentFile;
}
namespace { // anon
class FileConsumer : public CacheFileListener
{
public:
NS_DECL_THREADSAFE_ISUPPORTS
nsresult Init(nsCSubstring const & aKey,
CacheEntriesEnumeratorCallback* aCallback);
virtual ~FileConsumer() {}
private:
NS_IMETHOD OnFileReady(nsresult aResult, bool aIsNew);
NS_IMETHOD OnFileDoomed(nsresult aResult) { return NS_OK; }
nsRefPtr<CacheFile> mFile;
nsRefPtr<CacheEntriesEnumeratorCallback> mCallback;
};
nsresult FileConsumer::Init(const nsCSubstring &aKey,
CacheEntriesEnumeratorCallback *aCallback)
{
mCallback = aCallback;
mFile = new CacheFile();
nsresult rv = mFile->Init(aKey, false, false, false, true, this);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
NS_IMETHODIMP FileConsumer::OnFileReady(nsresult aResult, bool aIsNew)
{
//MOZ_ASSERT(!aIsNew);
if (NS_FAILED(aResult)) {
mCallback->OnFile(nullptr);
}
else {
mCallback->OnFile(mFile);
}
return NS_OK;
}
NS_IMPL_ISUPPORTS1(FileConsumer, CacheFileListener);
} // anon
nsresult CacheEntriesEnumerator::GetNextCacheFile(CacheEntriesEnumeratorCallback* aCallback)
{
#ifdef DEBUG
MOZ_ASSERT(mThreadCheck == NS_GetCurrentThread());
#endif
nsresult rv;
NS_ENSURE_TRUE(mCurrentFile, NS_ERROR_UNEXPECTED);
nsAutoCString key;
rv = mCurrentFile->GetNativeLeafName(key);
mCurrentFile = nullptr;
NS_ENSURE_SUCCESS(rv, rv);
nsRefPtr<FileConsumer> consumer = new FileConsumer();
rv = consumer->Init(key, aCallback);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
nsresult CacheEntriesEnumerator::GetNextFile(nsIFile** aFile)
{
#ifdef DEBUG
MOZ_ASSERT(mThreadCheck == NS_GetCurrentThread());
#endif
NS_ENSURE_TRUE(mCurrentFile, NS_ERROR_UNEXPECTED);
mCurrentFile.forget(aFile);
return NS_OK;
}
nsresult CacheEntriesEnumerator::GetCacheFileFromFile(nsIFile* aFile,
CacheEntriesEnumeratorCallback* aCallback)
{
nsresult rv;
nsAutoCString key;
rv = aFile->GetNativeLeafName(key);
NS_ENSURE_SUCCESS(rv, rv);
nsRefPtr<FileConsumer> consumer = new FileConsumer();
rv = consumer->Init(key, aCallback);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
} // net
} // mozilla