forked from mirrors/gecko-dev
2afd829d0f
This patch is an automatic replacement of s/NS_NOTREACHED/MOZ_ASSERT_UNREACHABLE/. Reindenting long lines and whitespace fixups follow in patch 6b. MozReview-Commit-ID: 5UQVHElSpCr --HG-- extra : rebase_source : 4c1b2fc32b269342f07639266b64941e2270e9c4 extra : source : 907543f6eae716f23a6de52b1ffb1c82908d158a
500 lines
19 KiB
C++
500 lines
19 KiB
C++
/* 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/. */
|
|
|
|
#ifndef CacheFileIOManager__h__
|
|
#define CacheFileIOManager__h__
|
|
|
|
#include "CacheIOThread.h"
|
|
#include "CacheStorageService.h"
|
|
#include "CacheHashUtils.h"
|
|
#include "nsIEventTarget.h"
|
|
#include "nsINamed.h"
|
|
#include "nsITimer.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "mozilla/Atomics.h"
|
|
#include "mozilla/SHA1.h"
|
|
#include "mozilla/StaticPtr.h"
|
|
#include "mozilla/TimeStamp.h"
|
|
#include "nsTArray.h"
|
|
#include "nsString.h"
|
|
#include "nsTHashtable.h"
|
|
#include "prio.h"
|
|
|
|
//#define DEBUG_HANDLES 1
|
|
|
|
class nsIFile;
|
|
class nsITimer;
|
|
class nsIDirectoryEnumerator;
|
|
class nsILoadContextInfo;
|
|
|
|
namespace mozilla {
|
|
namespace net {
|
|
|
|
class CacheFile;
|
|
class CacheFileIOListener;
|
|
|
|
#ifdef DEBUG_HANDLES
|
|
class CacheFileHandlesEntry;
|
|
#endif
|
|
|
|
#define ENTRIES_DIR "entries"
|
|
#define DOOMED_DIR "doomed"
|
|
#define TRASH_DIR "trash"
|
|
|
|
|
|
class CacheFileHandle final : public nsISupports
|
|
{
|
|
public:
|
|
enum class PinningStatus : uint32_t {
|
|
UNKNOWN,
|
|
NON_PINNED,
|
|
PINNED
|
|
};
|
|
|
|
NS_DECL_THREADSAFE_ISUPPORTS
|
|
bool DispatchRelease();
|
|
|
|
CacheFileHandle(const SHA1Sum::Hash *aHash, bool aPriority, PinningStatus aPinning);
|
|
CacheFileHandle(const nsACString &aKey, bool aPriority, PinningStatus aPinning);
|
|
void Log();
|
|
bool IsDoomed() const { return mIsDoomed; }
|
|
const SHA1Sum::Hash *Hash() const { return mHash; }
|
|
int64_t FileSize() const { return mFileSize; }
|
|
uint32_t FileSizeInK() const;
|
|
bool IsPriority() const { return mPriority; }
|
|
bool FileExists() const { return mFileExists; }
|
|
bool IsClosed() const { return mClosed; }
|
|
bool IsSpecialFile() const { return mSpecialFile; }
|
|
nsCString & Key() { return mKey; }
|
|
|
|
// Returns false when this handle has been doomed based on the pinning state update.
|
|
bool SetPinned(bool aPinned);
|
|
void SetInvalid() { mInvalid = true; }
|
|
|
|
// Memory reporting
|
|
size_t SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
|
|
size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
|
|
|
|
private:
|
|
friend class CacheFileIOManager;
|
|
friend class CacheFileHandles;
|
|
friend class ReleaseNSPRHandleEvent;
|
|
|
|
virtual ~CacheFileHandle();
|
|
|
|
const SHA1Sum::Hash *mHash;
|
|
mozilla::Atomic<bool, ReleaseAcquire> mIsDoomed;
|
|
mozilla::Atomic<bool, ReleaseAcquire> mClosed;
|
|
|
|
// mPriority and mSpecialFile are plain "bool", not "bool:1", so as to
|
|
// avoid bitfield races with the byte containing mInvalid et al. See
|
|
// bug 1278502.
|
|
bool const mPriority;
|
|
bool const mSpecialFile;
|
|
|
|
mozilla::Atomic<bool, Relaxed> mInvalid;
|
|
|
|
// These bit flags are all accessed only on the IO thread
|
|
bool mFileExists : 1; // This means that the file should exists,
|
|
// but it can be still deleted by OS/user
|
|
// and then a subsequent OpenNSPRFileDesc()
|
|
// will fail.
|
|
|
|
// Both initially false. Can be raised to true only when this handle is to be doomed
|
|
// during the period when the pinning status is unknown. After the pinning status
|
|
// determination we check these flags and possibly doom.
|
|
// These flags are only accessed on the IO thread.
|
|
bool mDoomWhenFoundPinned : 1;
|
|
bool mDoomWhenFoundNonPinned : 1;
|
|
// Set when after shutdown AND:
|
|
// - when writing: writing data (not metadata) OR the physical file handle is not currently open
|
|
// - when truncating: the physical file handle is not currently open
|
|
// When set it prevents any further writes or truncates on such handles to happen immediately
|
|
// after shutdown and gives a chance to write metadata of already open files quickly as possible
|
|
// (only that renders them actually usable by the cache.)
|
|
bool mKilled : 1;
|
|
// For existing files this is always pre-set to UNKNOWN. The status is udpated accordingly
|
|
// after the matadata has been parsed.
|
|
// For new files the flag is set according to which storage kind is opening
|
|
// the cache entry and remains so for the handle's lifetime.
|
|
// The status can only change from UNKNOWN (if set so initially) to one of PINNED or NON_PINNED
|
|
// and it stays unchanged afterwards.
|
|
// This status is only accessed on the IO thread.
|
|
PinningStatus mPinning;
|
|
|
|
nsCOMPtr<nsIFile> mFile;
|
|
int64_t mFileSize;
|
|
PRFileDesc *mFD; // if null then the file doesn't exists on the disk
|
|
nsCString mKey;
|
|
};
|
|
|
|
class CacheFileHandles {
|
|
public:
|
|
CacheFileHandles();
|
|
~CacheFileHandles();
|
|
|
|
nsresult GetHandle(const SHA1Sum::Hash *aHash, CacheFileHandle **_retval);
|
|
nsresult NewHandle(const SHA1Sum::Hash *aHash, bool aPriority,
|
|
CacheFileHandle::PinningStatus aPinning, CacheFileHandle **_retval);
|
|
void RemoveHandle(CacheFileHandle *aHandlle);
|
|
void GetAllHandles(nsTArray<RefPtr<CacheFileHandle> > *_retval);
|
|
void GetActiveHandles(nsTArray<RefPtr<CacheFileHandle> > *_retval);
|
|
void ClearAll();
|
|
uint32_t HandleCount();
|
|
|
|
#ifdef DEBUG_HANDLES
|
|
void Log(CacheFileHandlesEntry *entry);
|
|
#endif
|
|
|
|
// Memory reporting
|
|
size_t SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
|
|
size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
|
|
|
|
class HandleHashKey : public PLDHashEntryHdr
|
|
{
|
|
public:
|
|
typedef const SHA1Sum::Hash& KeyType;
|
|
typedef const SHA1Sum::Hash* KeyTypePointer;
|
|
|
|
explicit HandleHashKey(KeyTypePointer aKey)
|
|
{
|
|
MOZ_COUNT_CTOR(HandleHashKey);
|
|
mHash = MakeUnique<uint8_t[]>(SHA1Sum::kHashSize);
|
|
memcpy(mHash.get(), aKey, sizeof(SHA1Sum::Hash));
|
|
}
|
|
HandleHashKey(const HandleHashKey& aOther)
|
|
{
|
|
MOZ_ASSERT_UNREACHABLE("HandleHashKey copy constructor is forbidden!");
|
|
}
|
|
~HandleHashKey()
|
|
{
|
|
MOZ_COUNT_DTOR(HandleHashKey);
|
|
}
|
|
|
|
bool KeyEquals(KeyTypePointer aKey) const
|
|
{
|
|
return memcmp(mHash.get(), aKey, sizeof(SHA1Sum::Hash)) == 0;
|
|
}
|
|
static KeyTypePointer KeyToPointer(KeyType aKey)
|
|
{
|
|
return &aKey;
|
|
}
|
|
static PLDHashNumber HashKey(KeyTypePointer aKey)
|
|
{
|
|
return (reinterpret_cast<const uint32_t *>(aKey))[0];
|
|
}
|
|
|
|
void AddHandle(CacheFileHandle* aHandle);
|
|
void RemoveHandle(CacheFileHandle* aHandle);
|
|
already_AddRefed<CacheFileHandle> GetNewestHandle();
|
|
void GetHandles(nsTArray<RefPtr<CacheFileHandle> > &aResult);
|
|
|
|
SHA1Sum::Hash *Hash() const
|
|
{
|
|
return reinterpret_cast<SHA1Sum::Hash*>(mHash.get());
|
|
}
|
|
bool IsEmpty() const { return mHandles.Length() == 0; }
|
|
|
|
enum { ALLOW_MEMMOVE = true };
|
|
|
|
#ifdef DEBUG
|
|
void AssertHandlesState();
|
|
#endif
|
|
|
|
// Memory reporting
|
|
size_t SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
|
|
size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
|
|
|
|
private:
|
|
// We can't make this UniquePtr<SHA1Sum::Hash>, because you can't have
|
|
// UniquePtrs with known bounds. So we settle for this representation
|
|
// and using appropriate casts when we need to access it as a
|
|
// SHA1Sum::Hash.
|
|
UniquePtr<uint8_t[]> mHash;
|
|
// Use weak pointers since the hash table access is on a single thread
|
|
// only and CacheFileHandle removes itself from this table in its dtor
|
|
// that may only be called on the same thread as we work with the hashtable
|
|
// since we dispatch its Release() to this thread.
|
|
nsTArray<CacheFileHandle*> mHandles;
|
|
};
|
|
|
|
private:
|
|
nsTHashtable<HandleHashKey> mTable;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
class OpenFileEvent;
|
|
class ReadEvent;
|
|
class WriteEvent;
|
|
class MetadataWriteScheduleEvent;
|
|
class CacheFileContextEvictor;
|
|
|
|
#define CACHEFILEIOLISTENER_IID \
|
|
{ /* dcaf2ddc-17cf-4242-bca1-8c86936375a5 */ \
|
|
0xdcaf2ddc, \
|
|
0x17cf, \
|
|
0x4242, \
|
|
{0xbc, 0xa1, 0x8c, 0x86, 0x93, 0x63, 0x75, 0xa5} \
|
|
}
|
|
|
|
class CacheFileIOListener : public nsISupports
|
|
{
|
|
public:
|
|
NS_DECLARE_STATIC_IID_ACCESSOR(CACHEFILEIOLISTENER_IID)
|
|
|
|
NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult) = 0;
|
|
NS_IMETHOD OnDataWritten(CacheFileHandle *aHandle, const char *aBuf,
|
|
nsresult aResult) = 0;
|
|
NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf,
|
|
nsresult aResult) = 0;
|
|
NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult) = 0;
|
|
NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult) = 0;
|
|
NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult) = 0;
|
|
|
|
virtual bool IsKilled() { return false; }
|
|
};
|
|
|
|
NS_DEFINE_STATIC_IID_ACCESSOR(CacheFileIOListener, CACHEFILEIOLISTENER_IID)
|
|
|
|
|
|
class CacheFileIOManager final
|
|
: public nsITimerCallback
|
|
, public nsINamed
|
|
{
|
|
public:
|
|
NS_DECL_THREADSAFE_ISUPPORTS
|
|
NS_DECL_NSITIMERCALLBACK
|
|
NS_DECL_NSINAMED
|
|
|
|
enum {
|
|
OPEN = 0U,
|
|
CREATE = 1U,
|
|
CREATE_NEW = 2U,
|
|
PRIORITY = 4U,
|
|
SPECIAL_FILE = 8U,
|
|
PINNED = 16U
|
|
};
|
|
|
|
CacheFileIOManager();
|
|
|
|
static nsresult Init();
|
|
static nsresult Shutdown();
|
|
static nsresult OnProfile();
|
|
static already_AddRefed<nsIEventTarget> IOTarget();
|
|
static already_AddRefed<CacheIOThread> IOThread();
|
|
static bool IsOnIOThread();
|
|
static bool IsOnIOThreadOrCeased();
|
|
static bool IsShutdown();
|
|
|
|
// Make aFile's WriteMetadataIfNeeded be called automatically after
|
|
// a short interval.
|
|
static nsresult ScheduleMetadataWrite(CacheFile * aFile);
|
|
// Remove aFile from the scheduling registry array.
|
|
// WriteMetadataIfNeeded will not be automatically called.
|
|
static nsresult UnscheduleMetadataWrite(CacheFile * aFile);
|
|
// Shuts the scheduling off and flushes all pending metadata writes.
|
|
static nsresult ShutdownMetadataWriteScheduling();
|
|
|
|
static nsresult OpenFile(const nsACString &aKey,
|
|
uint32_t aFlags, CacheFileIOListener *aCallback);
|
|
static nsresult Read(CacheFileHandle *aHandle, int64_t aOffset,
|
|
char *aBuf, int32_t aCount,
|
|
CacheFileIOListener *aCallback);
|
|
static nsresult Write(CacheFileHandle *aHandle, int64_t aOffset,
|
|
const char *aBuf, int32_t aCount, bool aValidate,
|
|
bool aTruncate, CacheFileIOListener *aCallback);
|
|
// PinningDoomRestriction:
|
|
// NO_RESTRICTION
|
|
// no restriction is checked, the file is simply always doomed
|
|
// DOOM_WHEN_(NON)_PINNED, we branch based on the pinning status of the handle:
|
|
// UNKNOWN: the handle is marked to be doomed when later found (non)pinned
|
|
// PINNED/NON_PINNED: doom only when the restriction matches the pin status
|
|
// and the handle has not yet been required to doom during the UNKNOWN
|
|
// period
|
|
enum PinningDoomRestriction {
|
|
NO_RESTRICTION,
|
|
DOOM_WHEN_NON_PINNED,
|
|
DOOM_WHEN_PINNED
|
|
};
|
|
static nsresult DoomFile(CacheFileHandle *aHandle,
|
|
CacheFileIOListener *aCallback);
|
|
static nsresult DoomFileByKey(const nsACString &aKey,
|
|
CacheFileIOListener *aCallback);
|
|
static nsresult ReleaseNSPRHandle(CacheFileHandle *aHandle);
|
|
static nsresult TruncateSeekSetEOF(CacheFileHandle *aHandle,
|
|
int64_t aTruncatePos, int64_t aEOFPos,
|
|
CacheFileIOListener *aCallback);
|
|
static nsresult RenameFile(CacheFileHandle *aHandle,
|
|
const nsACString &aNewName,
|
|
CacheFileIOListener *aCallback);
|
|
static nsresult EvictIfOverLimit();
|
|
static nsresult EvictAll();
|
|
static nsresult EvictByContext(nsILoadContextInfo *aLoadContextInfo,
|
|
bool aPinning);
|
|
|
|
static nsresult InitIndexEntry(CacheFileHandle *aHandle,
|
|
OriginAttrsHash aOriginAttrsHash,
|
|
bool aAnonymous,
|
|
bool aPinning);
|
|
static nsresult UpdateIndexEntry(CacheFileHandle *aHandle,
|
|
const uint32_t *aFrecency,
|
|
const uint32_t *aExpirationTime,
|
|
const bool *aHasAltData,
|
|
const uint16_t *aOnStartTime,
|
|
const uint16_t *aOnStopTime);
|
|
|
|
static nsresult UpdateIndexEntry();
|
|
|
|
enum EEnumerateMode {
|
|
ENTRIES,
|
|
DOOMED
|
|
};
|
|
|
|
static void GetCacheDirectory(nsIFile** result);
|
|
#if defined(MOZ_WIDGET_ANDROID)
|
|
static void GetProfilelessCacheDirectory(nsIFile** result);
|
|
#endif
|
|
|
|
// Calls synchronously OnEntryInfo for an entry with the given hash.
|
|
// Tries to find an existing entry in the service hashtables first, if not
|
|
// found, loads synchronously from disk file.
|
|
// Callable on the IO thread only.
|
|
static nsresult GetEntryInfo(const SHA1Sum::Hash *aHash,
|
|
CacheStorageService::EntryInfoCallback *aCallback);
|
|
|
|
// Memory reporting
|
|
static size_t SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf);
|
|
static size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf);
|
|
|
|
private:
|
|
friend class CacheFileHandle;
|
|
friend class CacheFileChunk;
|
|
friend class CacheFile;
|
|
friend class ShutdownEvent;
|
|
friend class OpenFileEvent;
|
|
friend class CloseHandleEvent;
|
|
friend class ReadEvent;
|
|
friend class WriteEvent;
|
|
friend class DoomFileEvent;
|
|
friend class DoomFileByKeyEvent;
|
|
friend class ReleaseNSPRHandleEvent;
|
|
friend class TruncateSeekSetEOFEvent;
|
|
friend class RenameFileEvent;
|
|
friend class CacheIndex;
|
|
friend class MetadataWriteScheduleEvent;
|
|
friend class CacheFileContextEvictor;
|
|
|
|
virtual ~CacheFileIOManager();
|
|
|
|
nsresult InitInternal();
|
|
nsresult ShutdownInternal();
|
|
|
|
nsresult OpenFileInternal(const SHA1Sum::Hash *aHash,
|
|
const nsACString &aKey,
|
|
uint32_t aFlags,
|
|
CacheFileHandle **_retval);
|
|
nsresult OpenSpecialFileInternal(const nsACString &aKey,
|
|
uint32_t aFlags,
|
|
CacheFileHandle **_retval);
|
|
nsresult CloseHandleInternal(CacheFileHandle *aHandle);
|
|
nsresult ReadInternal(CacheFileHandle *aHandle, int64_t aOffset,
|
|
char *aBuf, int32_t aCount);
|
|
nsresult WriteInternal(CacheFileHandle *aHandle, int64_t aOffset,
|
|
const char *aBuf, int32_t aCount, bool aValidate,
|
|
bool aTruncate);
|
|
nsresult DoomFileInternal(CacheFileHandle *aHandle,
|
|
PinningDoomRestriction aPinningStatusRestriction = NO_RESTRICTION);
|
|
nsresult DoomFileByKeyInternal(const SHA1Sum::Hash *aHash);
|
|
nsresult MaybeReleaseNSPRHandleInternal(CacheFileHandle *aHandle,
|
|
bool aIgnoreShutdownLag = false);
|
|
nsresult TruncateSeekSetEOFInternal(CacheFileHandle *aHandle,
|
|
int64_t aTruncatePos, int64_t aEOFPos);
|
|
nsresult RenameFileInternal(CacheFileHandle *aHandle,
|
|
const nsACString &aNewName);
|
|
nsresult EvictIfOverLimitInternal();
|
|
nsresult OverLimitEvictionInternal();
|
|
nsresult EvictAllInternal();
|
|
nsresult EvictByContextInternal(nsILoadContextInfo *aLoadContextInfo,
|
|
bool aPinning);
|
|
|
|
nsresult TrashDirectory(nsIFile *aFile);
|
|
static void OnTrashTimer(nsITimer *aTimer, void *aClosure);
|
|
nsresult StartRemovingTrash();
|
|
nsresult RemoveTrashInternal();
|
|
nsresult FindTrashDirToRemove();
|
|
|
|
nsresult CreateFile(CacheFileHandle *aHandle);
|
|
static void HashToStr(const SHA1Sum::Hash *aHash, nsACString &_retval);
|
|
static nsresult StrToHash(const nsACString &aHash, SHA1Sum::Hash *_retval);
|
|
nsresult GetFile(const SHA1Sum::Hash *aHash, nsIFile **_retval);
|
|
nsresult GetSpecialFile(const nsACString &aKey, nsIFile **_retval);
|
|
nsresult GetDoomedFile(nsIFile **_retval);
|
|
nsresult IsEmptyDirectory(nsIFile *aFile, bool *_retval);
|
|
nsresult CheckAndCreateDir(nsIFile *aFile, const char *aDir,
|
|
bool aEnsureEmptyDir);
|
|
nsresult CreateCacheTree();
|
|
nsresult OpenNSPRHandle(CacheFileHandle *aHandle, bool aCreate = false);
|
|
void NSPRHandleUsed(CacheFileHandle *aHandle);
|
|
|
|
// Removing all cache files during shutdown
|
|
nsresult SyncRemoveDir(nsIFile *aFile, const char *aDir);
|
|
void SyncRemoveAllCacheFiles();
|
|
|
|
nsresult ScheduleMetadataWriteInternal(CacheFile * aFile);
|
|
nsresult UnscheduleMetadataWriteInternal(CacheFile * aFile);
|
|
nsresult ShutdownMetadataWriteSchedulingInternal();
|
|
|
|
static nsresult CacheIndexStateChanged();
|
|
nsresult CacheIndexStateChangedInternal();
|
|
|
|
// Smart size calculation. UpdateSmartCacheSize() must be called on IO thread.
|
|
// It is called in EvictIfOverLimitInternal() just before we decide whether to
|
|
// start overlimit eviction or not and also in OverLimitEvictionInternal()
|
|
// before we start an eviction loop.
|
|
nsresult UpdateSmartCacheSize(int64_t aFreeSpace);
|
|
|
|
// Memory reporting (private part)
|
|
size_t SizeOfExcludingThisInternal(mozilla::MallocSizeOf mallocSizeOf) const;
|
|
|
|
static StaticRefPtr<CacheFileIOManager> gInstance;
|
|
|
|
TimeStamp mStartTime;
|
|
// Set true on the IO thread, CLOSE level as part of the internal shutdown
|
|
// procedure.
|
|
bool mShuttingDown;
|
|
RefPtr<CacheIOThread> mIOThread;
|
|
nsCOMPtr<nsIFile> mCacheDirectory;
|
|
#if defined(MOZ_WIDGET_ANDROID)
|
|
// On Android we add the active profile directory name between the path
|
|
// and the 'cache2' leaf name. However, to delete any leftover data from
|
|
// times before we were doing it, we still need to access the directory
|
|
// w/o the profile name in the path. Here it is stored.
|
|
nsCOMPtr<nsIFile> mCacheProfilelessDirectory;
|
|
#endif
|
|
bool mTreeCreated;
|
|
bool mTreeCreationFailed;
|
|
CacheFileHandles mHandles;
|
|
nsTArray<CacheFileHandle *> mHandlesByLastUsed;
|
|
nsTArray<CacheFileHandle *> mSpecialHandles;
|
|
nsTArray<RefPtr<CacheFile> > mScheduledMetadataWrites;
|
|
nsCOMPtr<nsITimer> mMetadataWritesTimer;
|
|
bool mOverLimitEvicting;
|
|
// When overlimit eviction is too slow and cache size reaches 105% of the
|
|
// limit, this flag is set and no other content is cached to prevent
|
|
// uncontrolled cache growing.
|
|
bool mCacheSizeOnHardLimit;
|
|
bool mRemovingTrashDirs;
|
|
nsCOMPtr<nsITimer> mTrashTimer;
|
|
nsCOMPtr<nsIFile> mTrashDir;
|
|
nsCOMPtr<nsIDirectoryEnumerator> mTrashDirEnumerator;
|
|
nsTArray<nsCString> mFailedTrashDirs;
|
|
RefPtr<CacheFileContextEvictor> mContextEvictor;
|
|
TimeStamp mLastSmartSizeTime;
|
|
};
|
|
|
|
} // namespace net
|
|
} // namespace mozilla
|
|
|
|
#endif
|