Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-11-24 13:21:05 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1117042 - Mark virtual overridden functions as MOZ_OVERRIDE in netwerk; r=mcmanus

Browse Source
This commit is contained in:
Ehsan Akhgari 2015-01-02 01:24:13 -05:00
parent 390eaebf41
commit e9499ce141
59 changed files with 484 additions and 556 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
netwerk/base/src/BackgroundFileSaver.h
View File

@ -54,7 +54,7 @@ public:
/**
* Used by nsNSSShutDownList to manage nsNSSShutDownObjects.
*/
void virtualDestroyNSSReference();
void virtualDestroyNSSReference() MOZ_OVERRIDE;
/**
* Number of worker threads that are currently running.
@ -400,7 +400,7 @@ public:
DigestOutputStream(nsIOutputStream* outputStream, PK11Context* aContext);
// We don't own any NSS objects here, so no need to clean up
void virtualDestroyNSSReference() { }
void virtualDestroyNSSReference() MOZ_OVERRIDE { }
private:
~DigestOutputStream();

4
netwerk/base/src/ProxyAutoConfig.cpp
View File

@ -272,7 +272,7 @@ public:
// nsIDNSListener
NS_IMETHODIMP OnLookupComplete(nsICancelable *request,
nsIDNSRecord *record,
nsresult status)
nsresult status) MOZ_OVERRIDE
{
if (mTimer) {
mTimer->Cancel();
@ -286,7 +286,7 @@ public:
}
// nsITimerCallback
NS_IMETHODIMP Notify(nsITimer *timer)
NS_IMETHODIMP Notify(nsITimer *timer) MOZ_OVERRIDE
{
if (mRequest)
mRequest->Cancel(NS_ERROR_NET_TIMEOUT);

2
netwerk/base/src/nsAsyncStreamCopier.h
View File

@ -31,7 +31,7 @@ public:
nsIEventTarget *aTarget,
uint32_t aChunkSize,
bool aCloseSource,
bool aCloseSink);
bool aCloseSink) MOZ_OVERRIDE;
nsAsyncStreamCopier();

6
netwerk/base/src/nsBufferedStreams.h
View File

@ -82,8 +82,8 @@ public:
protected:
virtual ~nsBufferedInputStream() {}
NS_IMETHOD Fill();
NS_IMETHOD Flush() { return NS_OK; } // no-op for input streams
NS_IMETHOD Fill() MOZ_OVERRIDE;
NS_IMETHOD Flush() MOZ_OVERRIDE { return NS_OK; } // no-op for input streams
};
////////////////////////////////////////////////////////////////////////////////
@ -112,7 +112,7 @@ public:
protected:
virtual ~nsBufferedOutputStream() { nsBufferedOutputStream::Close(); }
NS_IMETHOD Fill() { return NS_OK; } // no-op for output streams
NS_IMETHOD Fill() MOZ_OVERRIDE { return NS_OK; } // no-op for output streams
nsCOMPtr<nsISafeOutputStream> mSafeStream; // QI'd from mStream
};

38
netwerk/base/src/nsFileStreams.h
View File

@ -112,23 +112,23 @@ public:
NS_DECL_NSILINEINPUTSTREAM
NS_DECL_NSIIPCSERIALIZABLEINPUTSTREAM
NS_IMETHOD Close();
NS_IMETHOD Tell(int64_t *aResult);
NS_IMETHOD Available(uint64_t* _retval);
NS_IMETHOD Read(char* aBuf, uint32_t aCount, uint32_t* _retval);
NS_IMETHOD Close() MOZ_OVERRIDE;
NS_IMETHOD Tell(int64_t *aResult) MOZ_OVERRIDE;
NS_IMETHOD Available(uint64_t* _retval) MOZ_OVERRIDE;
NS_IMETHOD Read(char* aBuf, uint32_t aCount, uint32_t* _retval) MOZ_OVERRIDE;
NS_IMETHOD ReadSegments(nsWriteSegmentFun aWriter, void *aClosure,
uint32_t aCount, uint32_t* _retval)
uint32_t aCount, uint32_t* _retval) MOZ_OVERRIDE
{
return nsFileStreamBase::ReadSegments(aWriter, aClosure, aCount,
_retval);
}
NS_IMETHOD IsNonBlocking(bool* _retval)
NS_IMETHOD IsNonBlocking(bool* _retval) MOZ_OVERRIDE
{
return nsFileStreamBase::IsNonBlocking(_retval);
}
// Overrided from nsFileStreamBase
NS_IMETHOD Seek(int32_t aWhence, int64_t aOffset);
NS_IMETHOD Seek(int32_t aWhence, int64_t aOffset) MOZ_OVERRIDE;
nsFileInputStream()
: mLineBuffer(nullptr), mIOFlags(0), mPerm(0), mCachedPosition(0)
@ -187,10 +187,10 @@ public:
: mStart(0), mLength(0), mPosition(0)
{ }
NS_IMETHOD Tell(int64_t *aResult);
NS_IMETHOD Available(uint64_t *aResult);
NS_IMETHOD Read(char* aBuf, uint32_t aCount, uint32_t* aResult);
NS_IMETHOD Seek(int32_t aWhence, int64_t aOffset);
NS_IMETHOD Tell(int64_t *aResult) MOZ_OVERRIDE;
NS_IMETHOD Available(uint64_t *aResult) MOZ_OVERRIDE;
NS_IMETHOD Read(char* aBuf, uint32_t aCount, uint32_t* aResult) MOZ_OVERRIDE;
NS_IMETHOD Seek(int32_t aWhence, int64_t aOffset) MOZ_OVERRIDE;
static nsresult
Create(nsISupports *aOuter, REFNSIID aIID, void **aResult);
@ -249,9 +249,9 @@ public:
virtual nsresult DoOpen() MOZ_OVERRIDE;
NS_IMETHODIMP Close();
NS_IMETHODIMP Write(const char *buf, uint32_t count, uint32_t *result);
NS_IMETHODIMP Init(nsIFile* file, int32_t ioFlags, int32_t perm, int32_t behaviorFlags);
NS_IMETHODIMP Close() MOZ_OVERRIDE;
NS_IMETHODIMP Write(const char *buf, uint32_t count, uint32_t *result) MOZ_OVERRIDE;
NS_IMETHODIMP Init(nsIFile* file, int32_t ioFlags, int32_t perm, int32_t behaviorFlags) MOZ_OVERRIDE;
protected:
virtual ~nsAtomicFileOutputStream()
@ -279,7 +279,7 @@ class nsSafeFileOutputStream : public nsAtomicFileOutputStream
{
public:
NS_IMETHOD Finish();
NS_IMETHOD Finish() MOZ_OVERRIDE;
};
////////////////////////////////////////////////////////////////////////////////
@ -296,21 +296,21 @@ public:
// Can't use NS_FORWARD_NSIOUTPUTSTREAM due to overlapping methods
// Close() and IsNonBlocking()
NS_IMETHOD Flush()
NS_IMETHOD Flush() MOZ_OVERRIDE
{
return nsFileStreamBase::Flush();
}
NS_IMETHOD Write(const char* aBuf, uint32_t aCount, uint32_t* _retval)
NS_IMETHOD Write(const char* aBuf, uint32_t aCount, uint32_t* _retval) MOZ_OVERRIDE
{
return nsFileStreamBase::Write(aBuf, aCount, _retval);
}
NS_IMETHOD WriteFrom(nsIInputStream* aFromStream, uint32_t aCount,
uint32_t* _retval)
uint32_t* _retval) MOZ_OVERRIDE
{
return nsFileStreamBase::WriteFrom(aFromStream, aCount, _retval);
}
NS_IMETHOD WriteSegments(nsReadSegmentFun aReader, void* aClosure,
uint32_t aCount, uint32_t* _retval)
uint32_t aCount, uint32_t* _retval) MOZ_OVERRIDE
{
return nsFileStreamBase::WriteSegments(aReader, aClosure, aCount,
_retval);

4
netwerk/base/src/nsIOService.h
View File

@ -174,13 +174,13 @@ public:
{
}
NS_IMETHODIMP GetMode(int32_t *aMode)
NS_IMETHODIMP GetMode(int32_t *aMode) MOZ_OVERRIDE
{
*aMode = mMode;
return NS_OK;
}
NS_IMETHODIMP GetAppId(uint32_t *aAppId)
NS_IMETHODIMP GetAppId(uint32_t *aAppId) MOZ_OVERRIDE
{
*aAppId = mAppId;
return NS_OK;

2
netwerk/base/src/nsInputStreamChannel.h
View File

@ -25,7 +25,7 @@ protected:
virtual ~nsInputStreamChannel() {}
virtual nsresult OpenContentStream(bool async, nsIInputStream **result,
nsIChannel** channel);
nsIChannel** channel) MOZ_OVERRIDE;
virtual void OnChannelDone() MOZ_OVERRIDE {
mContentStream = nullptr;

8
netwerk/base/src/nsProtocolProxyService.cpp
View File

@ -136,14 +136,14 @@ public:
mProxyInfo = pi;
}
NS_IMETHOD Run()
NS_IMETHOD Run() MOZ_OVERRIDE
{
if (mCallback)
DoCallback();
return NS_OK;
}
NS_IMETHOD Cancel(nsresult reason)
NS_IMETHOD Cancel(nsresult reason) MOZ_OVERRIDE
{
NS_ENSURE_ARG(NS_FAILED(reason));
@ -178,7 +178,7 @@ private:
// before calling DoCallback.
void OnQueryComplete(nsresult status,
const nsCString &pacString,
const nsCString &newPACURL)
const nsCString &newPACURL) MOZ_OVERRIDE
{
// If we've already called DoCallback then, nothing more to do.
if (!mCallback)
@ -1067,7 +1067,7 @@ class nsAsyncBridgeRequest MOZ_FINAL : public nsPACManCallback
void OnQueryComplete(nsresult status,
const nsCString &pacString,
const nsCString &newPACURL)
const nsCString &newPACURL) MOZ_OVERRIDE
{
MutexAutoLock lock(mMutex);
mCompleted = true;

12
netwerk/base/src/nsServerSocket.h
View File

@ -26,13 +26,13 @@ public:
NS_DECL_NSISERVERSOCKET
// nsASocketHandler methods:
virtual void OnSocketReady(PRFileDesc *fd, int16_t outFlags);
virtual void OnSocketDetached(PRFileDesc *fd);
virtual void IsLocal(bool *aIsLocal);
virtual void KeepWhenOffline(bool *aKeepWhenOffline);
virtual void OnSocketReady(PRFileDesc *fd, int16_t outFlags) MOZ_OVERRIDE;
virtual void OnSocketDetached(PRFileDesc *fd) MOZ_OVERRIDE;
virtual void IsLocal(bool *aIsLocal) MOZ_OVERRIDE;
virtual void KeepWhenOffline(bool *aKeepWhenOffline) MOZ_OVERRIDE;
virtual uint64_t ByteCountSent() { return 0; }
virtual uint64_t ByteCountReceived() { return 0; }
virtual uint64_t ByteCountSent() MOZ_OVERRIDE { return 0; }
virtual uint64_t ByteCountReceived() MOZ_OVERRIDE { return 0; }
nsServerSocket();
virtual void CreateClientTransport(PRFileDesc* clientFD,

10
netwerk/base/src/nsSimpleNestedURI.h
View File

@ -45,16 +45,16 @@ public:
// nsSimpleURI overrides
virtual nsresult EqualsInternal(nsIURI* other,
RefHandlingEnum refHandlingMode,
bool* result);
virtual nsSimpleURI* StartClone(RefHandlingEnum refHandlingMode);
bool* result) MOZ_OVERRIDE;
virtual nsSimpleURI* StartClone(RefHandlingEnum refHandlingMode) MOZ_OVERRIDE;
// nsISerializable overrides
NS_IMETHOD Read(nsIObjectInputStream* aStream);
NS_IMETHOD Write(nsIObjectOutputStream* aStream);
NS_IMETHOD Read(nsIObjectInputStream* aStream) MOZ_OVERRIDE;
NS_IMETHOD Write(nsIObjectOutputStream* aStream) MOZ_OVERRIDE;
// Override the nsIClassInfo method GetClassIDNoAlloc to make sure our
// nsISerializable impl works right.
NS_IMETHOD GetClassIDNoAlloc(nsCID *aClassIDNoAlloc);
NS_IMETHOD GetClassIDNoAlloc(nsCID *aClassIDNoAlloc) MOZ_OVERRIDE;
protected:
nsCOMPtr<nsIURI> mInnerURI;

4
netwerk/base/src/nsSimpleURI.h
View File

@ -52,8 +52,8 @@ public:
// - nsJSURI: mBaseURI
// - nsSimpleNestedURI: mInnerURI
// - nsBlobURI: mPrincipal
virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE;
virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE;
protected:
// enum used in a few places to specify how .ref attribute should be handled

10
netwerk/base/src/nsSocketTransport2.h
View File

@ -143,16 +143,16 @@ public:
nsresult InitWithFilename(const char *filename);
// nsASocketHandler methods:
void OnSocketReady(PRFileDesc *, int16_t outFlags);
void OnSocketDetached(PRFileDesc *);
void IsLocal(bool *aIsLocal);
void OnSocketReady(PRFileDesc *, int16_t outFlags) MOZ_OVERRIDE;
void OnSocketDetached(PRFileDesc *) MOZ_OVERRIDE;
void IsLocal(bool *aIsLocal) MOZ_OVERRIDE;
void OnKeepaliveEnabledPrefChange(bool aEnabled) MOZ_OVERRIDE MOZ_FINAL;
// called when a socket event is handled
void OnSocketEvent(uint32_t type, nsresult status, nsISupports *param);
uint64_t ByteCountReceived() { return mInput.ByteCount(); }
uint64_t ByteCountSent() { return mOutput.ByteCount(); }
uint64_t ByteCountReceived() MOZ_OVERRIDE { return mInput.ByteCount(); }
uint64_t ByteCountSent() MOZ_OVERRIDE { return mOutput.ByteCount(); }
protected:
virtual ~nsSocketTransport();

4
netwerk/base/src/nsStandardURL.h
View File

@ -58,8 +58,8 @@ public:
NS_DECL_NSIIPCSERIALIZABLEURI
// nsISizeOf
virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE;
virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE;
explicit nsStandardURL(bool aSupportsFileURL = false, bool aTrackURL = true);

10
netwerk/base/src/nsUDPSocket.h
View File

@ -22,12 +22,12 @@ public:
NS_DECL_NSIUDPSOCKET
// nsASocketHandler methods:
virtual void OnSocketReady(PRFileDesc* fd, int16_t outFlags);
virtual void OnSocketDetached(PRFileDesc* fd);
virtual void IsLocal(bool* aIsLocal);
virtual void OnSocketReady(PRFileDesc* fd, int16_t outFlags) MOZ_OVERRIDE;
virtual void OnSocketDetached(PRFileDesc* fd) MOZ_OVERRIDE;
virtual void IsLocal(bool* aIsLocal) MOZ_OVERRIDE;
uint64_t ByteCountSent() { return mByteWriteCount; }
uint64_t ByteCountReceived() { return mByteReadCount; }
uint64_t ByteCountSent() MOZ_OVERRIDE { return mByteWriteCount; }
uint64_t ByteCountReceived() MOZ_OVERRIDE { return mByteReadCount; }
void AddOutputBytes(uint64_t aBytes);

14
netwerk/base/src/nsURLParsers.h
View File

@ -51,18 +51,18 @@ public:
NS_IMETHOD ParseFilePath(const char *, int32_t,
uint32_t *, int32_t *,
uint32_t *, int32_t *,
uint32_t *, int32_t *);
uint32_t *, int32_t *) MOZ_OVERRIDE;
#endif
NS_IMETHOD ParseAuthority(const char *auth, int32_t authLen,
uint32_t *usernamePos, int32_t *usernameLen,
uint32_t *passwordPos, int32_t *passwordLen,
uint32_t *hostnamePos, int32_t *hostnameLen,
int32_t *port);
int32_t *port) MOZ_OVERRIDE;
void ParseAfterScheme(const char *spec, int32_t specLen,
uint32_t *authPos, int32_t *authLen,
uint32_t *pathPos, int32_t *pathLen);
uint32_t *pathPos, int32_t *pathLen) MOZ_OVERRIDE;
};
//----------------------------------------------------------------------------
@ -86,19 +86,19 @@ public:
uint32_t *usernamePos, int32_t *usernameLen,
uint32_t *passwordPos, int32_t *passwordLen,
uint32_t *hostnamePos, int32_t *hostnameLen,
int32_t *port);
int32_t *port) MOZ_OVERRIDE;
NS_IMETHOD ParseUserInfo(const char *userinfo, int32_t userinfoLen,
uint32_t *usernamePos, int32_t *usernameLen,
uint32_t *passwordPos, int32_t *passwordLen);
uint32_t *passwordPos, int32_t *passwordLen) MOZ_OVERRIDE;
NS_IMETHOD ParseServerInfo(const char *serverinfo, int32_t serverinfoLen,
uint32_t *hostnamePos, int32_t *hostnameLen,
int32_t *port);
int32_t *port) MOZ_OVERRIDE;
void ParseAfterScheme(const char *spec, int32_t specLen,
uint32_t *authPos, int32_t *authLen,
uint32_t *pathPos, int32_t *pathLen);
uint32_t *pathPos, int32_t *pathLen) MOZ_OVERRIDE;
};
//----------------------------------------------------------------------------

2
netwerk/cache/nsApplicationCacheService.cpp vendored
View File

@ -213,7 +213,7 @@ public:
// nsIObserver implementation.
NS_IMETHODIMP
Observe(nsISupports *aSubject, const char *aTopic, const char16_t *aData)
Observe(nsISupports *aSubject, const char *aTopic, const char16_t *aData) MOZ_OVERRIDE
{
MOZ_ASSERT(!nsCRT::strcmp(aTopic, TOPIC_WEB_APP_CLEAR_DATA));

8
netwerk/cache/nsCacheEntryDescriptor.h vendored
View File

@ -128,8 +128,8 @@ private:
, mStreamEnded(false)
{
}
NS_IMETHOD Read(char* buf, uint32_t count, uint32_t * result);
NS_IMETHOD Close();
NS_IMETHOD Read(char* buf, uint32_t count, uint32_t * result) MOZ_OVERRIDE;
NS_IMETHOD Close() MOZ_OVERRIDE;
private:
virtual ~nsDecompressInputStreamWrapper()
{
@ -209,8 +209,8 @@ private:
, mUncompressedCount(0)
{
}
NS_IMETHOD Write(const char* buf, uint32_t count, uint32_t * result);
NS_IMETHOD Close();
NS_IMETHOD Write(const char* buf, uint32_t count, uint32_t * result) MOZ_OVERRIDE;
NS_IMETHOD Close() MOZ_OVERRIDE;
private:
virtual ~nsCompressOutputStreamWrapper()
{

2
netwerk/cache/nsCacheService.cpp vendored
View File

@ -210,7 +210,7 @@ class nsSetDiskSmartSizeCallback MOZ_FINAL : public nsITimerCallback
public:
NS_DECL_THREADSAFE_ISUPPORTS
NS_IMETHOD Notify(nsITimer* aTimer) {
NS_IMETHOD Notify(nsITimer* aTimer) MOZ_OVERRIDE {
if (nsCacheService::gService) {
nsCacheServiceAutoLock autoLock(LOCK_TELEM(NSSETDISKSMARTSIZECALLBACK_NOTIFY));
nsCacheService::gService->SetDiskSmartSize_Locked();

26
netwerk/cache/nsDiskCacheDeviceSQL.h vendored
View File

@ -74,34 +74,34 @@ public:
* nsCacheDevice methods
*/
virtual nsresult Init();
virtual nsresult Init() MOZ_OVERRIDE;
nsresult InitWithSqlite(mozIStorageService * ss);
virtual nsresult Shutdown();
virtual nsresult Shutdown() MOZ_OVERRIDE;
virtual const char * GetDeviceID(void);
virtual nsCacheEntry * FindEntry(nsCString * key, bool *collision);
virtual nsresult DeactivateEntry(nsCacheEntry * entry);
virtual nsresult BindEntry(nsCacheEntry * entry);
virtual void DoomEntry( nsCacheEntry * entry );
virtual const char * GetDeviceID(void) MOZ_OVERRIDE;
virtual nsCacheEntry * FindEntry(nsCString * key, bool *collision) MOZ_OVERRIDE;
virtual nsresult DeactivateEntry(nsCacheEntry * entry) MOZ_OVERRIDE;
virtual nsresult BindEntry(nsCacheEntry * entry) MOZ_OVERRIDE;
virtual void DoomEntry( nsCacheEntry * entry ) MOZ_OVERRIDE;
virtual nsresult OpenInputStreamForEntry(nsCacheEntry * entry,
nsCacheAccessMode mode,
uint32_t offset,
nsIInputStream ** result);
nsIInputStream ** result) MOZ_OVERRIDE;
virtual nsresult OpenOutputStreamForEntry(nsCacheEntry * entry,
nsCacheAccessMode mode,
uint32_t offset,
nsIOutputStream ** result);
nsIOutputStream ** result) MOZ_OVERRIDE;
virtual nsresult GetFileForEntry(nsCacheEntry * entry,
nsIFile ** result);
nsIFile ** result) MOZ_OVERRIDE;
virtual nsresult OnDataSizeChange(nsCacheEntry * entry, int32_t deltaSize);
virtual nsresult OnDataSizeChange(nsCacheEntry * entry, int32_t deltaSize) MOZ_OVERRIDE;
virtual nsresult Visit(nsICacheVisitor * visitor);
virtual nsresult Visit(nsICacheVisitor * visitor) MOZ_OVERRIDE;
virtual nsresult EvictEntries(const char * clientID);
virtual nsresult EvictEntries(const char * clientID) MOZ_OVERRIDE;
/* Entry ownership */
nsresult GetOwnerDomains(const char * clientID,

4
netwerk/cache2/CacheEntry.h
View File

@ -123,8 +123,8 @@ private:
virtual ~CacheEntry();
// CacheFileListener
NS_IMETHOD OnFileReady(nsresult aResult, bool aIsNew);
NS_IMETHOD OnFileDoomed(nsresult aResult);
NS_IMETHOD OnFileReady(nsresult aResult, bool aIsNew) MOZ_OVERRIDE;
NS_IMETHOD OnFileDoomed(nsresult aResult) MOZ_OVERRIDE;
// Keep the service alive during life-time of an entry
nsRefPtr<CacheStorageService> mService;

12
netwerk/cache2/CacheFile.cpp
View File

@ -117,39 +117,39 @@ public:
}
NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult)
NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE
{
MOZ_CRASH("DoomFileHelper::OnFileOpened should not be called!");
return NS_ERROR_UNEXPECTED;
}
NS_IMETHOD OnDataWritten(CacheFileHandle *aHandle, const char *aBuf,
nsresult aResult)
nsresult aResult) MOZ_OVERRIDE
{
MOZ_CRASH("DoomFileHelper::OnDataWritten should not be called!");
return NS_ERROR_UNEXPECTED;
}
NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf, nsresult aResult)
NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf, nsresult aResult) MOZ_OVERRIDE
{
MOZ_CRASH("DoomFileHelper::OnDataRead should not be called!");
return NS_ERROR_UNEXPECTED;
}
NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult)
NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE
{
if (mListener)
mListener->OnFileDoomed(aResult);
return NS_OK;
}
NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult)
NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE
{
MOZ_CRASH("DoomFileHelper::OnEOFSet should not be called!");
return NS_ERROR_UNEXPECTED;
}
NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult)
NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE
{
MOZ_CRASH("DoomFileHelper::OnFileRenamed should not be called!");
return NS_ERROR_UNEXPECTED;

24
netwerk/cache2/CacheFile.h
View File

@ -59,22 +59,22 @@ public:
bool aPriority,
CacheFileListener *aCallback);
NS_IMETHOD OnChunkRead(nsresult aResult, CacheFileChunk *aChunk);
NS_IMETHOD OnChunkWritten(nsresult aResult, CacheFileChunk *aChunk);
NS_IMETHOD OnChunkRead(nsresult aResult, CacheFileChunk *aChunk) MOZ_OVERRIDE;
NS_IMETHOD OnChunkWritten(nsresult aResult, CacheFileChunk *aChunk) MOZ_OVERRIDE;
NS_IMETHOD OnChunkAvailable(nsresult aResult, uint32_t aChunkIdx,
CacheFileChunk *aChunk);
NS_IMETHOD OnChunkUpdated(CacheFileChunk *aChunk);
CacheFileChunk *aChunk) MOZ_OVERRIDE;
NS_IMETHOD OnChunkUpdated(CacheFileChunk *aChunk) MOZ_OVERRIDE;
NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult);
NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnDataWritten(CacheFileHandle *aHandle, const char *aBuf,
nsresult aResult);
NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf, nsresult aResult);
NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult);
NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult);
NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult);
nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnMetadataRead(nsresult aResult);
NS_IMETHOD OnMetadataWritten(nsresult aResult);
NS_IMETHOD OnMetadataRead(nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnMetadataWritten(nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OpenInputStream(nsIInputStream **_retval);
NS_IMETHOD OpenOutputStream(CacheOutputCloseListener *aCloseListener, nsIOutputStream **_retval);

12
netwerk/cache2/CacheFileChunk.h
View File

@ -87,13 +87,13 @@ public:
void UpdateDataSize(uint32_t aOffset, uint32_t aLen,
bool aEOF);
NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult);
NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnDataWritten(CacheFileHandle *aHandle, const char *aBuf,
nsresult aResult);
NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf, nsresult aResult);
NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult);
NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult);
NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult);
nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
bool IsReady() const;
bool IsDirty() const;

8
netwerk/cache2/CacheFileInputStream.h
View File

@ -29,11 +29,11 @@ class CacheFileInputStream : public nsIAsyncInputStream
public:
explicit CacheFileInputStream(CacheFile *aFile);
NS_IMETHOD OnChunkRead(nsresult aResult, CacheFileChunk *aChunk);
NS_IMETHOD OnChunkWritten(nsresult aResult, CacheFileChunk *aChunk);
NS_IMETHOD OnChunkRead(nsresult aResult, CacheFileChunk *aChunk) MOZ_OVERRIDE;
NS_IMETHOD OnChunkWritten(nsresult aResult, CacheFileChunk *aChunk) MOZ_OVERRIDE;
NS_IMETHOD OnChunkAvailable(nsresult aResult, uint32_t aChunkIdx,
CacheFileChunk *aChunk);
NS_IMETHOD OnChunkUpdated(CacheFileChunk *aChunk);
CacheFileChunk *aChunk) MOZ_OVERRIDE;
NS_IMETHOD OnChunkUpdated(CacheFileChunk *aChunk) MOZ_OVERRIDE;
// Memory reporting
size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;

12
netwerk/cache2/CacheFileMetadata.h
View File

@ -153,13 +153,13 @@ public:
bool IsDirty() { return mIsDirty; }
uint32_t MemoryUsage() { return sizeof(CacheFileMetadata) + mHashArraySize + mBufSize; }
NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult);
NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnDataWritten(CacheFileHandle *aHandle, const char *aBuf,
nsresult aResult);
NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf, nsresult aResult);
NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult);
NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult);
NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult);
nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
// Memory reporting
size_t SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const;

8
netwerk/cache2/CacheFileOutputStream.h
View File

@ -30,11 +30,11 @@ class CacheFileOutputStream : public nsIAsyncOutputStream
public:
CacheFileOutputStream(CacheFile *aFile, CacheOutputCloseListener *aCloseListener);
NS_IMETHOD OnChunkRead(nsresult aResult, CacheFileChunk *aChunk);
NS_IMETHOD OnChunkWritten(nsresult aResult, CacheFileChunk *aChunk);
NS_IMETHOD OnChunkRead(nsresult aResult, CacheFileChunk *aChunk) MOZ_OVERRIDE;
NS_IMETHOD OnChunkWritten(nsresult aResult, CacheFileChunk *aChunk) MOZ_OVERRIDE;
NS_IMETHOD OnChunkAvailable(nsresult aResult, uint32_t aChunkIdx,
CacheFileChunk *aChunk);
NS_IMETHOD OnChunkUpdated(CacheFileChunk *aChunk);
CacheFileChunk *aChunk) MOZ_OVERRIDE;
NS_IMETHOD OnChunkUpdated(CacheFileChunk *aChunk) MOZ_OVERRIDE;
void NotifyCloseListener();

12
netwerk/cache2/CacheIndex.cpp
View File

@ -179,26 +179,26 @@ public:
private:
virtual ~FileOpenHelper() {}
NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult);
NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnDataWritten(CacheFileHandle *aHandle, const char *aBuf,
nsresult aResult) {
nsresult aResult) MOZ_OVERRIDE {
MOZ_CRASH("FileOpenHelper::OnDataWritten should not be called!");
return NS_ERROR_UNEXPECTED;
}
NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf,
nsresult aResult) {
nsresult aResult) MOZ_OVERRIDE {
MOZ_CRASH("FileOpenHelper::OnDataRead should not be called!");
return NS_ERROR_UNEXPECTED;
}
NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult) {
NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE {
MOZ_CRASH("FileOpenHelper::OnFileDoomed should not be called!");
return NS_ERROR_UNEXPECTED;
}
NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult) {
NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE {
MOZ_CRASH("FileOpenHelper::OnEOFSet should not be called!");
return NS_ERROR_UNEXPECTED;
}
NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult) {
NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE {
MOZ_CRASH("FileOpenHelper::OnFileRenamed should not be called!");
return NS_ERROR_UNEXPECTED;
}

12
netwerk/cache2/CacheIndex.h
View File

@ -683,15 +683,15 @@ private:
virtual ~CacheIndex();
NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult);
NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
nsresult OnFileOpenedInternal(FileOpenHelper *aOpener,
CacheFileHandle *aHandle, nsresult aResult);
NS_IMETHOD OnDataWritten(CacheFileHandle *aHandle, const char *aBuf,
nsresult aResult);
NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf, nsresult aResult);
NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult);
NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult);
NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult);
nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
void Lock();
void Unlock();

12
netwerk/cache2/CacheStorageService.cpp
View File

@ -1506,12 +1506,12 @@ public:
private:
virtual ~CacheEntryDoomByKeyCallback();
NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult) { return NS_OK; }
NS_IMETHOD OnDataWritten(CacheFileHandle *aHandle, const char *aBuf, nsresult aResult) { return NS_OK; }
NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf, nsresult aResult) { return NS_OK; }
NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult);
NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult) { return NS_OK; }
NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult) { return NS_OK; }
NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE { return NS_OK; }
NS_IMETHOD OnDataWritten(CacheFileHandle *aHandle, const char *aBuf, nsresult aResult) MOZ_OVERRIDE { return NS_OK; }
NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf, nsresult aResult) MOZ_OVERRIDE { return NS_OK; }
NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE { return NS_OK; }
NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE { return NS_OK; }
nsCOMPtr<nsICacheEntryDoomCallback> mCallback;
nsresult mResult;

131
netwerk/cache2/OldWrappers.h
View File

@ -30,172 +30,101 @@ public:
NS_DECL_THREADSAFE_ISUPPORTS
// nsICacheEntryDescriptor
NS_IMETHOD SetExpirationTime(uint32_t expirationTime)
NS_IMETHOD SetExpirationTime(uint32_t expirationTime) MOZ_OVERRIDE
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->SetExpirationTime(expirationTime);
}
NS_IMETHOD SetDataSize(uint32_t size)
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->SetDataSize(size);
}
NS_IMETHOD OpenInputStream(uint32_t offset, nsIInputStream * *_retval)
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->OpenInputStream(offset, _retval);
}
NS_IMETHOD OpenOutputStream(uint32_t offset, nsIOutputStream * *_retval)
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->OpenOutputStream(offset, _retval);
}
NS_IMETHOD GetCacheElement(nsISupports * *aCacheElement)
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->GetCacheElement(aCacheElement);
}
NS_IMETHOD SetCacheElement(nsISupports *aCacheElement)
{ return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->SetCacheElement(aCacheElement);
}
NS_IMETHOD GetPredictedDataSize(int64_t *aPredictedDataSize)
NS_IMETHOD GetPredictedDataSize(int64_t *aPredictedDataSize) MOZ_OVERRIDE
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->GetPredictedDataSize(aPredictedDataSize);
}
NS_IMETHOD SetPredictedDataSize(int64_t aPredictedDataSize)
NS_IMETHOD SetPredictedDataSize(int64_t aPredictedDataSize) MOZ_OVERRIDE
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->SetPredictedDataSize(aPredictedDataSize);
}
NS_IMETHOD GetAccessGranted(nsCacheAccessMode *aAccessGranted)
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->GetAccessGranted(aAccessGranted);
}
NS_IMETHOD GetStoragePolicy(nsCacheStoragePolicy *aStoragePolicy)
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->GetStoragePolicy(aStoragePolicy);
}
NS_IMETHOD SetStoragePolicy(nsCacheStoragePolicy aStoragePolicy)
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->SetStoragePolicy(aStoragePolicy);
}
NS_IMETHOD GetFile(nsIFile * *aFile)
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->GetFile(aFile);
}
NS_IMETHOD GetSecurityInfo(nsISupports * *aSecurityInfo)
NS_IMETHOD GetSecurityInfo(nsISupports * *aSecurityInfo) MOZ_OVERRIDE
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->GetSecurityInfo(aSecurityInfo);
}
NS_IMETHOD SetSecurityInfo(nsISupports *aSecurityInfo)
NS_IMETHOD SetSecurityInfo(nsISupports *aSecurityInfo) MOZ_OVERRIDE
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->SetSecurityInfo(aSecurityInfo);
}
NS_IMETHOD GetStorageDataSize(uint32_t *aStorageDataSize)
NS_IMETHOD GetStorageDataSize(uint32_t *aStorageDataSize) MOZ_OVERRIDE
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->GetStorageDataSize(aStorageDataSize);
}
NS_IMETHOD Doom(void)
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->Doom();
}
NS_IMETHOD DoomAndFailPendingRequests(nsresult status)
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->DoomAndFailPendingRequests(status);
}
NS_IMETHOD AsyncDoom(nsICacheListener *listener)
nsresult AsyncDoom(nsICacheListener *listener)
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->AsyncDoom(listener);
}
NS_IMETHOD MarkValid(void)
NS_IMETHOD MarkValid(void) MOZ_OVERRIDE
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->MarkValid();
}
NS_IMETHOD Close(void)
NS_IMETHOD Close(void) MOZ_OVERRIDE
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->Close();
}
NS_IMETHOD GetMetaDataElement(const char * key, char * *_retval)
NS_IMETHOD GetMetaDataElement(const char * key, char * *_retval) MOZ_OVERRIDE
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->GetMetaDataElement(key, _retval);
}
NS_IMETHOD SetMetaDataElement(const char * key, const char * value)
NS_IMETHOD SetMetaDataElement(const char * key, const char * value) MOZ_OVERRIDE
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->SetMetaDataElement(key, value);
}
NS_IMETHOD VisitMetaData(nsICacheMetaDataVisitor *visitor)
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->VisitMetaData(visitor);
}
// nsICacheEntryInfo
NS_IMETHOD GetClientID(char * *aClientID)
{
return mOldInfo->GetClientID(aClientID);
}
NS_IMETHOD GetDeviceID(char * *aDeviceID)
{
return mOldInfo->GetDeviceID(aDeviceID);
}
NS_IMETHOD GetKey(nsACString & aKey)
NS_IMETHOD GetKey(nsACString & aKey) MOZ_OVERRIDE
{
return mOldInfo->GetKey(aKey);
}
NS_IMETHOD GetFetchCount(int32_t *aFetchCount)
NS_IMETHOD GetFetchCount(int32_t *aFetchCount) MOZ_OVERRIDE
{
return mOldInfo->GetFetchCount(aFetchCount);
}
NS_IMETHOD GetLastFetched(uint32_t *aLastFetched)
NS_IMETHOD GetLastFetched(uint32_t *aLastFetched) MOZ_OVERRIDE
{
return mOldInfo->GetLastFetched(aLastFetched);
}
NS_IMETHOD GetLastModified(uint32_t *aLastModified)
NS_IMETHOD GetLastModified(uint32_t *aLastModified) MOZ_OVERRIDE
{
return mOldInfo->GetLastModified(aLastModified);
}
NS_IMETHOD GetExpirationTime(uint32_t *aExpirationTime)
NS_IMETHOD GetExpirationTime(uint32_t *aExpirationTime) MOZ_OVERRIDE
{
return mOldInfo->GetExpirationTime(aExpirationTime);
}
NS_IMETHOD GetDataSize(uint32_t *aDataSize)
nsresult GetDataSize(uint32_t *aDataSize)
{
return mOldInfo->GetDataSize(aDataSize);
}
NS_IMETHOD IsStreamBased(bool *_retval)
{
return mOldInfo->IsStreamBased(_retval);
}
NS_IMETHOD AsyncDoom(nsICacheEntryDoomCallback* listener);
NS_IMETHOD GetPersistent(bool *aPersistToDisk);
NS_IMETHOD GetIsForcedValid(bool *aIsForcedValid);
NS_IMETHOD ForceValidFor(uint32_t aSecondsToTheFuture);
NS_IMETHOD SetValid() { return NS_OK; }
NS_IMETHOD MetaDataReady() { return NS_OK; }
NS_IMETHOD Recreate(bool, nsICacheEntry**);
NS_IMETHOD GetDataSize(int64_t *size);
NS_IMETHOD OpenInputStream(int64_t offset, nsIInputStream * *_retval);
NS_IMETHOD OpenOutputStream(int64_t offset, nsIOutputStream * *_retval);
NS_IMETHOD MaybeMarkValid();
NS_IMETHOD HasWriteAccess(bool aWriteOnly, bool *aWriteAccess);
NS_IMETHOD VisitMetaData(nsICacheEntryMetaDataVisitor*);
NS_IMETHOD AsyncDoom(nsICacheEntryDoomCallback* listener) MOZ_OVERRIDE;
NS_IMETHOD GetPersistent(bool *aPersistToDisk) MOZ_OVERRIDE;
NS_IMETHOD GetIsForcedValid(bool *aIsForcedValid) MOZ_OVERRIDE;
NS_IMETHOD ForceValidFor(uint32_t aSecondsToTheFuture) MOZ_OVERRIDE;
NS_IMETHOD SetValid() MOZ_OVERRIDE { return NS_OK; }
NS_IMETHOD MetaDataReady() MOZ_OVERRIDE { return NS_OK; }
NS_IMETHOD Recreate(bool, nsICacheEntry**) MOZ_OVERRIDE;
NS_IMETHOD GetDataSize(int64_t *size) MOZ_OVERRIDE;
NS_IMETHOD OpenInputStream(int64_t offset, nsIInputStream * *_retval) MOZ_OVERRIDE;
NS_IMETHOD OpenOutputStream(int64_t offset, nsIOutputStream * *_retval) MOZ_OVERRIDE;
NS_IMETHOD MaybeMarkValid() MOZ_OVERRIDE;
NS_IMETHOD HasWriteAccess(bool aWriteOnly, bool *aWriteAccess) MOZ_OVERRIDE;
NS_IMETHOD VisitMetaData(nsICacheEntryMetaDataVisitor*) MOZ_OVERRIDE;
explicit _OldCacheEntryWrapper(nsICacheEntryDescriptor* desc);
explicit _OldCacheEntryWrapper(nsICacheEntryInfo* info);

30
netwerk/cookie/nsCookieService.cpp
View File

@ -357,7 +357,7 @@ protected:
virtual const char *GetOpType() = 0;
public:
NS_IMETHOD HandleError(mozIStorageError* aError)
NS_IMETHOD HandleError(mozIStorageError* aError) MOZ_OVERRIDE
{
int32_t result = -1;
aError->GetResult(&result);
@ -385,7 +385,7 @@ public:
class InsertCookieDBListener MOZ_FINAL : public DBListenerErrorHandler
{
private:
virtual const char *GetOpType() { return "INSERT"; }
virtual const char *GetOpType() MOZ_OVERRIDE { return "INSERT"; }
~InsertCookieDBListener() {}
@ -393,12 +393,12 @@ public:
NS_DECL_ISUPPORTS
explicit InsertCookieDBListener(DBState* dbState) : DBListenerErrorHandler(dbState) { }
NS_IMETHOD HandleResult(mozIStorageResultSet*)
NS_IMETHOD HandleResult(mozIStorageResultSet*) MOZ_OVERRIDE
{
NS_NOTREACHED("Unexpected call to InsertCookieDBListener::HandleResult");
return NS_OK;
}
NS_IMETHOD HandleCompletion(uint16_t aReason)
NS_IMETHOD HandleCompletion(uint16_t aReason) MOZ_OVERRIDE
{
// If we were rebuilding the db and we succeeded, make our corruptFlag say
// so.
@ -421,7 +421,7 @@ NS_IMPL_ISUPPORTS(InsertCookieDBListener, mozIStorageStatementCallback)
class UpdateCookieDBListener MOZ_FINAL : public DBListenerErrorHandler
{
private:
virtual const char *GetOpType() { return "UPDATE"; }
virtual const char *GetOpType() MOZ_OVERRIDE { return "UPDATE"; }
~UpdateCookieDBListener() {}
@ -429,12 +429,12 @@ public:
NS_DECL_ISUPPORTS
explicit UpdateCookieDBListener(DBState* dbState) : DBListenerErrorHandler(dbState) { }
NS_IMETHOD HandleResult(mozIStorageResultSet*)
NS_IMETHOD HandleResult(mozIStorageResultSet*) MOZ_OVERRIDE
{
NS_NOTREACHED("Unexpected call to UpdateCookieDBListener::HandleResult");
return NS_OK;
}
NS_IMETHOD HandleCompletion(uint16_t aReason)
NS_IMETHOD HandleCompletion(uint16_t aReason) MOZ_OVERRIDE
{
return NS_OK;
}
@ -449,7 +449,7 @@ NS_IMPL_ISUPPORTS(UpdateCookieDBListener, mozIStorageStatementCallback)
class RemoveCookieDBListener MOZ_FINAL : public DBListenerErrorHandler
{
private:
virtual const char *GetOpType() { return "REMOVE"; }
virtual const char *GetOpType() MOZ_OVERRIDE { return "REMOVE"; }
~RemoveCookieDBListener() {}
@ -457,12 +457,12 @@ public:
NS_DECL_ISUPPORTS
explicit RemoveCookieDBListener(DBState* dbState) : DBListenerErrorHandler(dbState) { }
NS_IMETHOD HandleResult(mozIStorageResultSet*)
NS_IMETHOD HandleResult(mozIStorageResultSet*) MOZ_OVERRIDE
{
NS_NOTREACHED("Unexpected call to RemoveCookieDBListener::HandleResult");
return NS_OK;
}
NS_IMETHOD HandleCompletion(uint16_t aReason)
NS_IMETHOD HandleCompletion(uint16_t aReason) MOZ_OVERRIDE
{
return NS_OK;
}
@ -477,7 +477,7 @@ NS_IMPL_ISUPPORTS(RemoveCookieDBListener, mozIStorageStatementCallback)
class ReadCookieDBListener MOZ_FINAL : public DBListenerErrorHandler
{
private:
virtual const char *GetOpType() { return "READ"; }
virtual const char *GetOpType() MOZ_OVERRIDE { return "READ"; }
bool mCanceled;
~ReadCookieDBListener() {}
@ -493,7 +493,7 @@ public:
void Cancel() { mCanceled = true; }
NS_IMETHOD HandleResult(mozIStorageResultSet *aResult)
NS_IMETHOD HandleResult(mozIStorageResultSet *aResult) MOZ_OVERRIDE
{
nsCOMPtr<mozIStorageRow> row;
@ -513,7 +513,7 @@ public:
return NS_OK;
}
NS_IMETHOD HandleCompletion(uint16_t aReason)
NS_IMETHOD HandleCompletion(uint16_t aReason) MOZ_OVERRIDE
{
// Process the completion of the read operation. If we have been canceled,
// we cannot assume that the cookieservice still has an open connection
@ -565,7 +565,7 @@ public:
nsRefPtr<DBState> mDBState;
NS_DECL_ISUPPORTS
NS_IMETHOD Complete(nsresult, nsISupports*)
NS_IMETHOD Complete(nsresult, nsISupports*) MOZ_OVERRIDE
{
gCookieService->HandleDBClosed(mDBState);
return NS_OK;
@ -585,7 +585,7 @@ public:
// nsIObserver implementation.
NS_IMETHODIMP
Observe(nsISupports *aSubject, const char *aTopic, const char16_t *data)
Observe(nsISupports *aSubject, const char *aTopic, const char16_t *data) MOZ_OVERRIDE
{
MOZ_ASSERT(!nsCRT::strcmp(aTopic, TOPIC_WEB_APP_CLEAR_DATA));

4
netwerk/dns/DNSRequestParent.h
View File

@ -30,8 +30,8 @@ public:
// needed if the request is to be canceled.
bool RecvCancelDNSRequest(const nsCString& hostName,
const uint32_t& flags,
const nsresult& reason);
bool Recv__delete__();
const nsresult& reason) MOZ_OVERRIDE;
bool Recv__delete__() MOZ_OVERRIDE;
protected:
virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE;

6
netwerk/dns/nsDNSService2.cpp
View File

@ -270,13 +270,13 @@ public:
, mFlags(flags)
, mAF(af) {}
void OnLookupComplete(nsHostResolver *, nsHostRecord *, nsresult);
void OnLookupComplete(nsHostResolver *, nsHostRecord *, nsresult) MOZ_OVERRIDE;
// Returns TRUE if the DNS listener arg is the same as the member listener
// Used in Cancellations to remove DNS requests associated with a
// particular hostname and nsIDNSListener
bool EqualsAsyncListener(nsIDNSListener *aListener);
bool EqualsAsyncListener(nsIDNSListener *aListener) MOZ_OVERRIDE;
size_t SizeOfIncludingThis(mozilla::MallocSizeOf) const;
size_t SizeOfIncludingThis(mozilla::MallocSizeOf) const MOZ_OVERRIDE;
nsRefPtr<nsHostResolver> mResolver;
nsCString mHost; // hostname we're resolving

11
netwerk/ipc/NeckoParent.h
View File

@ -80,21 +80,14 @@ public:
NestedFrameAuthPrompt(PNeckoParent* aParent, TabId aNestedFrameId);
NS_IMETHOD PromptAuth(nsIChannel*, uint32_t, nsIAuthInformation*, bool*)
NS_IMETHOD PromptAuth(nsIChannel*, uint32_t, nsIAuthInformation*, bool*) MOZ_OVERRIDE
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHOD AsyncPromptAuth(nsIChannel* aChannel, nsIAuthPromptCallback* callback,
nsISupports*, uint32_t,
nsIAuthInformation* aInfo, nsICancelable**);
NS_IMETHOD AsyncPromptAuth2(nsIChannel*, nsIDOMElement*,
nsIAuthPromptCallback*, nsISupports*,
uint32_t, nsIAuthInformation*, nsICancelable**)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
nsIAuthInformation* aInfo, nsICancelable**) MOZ_OVERRIDE;
protected:
PNeckoParent* mNeckoParent;

2
netwerk/protocol/app/AppProtocolHandler.cpp
View File

@ -34,7 +34,7 @@ public:
DummyChannel();
NS_IMETHODIMP Run();
NS_IMETHODIMP Run() MOZ_OVERRIDE;
private:
~DummyChannel() {}

2
netwerk/protocol/device/nsDeviceChannel.h
View File

@ -18,7 +18,7 @@ public:
nsresult Init(nsIURI* uri);
nsresult OpenContentStream(bool aAsync,
nsIInputStream **aStream,
nsIChannel **aChannel);
nsIChannel **aChannel) MOZ_OVERRIDE;
protected:
~nsDeviceChannel();

4
netwerk/protocol/file/nsFileChannel.cpp
View File

@ -175,9 +175,9 @@ public:
}
NS_IMETHODIMP ReadSegments(nsWriteSegmentFun fun, void *closure,
uint32_t count, uint32_t *result);
uint32_t count, uint32_t *result) MOZ_OVERRIDE;
NS_IMETHODIMP AsyncWait(nsIInputStreamCallback *callback, uint32_t flags,
uint32_t count, nsIEventTarget *target);
uint32_t count, nsIEventTarget *target) MOZ_OVERRIDE;
private:
virtual ~nsFileUploadContentStream() {}

2
netwerk/protocol/file/nsFileChannel.h
View File

@ -33,7 +33,7 @@ protected:
nsCString &contentType, bool async);
virtual nsresult OpenContentStream(bool async, nsIInputStream **result,
nsIChannel** channel);
nsIChannel** channel) MOZ_OVERRIDE;
private:
nsCOMPtr<nsIInputStream> mUploadStream;

10
netwerk/protocol/ftp/FTPChannelChild.h
View File

@ -49,20 +49,20 @@ public:
NS_DECL_NSICHILDCHANNEL
NS_DECL_NSIDIVERTABLECHANNEL
NS_IMETHOD Cancel(nsresult status);
NS_IMETHOD Suspend();
NS_IMETHOD Resume();
NS_IMETHOD Cancel(nsresult status) MOZ_OVERRIDE;
NS_IMETHOD Suspend() MOZ_OVERRIDE;
NS_IMETHOD Resume() MOZ_OVERRIDE;
explicit FTPChannelChild(nsIURI* uri);
void AddIPDLReference();
void ReleaseIPDLReference();
NS_IMETHOD AsyncOpen(nsIStreamListener* listener, nsISupports* aContext);
NS_IMETHOD AsyncOpen(nsIStreamListener* listener, nsISupports* aContext) MOZ_OVERRIDE;
// Note that we handle this ourselves, overriding the nsBaseChannel
// default behavior, in order to be e10s-friendly.
NS_IMETHOD IsPending(bool* result);
NS_IMETHOD IsPending(bool* result) MOZ_OVERRIDE;
nsresult OpenContentStream(bool async,
nsIInputStream** stream,

12
netwerk/protocol/ftp/nsFTPChannel.h
View File

@ -72,12 +72,12 @@ public:
mEntityID = entityID;
}
NS_IMETHODIMP GetLastModifiedTime(PRTime* lastModifiedTime) {
NS_IMETHODIMP GetLastModifiedTime(PRTime* lastModifiedTime) MOZ_OVERRIDE {
*lastModifiedTime = mLastModifiedTime;
return NS_OK;
}
NS_IMETHODIMP SetLastModifiedTime(PRTime lastModifiedTime) {
NS_IMETHODIMP SetLastModifiedTime(PRTime lastModifiedTime) MOZ_OVERRIDE {
mLastModifiedTime = lastModifiedTime;
return NS_OK;
}
@ -91,14 +91,14 @@ public:
void GetFTPEventSink(nsCOMPtr<nsIFTPEventSink> &aResult);
public:
NS_IMETHOD ForcePending(bool aForcePending);
NS_IMETHOD ForcePending(bool aForcePending) MOZ_OVERRIDE;
protected:
virtual ~nsFtpChannel() {}
virtual nsresult OpenContentStream(bool async, nsIInputStream **result,
nsIChannel** channel);
virtual bool GetStatusArg(nsresult status, nsString &statusArg);
virtual void OnCallbacksChanged();
nsIChannel** channel) MOZ_OVERRIDE;
virtual bool GetStatusArg(nsresult status, nsString &statusArg) MOZ_OVERRIDE;
virtual void OnCallbacksChanged() MOZ_OVERRIDE;
private:
nsCOMPtr<nsIProxyInfo> mProxyInfo;

12
netwerk/protocol/ftp/nsFtpConnectionThread.h
View File

@ -93,21 +93,21 @@ public:
NS_DECL_NSIPROTOCOLPROXYCALLBACK
// Override input stream methods:
NS_IMETHOD CloseWithStatus(nsresult status);
NS_IMETHOD Available(uint64_t *result);
NS_IMETHOD CloseWithStatus(nsresult status) MOZ_OVERRIDE;
NS_IMETHOD Available(uint64_t *result) MOZ_OVERRIDE;
NS_IMETHOD ReadSegments(nsWriteSegmentFun fun, void *closure,
uint32_t count, uint32_t *result);
uint32_t count, uint32_t *result) MOZ_OVERRIDE;
// nsFtpControlConnectionListener methods:
virtual void OnControlDataAvailable(const char *data, uint32_t dataLen);
virtual void OnControlError(nsresult status);
virtual void OnControlDataAvailable(const char *data, uint32_t dataLen) MOZ_OVERRIDE;
virtual void OnControlError(nsresult status) MOZ_OVERRIDE;
nsFtpState();
nsresult Init(nsFtpChannel *channel);
protected:
// Notification from nsBaseContentStream::AsyncWait
virtual void OnCallbackPending();
virtual void OnCallbackPending() MOZ_OVERRIDE;
private:
virtual ~nsFtpState();

8
netwerk/protocol/http/Http2Push.h
View File

@ -39,10 +39,10 @@ public:
bool GetHashKey(nsCString &key);
// override of Http2Stream
nsresult ReadSegments(nsAHttpSegmentReader *, uint32_t, uint32_t *);
nsresult WriteSegments(nsAHttpSegmentWriter *, uint32_t, uint32_t *);
nsresult ReadSegments(nsAHttpSegmentReader *, uint32_t, uint32_t *) MOZ_OVERRIDE;
nsresult WriteSegments(nsAHttpSegmentWriter *, uint32_t, uint32_t *) MOZ_OVERRIDE;
nsILoadGroupConnectionInfo *LoadGroupConnectionInfo() { return mLoadGroupCI; };
nsILoadGroupConnectionInfo *LoadGroupConnectionInfo() MOZ_OVERRIDE { return mLoadGroupCI; };
void ConnectPushedStream(Http2Stream *consumer);
bool TryOnPush();
@ -56,7 +56,7 @@ public:
nsresult GetBufferedData(char *buf, uint32_t count, uint32_t *countWritten);
// overload of Http2Stream
virtual bool HasSink() { return !!mConsumerStream; }
virtual bool HasSink() MOZ_OVERRIDE { return !!mConsumerStream; }
nsCString &GetRequestString() { return mRequestString; }

16
netwerk/protocol/http/Http2Session.h
View File

@ -44,18 +44,18 @@ public:
Http2Session(nsISocketTransport *, uint32_t version);
bool AddStream(nsAHttpTransaction *, int32_t,
bool, nsIInterfaceRequestor *);
bool CanReuse() { return !mShouldGoAway && !mClosed; }
bool RoomForMoreStreams();
bool, nsIInterfaceRequestor *) MOZ_OVERRIDE;
bool CanReuse() MOZ_OVERRIDE { return !mShouldGoAway && !mClosed; }
bool RoomForMoreStreams() MOZ_OVERRIDE;
// When the connection is active this is called up to once every 1 second
// return the interval (in seconds) that the connection next wants to
// have this invoked. It might happen sooner depending on the needs of
// other connections.
uint32_t ReadTimeoutTick(PRIntervalTime now);
uint32_t ReadTimeoutTick(PRIntervalTime now) MOZ_OVERRIDE;
// Idle time represents time since "goodput".. e.g. a data or header frame
PRIntervalTime IdleTime();
PRIntervalTime IdleTime() MOZ_OVERRIDE;
// Registering with a newID of 0 means pick the next available odd ID
uint32_t RegisterStreamID(Http2Stream *, uint32_t aNewID = 0);
@ -192,13 +192,13 @@ public:
const char *, uint32_t);
// an overload of nsAHttpConnection
void TransactionHasDataToWrite(nsAHttpTransaction *);
void TransactionHasDataToWrite(nsAHttpTransaction *) MOZ_OVERRIDE;
// a similar version for Http2Stream
void TransactionHasDataToWrite(Http2Stream *);
// an overload of nsAHttpSegementReader
virtual nsresult CommitToSegmentSize(uint32_t size, bool forceCommitment);
virtual nsresult CommitToSegmentSize(uint32_t size, bool forceCommitment) MOZ_OVERRIDE;
nsresult BufferOutput(const char *, uint32_t, uint32_t *);
void FlushOutputQueue();
uint32_t AmountOfOutputBuffered() { return mOutputQueueUsed - mOutputQueueSent; }
@ -213,7 +213,7 @@ public:
uint64_t Serial() { return mSerial; }
void PrintDiagnostics (nsCString &log);
void PrintDiagnostics (nsCString &log) MOZ_OVERRIDE;
// Streams need access to these
uint32_t SendingChunkSize() { return mSendingChunkSize; }

180
netwerk/protocol/http/HttpBaseChannel.h
View File

@ -91,120 +91,120 @@ public:
nsIURI *aProxyURI);
// nsIRequest
NS_IMETHOD GetName(nsACString& aName);
NS_IMETHOD IsPending(bool *aIsPending);
NS_IMETHOD GetStatus(nsresult *aStatus);
NS_IMETHOD GetLoadGroup(nsILoadGroup **aLoadGroup);
NS_IMETHOD SetLoadGroup(nsILoadGroup *aLoadGroup);
NS_IMETHOD GetLoadFlags(nsLoadFlags *aLoadFlags);
NS_IMETHOD SetLoadFlags(nsLoadFlags aLoadFlags);
NS_IMETHOD GetName(nsACString& aName) MOZ_OVERRIDE;
NS_IMETHOD IsPending(bool *aIsPending) MOZ_OVERRIDE;
NS_IMETHOD GetStatus(nsresult *aStatus) MOZ_OVERRIDE;
NS_IMETHOD GetLoadGroup(nsILoadGroup **aLoadGroup) MOZ_OVERRIDE;
NS_IMETHOD SetLoadGroup(nsILoadGroup *aLoadGroup) MOZ_OVERRIDE;
NS_IMETHOD GetLoadFlags(nsLoadFlags *aLoadFlags) MOZ_OVERRIDE;
NS_IMETHOD SetLoadFlags(nsLoadFlags aLoadFlags) MOZ_OVERRIDE;
// nsIChannel
NS_IMETHOD GetOriginalURI(nsIURI **aOriginalURI);
NS_IMETHOD SetOriginalURI(nsIURI *aOriginalURI);
NS_IMETHOD GetURI(nsIURI **aURI);
NS_IMETHOD GetOwner(nsISupports **aOwner);
NS_IMETHOD SetOwner(nsISupports *aOwner);
NS_IMETHOD GetLoadInfo(nsILoadInfo **aLoadInfo);
NS_IMETHOD SetLoadInfo(nsILoadInfo *aLoadInfo);
NS_IMETHOD GetNotificationCallbacks(nsIInterfaceRequestor **aCallbacks);
NS_IMETHOD SetNotificationCallbacks(nsIInterfaceRequestor *aCallbacks);
NS_IMETHOD GetContentType(nsACString& aContentType);
NS_IMETHOD SetContentType(const nsACString& aContentType);
NS_IMETHOD GetContentCharset(nsACString& aContentCharset);
NS_IMETHOD SetContentCharset(const nsACString& aContentCharset);
NS_IMETHOD GetContentDisposition(uint32_t *aContentDisposition);
NS_IMETHOD SetContentDisposition(uint32_t aContentDisposition);
NS_IMETHOD GetContentDispositionFilename(nsAString& aContentDispositionFilename);
NS_IMETHOD SetContentDispositionFilename(const nsAString& aContentDispositionFilename);
NS_IMETHOD GetContentDispositionHeader(nsACString& aContentDispositionHeader);
NS_IMETHOD GetContentLength(int64_t *aContentLength);
NS_IMETHOD SetContentLength(int64_t aContentLength);
NS_IMETHOD Open(nsIInputStream **aResult);
NS_IMETHOD GetOriginalURI(nsIURI **aOriginalURI) MOZ_OVERRIDE;
NS_IMETHOD SetOriginalURI(nsIURI *aOriginalURI) MOZ_OVERRIDE;
NS_IMETHOD GetURI(nsIURI **aURI) MOZ_OVERRIDE;
NS_IMETHOD GetOwner(nsISupports **aOwner) MOZ_OVERRIDE;
NS_IMETHOD SetOwner(nsISupports *aOwner) MOZ_OVERRIDE;
NS_IMETHOD GetLoadInfo(nsILoadInfo **aLoadInfo) MOZ_OVERRIDE;
NS_IMETHOD SetLoadInfo(nsILoadInfo *aLoadInfo) MOZ_OVERRIDE;
NS_IMETHOD GetNotificationCallbacks(nsIInterfaceRequestor **aCallbacks) MOZ_OVERRIDE;
NS_IMETHOD SetNotificationCallbacks(nsIInterfaceRequestor *aCallbacks) MOZ_OVERRIDE;
NS_IMETHOD GetContentType(nsACString& aContentType) MOZ_OVERRIDE;
NS_IMETHOD SetContentType(const nsACString& aContentType) MOZ_OVERRIDE;
NS_IMETHOD GetContentCharset(nsACString& aContentCharset) MOZ_OVERRIDE;
NS_IMETHOD SetContentCharset(const nsACString& aContentCharset) MOZ_OVERRIDE;
NS_IMETHOD GetContentDisposition(uint32_t *aContentDisposition) MOZ_OVERRIDE;
NS_IMETHOD SetContentDisposition(uint32_t aContentDisposition) MOZ_OVERRIDE;
NS_IMETHOD GetContentDispositionFilename(nsAString& aContentDispositionFilename) MOZ_OVERRIDE;
NS_IMETHOD SetContentDispositionFilename(const nsAString& aContentDispositionFilename) MOZ_OVERRIDE;
NS_IMETHOD GetContentDispositionHeader(nsACString& aContentDispositionHeader) MOZ_OVERRIDE;
NS_IMETHOD GetContentLength(int64_t *aContentLength) MOZ_OVERRIDE;
NS_IMETHOD SetContentLength(int64_t aContentLength) MOZ_OVERRIDE;
NS_IMETHOD Open(nsIInputStream **aResult) MOZ_OVERRIDE;
// nsIEncodedChannel
NS_IMETHOD GetApplyConversion(bool *value);
NS_IMETHOD SetApplyConversion(bool value);
NS_IMETHOD GetContentEncodings(nsIUTF8StringEnumerator** aEncodings);
NS_IMETHOD GetApplyConversion(bool *value) MOZ_OVERRIDE;
NS_IMETHOD SetApplyConversion(bool value) MOZ_OVERRIDE;
NS_IMETHOD GetContentEncodings(nsIUTF8StringEnumerator** aEncodings) MOZ_OVERRIDE;
NS_IMETHOD DoApplyContentConversions(nsIStreamListener *aNextListener,
nsIStreamListener **aNewNextListener,
nsISupports *aCtxt);
nsISupports *aCtxt) MOZ_OVERRIDE;
// HttpBaseChannel::nsIHttpChannel
NS_IMETHOD GetRequestMethod(nsACString& aMethod);
NS_IMETHOD SetRequestMethod(const nsACString& aMethod);
NS_IMETHOD GetReferrer(nsIURI **referrer);
NS_IMETHOD SetReferrer(nsIURI *referrer);
NS_IMETHOD GetReferrerPolicy(uint32_t *referrerPolicy);
NS_IMETHOD SetReferrerWithPolicy(nsIURI *referrer, uint32_t referrerPolicy);
NS_IMETHOD GetRequestHeader(const nsACString& aHeader, nsACString& aValue);
NS_IMETHOD GetRequestMethod(nsACString& aMethod) MOZ_OVERRIDE;
NS_IMETHOD SetRequestMethod(const nsACString& aMethod) MOZ_OVERRIDE;
NS_IMETHOD GetReferrer(nsIURI **referrer) MOZ_OVERRIDE;
NS_IMETHOD SetReferrer(nsIURI *referrer) MOZ_OVERRIDE;
NS_IMETHOD GetReferrerPolicy(uint32_t *referrerPolicy) MOZ_OVERRIDE;
NS_IMETHOD SetReferrerWithPolicy(nsIURI *referrer, uint32_t referrerPolicy) MOZ_OVERRIDE;
NS_IMETHOD GetRequestHeader(const nsACString& aHeader, nsACString& aValue) MOZ_OVERRIDE;
NS_IMETHOD SetRequestHeader(const nsACString& aHeader,
const nsACString& aValue, bool aMerge);
NS_IMETHOD VisitRequestHeaders(nsIHttpHeaderVisitor *visitor);
NS_IMETHOD GetResponseHeader(const nsACString &header, nsACString &value);
const nsACString& aValue, bool aMerge) MOZ_OVERRIDE;
NS_IMETHOD VisitRequestHeaders(nsIHttpHeaderVisitor *visitor) MOZ_OVERRIDE;
NS_IMETHOD GetResponseHeader(const nsACString &header, nsACString &value) MOZ_OVERRIDE;
NS_IMETHOD SetResponseHeader(const nsACString& header,
const nsACString& value, bool merge);
NS_IMETHOD VisitResponseHeaders(nsIHttpHeaderVisitor *visitor);
NS_IMETHOD GetAllowPipelining(bool *value);
NS_IMETHOD SetAllowPipelining(bool value);
NS_IMETHOD GetAllowSTS(bool *value);
NS_IMETHOD SetAllowSTS(bool value);
NS_IMETHOD GetRedirectionLimit(uint32_t *value);
NS_IMETHOD SetRedirectionLimit(uint32_t value);
NS_IMETHOD IsNoStoreResponse(bool *value);
NS_IMETHOD IsNoCacheResponse(bool *value);
NS_IMETHOD GetResponseStatus(uint32_t *aValue);
NS_IMETHOD GetResponseStatusText(nsACString& aValue);
NS_IMETHOD GetRequestSucceeded(bool *aValue);
NS_IMETHOD RedirectTo(nsIURI *newURI);
const nsACString& value, bool merge) MOZ_OVERRIDE;
NS_IMETHOD VisitResponseHeaders(nsIHttpHeaderVisitor *visitor) MOZ_OVERRIDE;
NS_IMETHOD GetAllowPipelining(bool *value) MOZ_OVERRIDE;
NS_IMETHOD SetAllowPipelining(bool value) MOZ_OVERRIDE;
NS_IMETHOD GetAllowSTS(bool *value) MOZ_OVERRIDE;
NS_IMETHOD SetAllowSTS(bool value) MOZ_OVERRIDE;
NS_IMETHOD GetRedirectionLimit(uint32_t *value) MOZ_OVERRIDE;
NS_IMETHOD SetRedirectionLimit(uint32_t value) MOZ_OVERRIDE;
NS_IMETHOD IsNoStoreResponse(bool *value) MOZ_OVERRIDE;
NS_IMETHOD IsNoCacheResponse(bool *value) MOZ_OVERRIDE;
NS_IMETHOD GetResponseStatus(uint32_t *aValue) MOZ_OVERRIDE;
NS_IMETHOD GetResponseStatusText(nsACString& aValue) MOZ_OVERRIDE;
NS_IMETHOD GetRequestSucceeded(bool *aValue) MOZ_OVERRIDE;
NS_IMETHOD RedirectTo(nsIURI *newURI) MOZ_OVERRIDE;
// nsIHttpChannelInternal
NS_IMETHOD GetDocumentURI(nsIURI **aDocumentURI);
NS_IMETHOD SetDocumentURI(nsIURI *aDocumentURI);
NS_IMETHOD GetRequestVersion(uint32_t *major, uint32_t *minor);
NS_IMETHOD GetResponseVersion(uint32_t *major, uint32_t *minor);
NS_IMETHOD SetCookie(const char *aCookieHeader);
NS_IMETHOD GetThirdPartyFlags(uint32_t *aForce);
NS_IMETHOD SetThirdPartyFlags(uint32_t aForce);
NS_IMETHOD GetForceAllowThirdPartyCookie(bool *aForce);
NS_IMETHOD SetForceAllowThirdPartyCookie(bool aForce);
NS_IMETHOD GetCanceled(bool *aCanceled);
NS_IMETHOD GetChannelIsForDownload(bool *aChannelIsForDownload);
NS_IMETHOD SetChannelIsForDownload(bool aChannelIsForDownload);
NS_IMETHOD SetCacheKeysRedirectChain(nsTArray<nsCString> *cacheKeys);
NS_IMETHOD GetLocalAddress(nsACString& addr);
NS_IMETHOD GetLocalPort(int32_t* port);
NS_IMETHOD GetRemoteAddress(nsACString& addr);
NS_IMETHOD GetRemotePort(int32_t* port);
NS_IMETHOD GetAllowSpdy(bool *aAllowSpdy);
NS_IMETHOD SetAllowSpdy(bool aAllowSpdy);
NS_IMETHOD GetApiRedirectToURI(nsIURI * *aApiRedirectToURI);
NS_IMETHOD AddSecurityMessage(const nsAString &aMessageTag, const nsAString &aMessageCategory);
NS_IMETHOD TakeAllSecurityMessages(nsCOMArray<nsISecurityConsoleMessage> &aMessages);
NS_IMETHOD GetResponseTimeoutEnabled(bool *aEnable);
NS_IMETHOD SetResponseTimeoutEnabled(bool aEnable);
NS_IMETHOD AddRedirect(nsIPrincipal *aRedirect);
NS_IMETHOD ForcePending(bool aForcePending);
NS_IMETHOD GetLastModifiedTime(PRTime* lastModifiedTime);
NS_IMETHOD ForceNoIntercept();
NS_IMETHOD GetTopWindowURI(nsIURI **aTopWindowURI);
NS_IMETHOD GetDocumentURI(nsIURI **aDocumentURI) MOZ_OVERRIDE;
NS_IMETHOD SetDocumentURI(nsIURI *aDocumentURI) MOZ_OVERRIDE;
NS_IMETHOD GetRequestVersion(uint32_t *major, uint32_t *minor) MOZ_OVERRIDE;
NS_IMETHOD GetResponseVersion(uint32_t *major, uint32_t *minor) MOZ_OVERRIDE;
NS_IMETHOD SetCookie(const char *aCookieHeader) MOZ_OVERRIDE;
NS_IMETHOD GetThirdPartyFlags(uint32_t *aForce) MOZ_OVERRIDE;
NS_IMETHOD SetThirdPartyFlags(uint32_t aForce) MOZ_OVERRIDE;
NS_IMETHOD GetForceAllowThirdPartyCookie(bool *aForce) MOZ_OVERRIDE;
NS_IMETHOD SetForceAllowThirdPartyCookie(bool aForce) MOZ_OVERRIDE;
NS_IMETHOD GetCanceled(bool *aCanceled) MOZ_OVERRIDE;
NS_IMETHOD GetChannelIsForDownload(bool *aChannelIsForDownload) MOZ_OVERRIDE;
NS_IMETHOD SetChannelIsForDownload(bool aChannelIsForDownload) MOZ_OVERRIDE;
NS_IMETHOD SetCacheKeysRedirectChain(nsTArray<nsCString> *cacheKeys) MOZ_OVERRIDE;
NS_IMETHOD GetLocalAddress(nsACString& addr) MOZ_OVERRIDE;
NS_IMETHOD GetLocalPort(int32_t* port) MOZ_OVERRIDE;
NS_IMETHOD GetRemoteAddress(nsACString& addr) MOZ_OVERRIDE;
NS_IMETHOD GetRemotePort(int32_t* port) MOZ_OVERRIDE;
NS_IMETHOD GetAllowSpdy(bool *aAllowSpdy) MOZ_OVERRIDE;
NS_IMETHOD SetAllowSpdy(bool aAllowSpdy) MOZ_OVERRIDE;
NS_IMETHOD GetApiRedirectToURI(nsIURI * *aApiRedirectToURI) MOZ_OVERRIDE;
nsresult AddSecurityMessage(const nsAString &aMessageTag, const nsAString &aMessageCategory);
NS_IMETHOD TakeAllSecurityMessages(nsCOMArray<nsISecurityConsoleMessage> &aMessages) MOZ_OVERRIDE;
NS_IMETHOD GetResponseTimeoutEnabled(bool *aEnable) MOZ_OVERRIDE;
NS_IMETHOD SetResponseTimeoutEnabled(bool aEnable) MOZ_OVERRIDE;
NS_IMETHOD AddRedirect(nsIPrincipal *aRedirect) MOZ_OVERRIDE;
NS_IMETHOD ForcePending(bool aForcePending) MOZ_OVERRIDE;
NS_IMETHOD GetLastModifiedTime(PRTime* lastModifiedTime) MOZ_OVERRIDE;
NS_IMETHOD ForceNoIntercept() MOZ_OVERRIDE;
NS_IMETHOD GetTopWindowURI(nsIURI **aTopWindowURI) MOZ_OVERRIDE;
inline void CleanRedirectCacheChainIfNecessary()
{
mRedirectedCachekeys = nullptr;
}
NS_IMETHOD HTTPUpgrade(const nsACString & aProtocolName,
nsIHttpUpgradeListener *aListener);
nsIHttpUpgradeListener *aListener) MOZ_OVERRIDE;
// nsISupportsPriority
NS_IMETHOD GetPriority(int32_t *value);
NS_IMETHOD AdjustPriority(int32_t delta);
NS_IMETHOD GetPriority(int32_t *value) MOZ_OVERRIDE;
NS_IMETHOD AdjustPriority(int32_t delta) MOZ_OVERRIDE;
// nsIClassOfService
NS_IMETHOD GetClassFlags(uint32_t *outFlags) { *outFlags = mClassOfService; return NS_OK; }
NS_IMETHOD GetClassFlags(uint32_t *outFlags) MOZ_OVERRIDE { *outFlags = mClassOfService; return NS_OK; }
// nsIResumableChannel
NS_IMETHOD GetEntityID(nsACString& aEntityID);
NS_IMETHOD GetEntityID(nsACString& aEntityID) MOZ_OVERRIDE;
class nsContentEncodings : public nsIUTF8StringEnumerator
{

38
netwerk/protocol/http/HttpChannelChild.h
View File

@ -68,31 +68,31 @@ public:
// Methods HttpBaseChannel didn't implement for us or that we override.
//
// nsIRequest
NS_IMETHOD Cancel(nsresult status);
NS_IMETHOD Suspend();
NS_IMETHOD Resume();
NS_IMETHOD Cancel(nsresult status) MOZ_OVERRIDE;
NS_IMETHOD Suspend() MOZ_OVERRIDE;
NS_IMETHOD Resume() MOZ_OVERRIDE;
// nsIChannel
NS_IMETHOD GetSecurityInfo(nsISupports **aSecurityInfo);
NS_IMETHOD AsyncOpen(nsIStreamListener *listener, nsISupports *aContext);
NS_IMETHOD GetSecurityInfo(nsISupports **aSecurityInfo) MOZ_OVERRIDE;
NS_IMETHOD AsyncOpen(nsIStreamListener *listener, nsISupports *aContext) MOZ_OVERRIDE;
// HttpBaseChannel::nsIHttpChannel
NS_IMETHOD SetRequestHeader(const nsACString& aHeader,
const nsACString& aValue,
bool aMerge);
NS_IMETHOD RedirectTo(nsIURI *newURI);
bool aMerge) MOZ_OVERRIDE;
NS_IMETHOD RedirectTo(nsIURI *newURI) MOZ_OVERRIDE;
// nsIHttpChannelInternal
NS_IMETHOD SetupFallbackChannel(const char *aFallbackKey);
NS_IMETHOD GetLocalAddress(nsACString& addr);
NS_IMETHOD GetLocalPort(int32_t* port);
NS_IMETHOD GetRemoteAddress(nsACString& addr);
NS_IMETHOD GetRemotePort(int32_t* port);
NS_IMETHOD SetupFallbackChannel(const char *aFallbackKey) MOZ_OVERRIDE;
NS_IMETHOD GetLocalAddress(nsACString& addr) MOZ_OVERRIDE;
NS_IMETHOD GetLocalPort(int32_t* port) MOZ_OVERRIDE;
NS_IMETHOD GetRemoteAddress(nsACString& addr) MOZ_OVERRIDE;
NS_IMETHOD GetRemotePort(int32_t* port) MOZ_OVERRIDE;
// nsISupportsPriority
NS_IMETHOD SetPriority(int32_t value);
NS_IMETHOD SetPriority(int32_t value) MOZ_OVERRIDE;
// nsIClassOfService
NS_IMETHOD SetClassFlags(uint32_t inFlags);
NS_IMETHOD AddClassFlags(uint32_t inFlags);
NS_IMETHOD ClearClassFlags(uint32_t inFlags);
NS_IMETHOD SetClassFlags(uint32_t inFlags) MOZ_OVERRIDE;
NS_IMETHOD AddClassFlags(uint32_t inFlags) MOZ_OVERRIDE;
NS_IMETHOD ClearClassFlags(uint32_t inFlags) MOZ_OVERRIDE;
// nsIResumableChannel
NS_IMETHOD ResumeAt(uint64_t startPos, const nsACString& entityID);
NS_IMETHOD ResumeAt(uint64_t startPos, const nsACString& entityID) MOZ_OVERRIDE;
// IPDL holds a reference while the PHttpChannel protocol is live (starting at
// AsyncOpen, and ending at either OnStopRequest or any IPDL error, either of
@ -125,7 +125,7 @@ protected:
const nsCString& data,
const uint64_t& offset,
const uint32_t& count) MOZ_OVERRIDE;
bool RecvOnStopRequest(const nsresult& statusCode, const ResourceTimingStruct& timing);
bool RecvOnStopRequest(const nsresult& statusCode, const ResourceTimingStruct& timing) MOZ_OVERRIDE;
bool RecvOnProgress(const uint64_t& progress, const uint64_t& progressMax) MOZ_OVERRIDE;
bool RecvOnStatus(const nsresult& status) MOZ_OVERRIDE;
bool RecvFailedAsyncOpen(const nsresult& status) MOZ_OVERRIDE;
@ -141,7 +141,7 @@ protected:
bool RecvDeleteSelf() MOZ_OVERRIDE;
bool GetAssociatedContentSecurity(nsIAssociatedContentSecurity** res = nullptr);
virtual void DoNotifyListenerCleanup();
virtual void DoNotifyListenerCleanup() MOZ_OVERRIDE;
private:
nsresult ContinueAsyncOpen();

16
netwerk/protocol/http/SpdySession31.h
View File

@ -42,18 +42,18 @@ public:
explicit SpdySession31(nsISocketTransport *);
bool AddStream(nsAHttpTransaction *, int32_t,
bool, nsIInterfaceRequestor *);
bool CanReuse() { return !mShouldGoAway && !mClosed; }
bool RoomForMoreStreams();
bool, nsIInterfaceRequestor *) MOZ_OVERRIDE;
bool CanReuse() MOZ_OVERRIDE { return !mShouldGoAway && !mClosed; }
bool RoomForMoreStreams() MOZ_OVERRIDE;
// When the connection is active this is called up to once every 1 second
// return the interval (in seconds) that the connection next wants to
// have this invoked. It might happen sooner depending on the needs of
// other connections.
uint32_t ReadTimeoutTick(PRIntervalTime now);
uint32_t ReadTimeoutTick(PRIntervalTime now) MOZ_OVERRIDE;
// Idle time represents time since "goodput".. e.g. a data or header frame
PRIntervalTime IdleTime();
PRIntervalTime IdleTime() MOZ_OVERRIDE;
// Registering with a newID of 0 means pick the next available odd ID
uint32_t RegisterStreamID(SpdyStream31 *, uint32_t aNewID = 0);
@ -165,13 +165,13 @@ public:
const char *, uint32_t);
// an overload of nsAHttpConnection
void TransactionHasDataToWrite(nsAHttpTransaction *);
void TransactionHasDataToWrite(nsAHttpTransaction *) MOZ_OVERRIDE;
// a similar version for SpdyStream31
void TransactionHasDataToWrite(SpdyStream31 *);
// an overload of nsAHttpSegementReader
virtual nsresult CommitToSegmentSize(uint32_t size, bool forceCommitment);
virtual nsresult CommitToSegmentSize(uint32_t size, bool forceCommitment) MOZ_OVERRIDE;
nsresult BufferOutput(const char *, uint32_t, uint32_t *);
void FlushOutputQueue();
uint32_t AmountOfOutputBuffered() { return mOutputQueueUsed - mOutputQueueSent; }
@ -183,7 +183,7 @@ public:
uint64_t Serial() { return mSerial; }
void PrintDiagnostics (nsCString &log);
void PrintDiagnostics (nsCString &log) MOZ_OVERRIDE;
// Streams need access to these
uint32_t SendingChunkSize() { return mSendingChunkSize; }

2
netwerk/protocol/http/SpdyZlibReporter.h
View File

@ -50,7 +50,7 @@ private:
NS_IMETHODIMP
CollectReports(nsIHandleReportCallback* aHandleReport, nsISupports* aData,
bool aAnonymize);
bool aAnonymize) MOZ_OVERRIDE;
};
} // namespace mozilla

18
netwerk/protocol/http/TunnelUtils.cpp
View File

@ -771,23 +771,23 @@ class SocketInWrapper : public nsIAsyncInputStream
, mTLSFilter(aFilter)
{ }
NS_IMETHODIMP Close()
NS_IMETHODIMP Close() MOZ_OVERRIDE
{
mTLSFilter = nullptr;
return mStream->Close();
}
NS_IMETHODIMP Available(uint64_t *_retval)
NS_IMETHODIMP Available(uint64_t *_retval) MOZ_OVERRIDE
{
return mStream->Available(_retval);
}
NS_IMETHODIMP IsNonBlocking(bool *_retval)
NS_IMETHODIMP IsNonBlocking(bool *_retval) MOZ_OVERRIDE
{
return mStream->IsNonBlocking(_retval);
}
NS_IMETHODIMP ReadSegments(nsWriteSegmentFun aWriter, void *aClosure, uint32_t aCount, uint32_t *_retval)
NS_IMETHODIMP ReadSegments(nsWriteSegmentFun aWriter, void *aClosure, uint32_t aCount, uint32_t *_retval) MOZ_OVERRIDE
{
return mStream->ReadSegments(aWriter, aClosure, aCount, _retval);
}
@ -838,28 +838,28 @@ class SocketOutWrapper : public nsIAsyncOutputStream
, mTLSFilter(aFilter)
{ }
NS_IMETHODIMP Close()
NS_IMETHODIMP Close() MOZ_OVERRIDE
{
mTLSFilter = nullptr;
return mStream->Close();
}
NS_IMETHODIMP Flush()
NS_IMETHODIMP Flush() MOZ_OVERRIDE
{
return mStream->Flush();
}
NS_IMETHODIMP IsNonBlocking(bool *_retval)
NS_IMETHODIMP IsNonBlocking(bool *_retval) MOZ_OVERRIDE
{
return mStream->IsNonBlocking(_retval);
}
NS_IMETHODIMP WriteSegments(nsReadSegmentFun aReader, void *aClosure, uint32_t aCount, uint32_t *_retval)
NS_IMETHODIMP WriteSegments(nsReadSegmentFun aReader, void *aClosure, uint32_t aCount, uint32_t *_retval) MOZ_OVERRIDE
{
return mStream->WriteSegments(aReader, aClosure, aCount, _retval);
}
NS_IMETHODIMP WriteFrom(nsIInputStream *aFromStream, uint32_t aCount, uint32_t *_retval)
NS_IMETHODIMP WriteFrom(nsIInputStream *aFromStream, uint32_t aCount, uint32_t *_retval) MOZ_OVERRIDE
{
return mStream->WriteFrom(aFromStream, aCount, _retval);
}

8
netwerk/protocol/http/TunnelUtils.h
View File

@ -93,7 +93,7 @@ public:
virtual void OnTunnelNudged(TLSFilterTransaction *) = 0;
};
#define NS_DECL_NUDGETUNNELCALLBACK void OnTunnelNudged(TLSFilterTransaction *);
#define NS_DECL_NUDGETUNNELCALLBACK void OnTunnelNudged(TLSFilterTransaction *) MOZ_OVERRIDE;
class TLSFilterTransaction MOZ_FINAL
: public nsAHttpTransaction
@ -115,8 +115,8 @@ public:
nsAHttpSegmentWriter *writer);
const nsAHttpTransaction *Transaction() const { return mTransaction.get(); }
nsresult CommitToSegmentSize(uint32_t size, bool forceCommitment);
nsresult GetTransactionSecurityInfo(nsISupports **);
nsresult CommitToSegmentSize(uint32_t size, bool forceCommitment) MOZ_OVERRIDE;
nsresult GetTransactionSecurityInfo(nsISupports **) MOZ_OVERRIDE;
nsresult NudgeTunnel(NudgeTunnelCallback *callback);
nsresult SetProxiedTransaction(nsAHttpTransaction *aTrans);
void newIODriver(nsIAsyncInputStream *aSocketIn,
@ -184,7 +184,7 @@ public:
nsAHttpConnection *session);
~SpdyConnectTransaction();
SpdyConnectTransaction *QuerySpdyConnectTransaction() { return this; }
SpdyConnectTransaction *QuerySpdyConnectTransaction() MOZ_OVERRIDE { return this; }
// A transaction is forced into plaintext when it is intended to be used as a CONNECT
// tunnel but the setup fails. The plaintext only carries the CONNECT error.

42
netwerk/protocol/http/nsAHttpConnection.h
View File

@ -148,23 +148,24 @@ public:
NS_DEFINE_STATIC_IID_ACCESSOR(nsAHttpConnection, NS_AHTTPCONNECTION_IID)
#define NS_DECL_NSAHTTPCONNECTION(fwdObject) \
nsresult OnHeadersAvailable(nsAHttpTransaction *, nsHttpRequestHead *, nsHttpResponseHead *, bool *reset); \
void CloseTransaction(nsAHttpTransaction *, nsresult); \
nsresult OnHeadersAvailable(nsAHttpTransaction *, nsHttpRequestHead *, nsHttpResponseHead *, bool *reset) MOZ_OVERRIDE; \
void CloseTransaction(nsAHttpTransaction *, nsresult) MOZ_OVERRIDE; \
nsresult TakeTransport(nsISocketTransport **, \
nsIAsyncInputStream **, \
nsIAsyncOutputStream **); \
bool IsPersistent(); \
bool IsReused(); \
void DontReuse(); \
nsresult PushBack(const char *, uint32_t); \
nsHttpConnection *TakeHttpConnection(); \
uint32_t CancelPipeline(nsresult originalReason); \
nsAHttpTransaction::Classifier Classification(); \
nsIAsyncOutputStream **) MOZ_OVERRIDE; \
bool IsPersistent() MOZ_OVERRIDE; \
bool IsReused() MOZ_OVERRIDE; \
void DontReuse() MOZ_OVERRIDE; \
nsresult PushBack(const char *, uint32_t) MOZ_OVERRIDE; \
nsHttpConnection *TakeHttpConnection() MOZ_OVERRIDE; \
uint32_t CancelPipeline(nsresult originalReason) MOZ_OVERRIDE; \
nsAHttpTransaction::Classifier Classification() MOZ_OVERRIDE; \
/* \
Thes methods below have automatic definitions that just forward the \
function to a lower level connection object \
*/ \
void GetConnectionInfo(nsHttpConnectionInfo **result) \
MOZ_OVERRIDE \
{ \
if (!(fwdObject)) { \
*result = nullptr; \
@ -173,6 +174,7 @@ NS_DEFINE_STATIC_IID_ACCESSOR(nsAHttpConnection, NS_AHTTPCONNECTION_IID)
return (fwdObject)->GetConnectionInfo(result); \
} \
void GetSecurityInfo(nsISupports **result) \
MOZ_OVERRIDE \
{ \
if (!(fwdObject)) { \
*result = nullptr; \
@ -180,62 +182,66 @@ NS_DEFINE_STATIC_IID_ACCESSOR(nsAHttpConnection, NS_AHTTPCONNECTION_IID)
} \
return (fwdObject)->GetSecurityInfo(result); \
} \
nsresult ResumeSend() \
nsresult ResumeSend() MOZ_OVERRIDE \
{ \
if (!(fwdObject)) \
return NS_ERROR_FAILURE; \
return (fwdObject)->ResumeSend(); \
} \
nsresult ResumeRecv() \
nsresult ResumeRecv() MOZ_OVERRIDE \
{ \
if (!(fwdObject)) \
return NS_ERROR_FAILURE; \
return (fwdObject)->ResumeRecv(); \
} \
nsresult ForceSend() \
nsresult ForceSend() MOZ_OVERRIDE \
{ \
if (!(fwdObject)) \
return NS_ERROR_FAILURE; \
return (fwdObject)->ForceSend(); \
} \
nsresult ForceRecv() \
nsresult ForceRecv() MOZ_OVERRIDE \
{ \
if (!(fwdObject)) \
return NS_ERROR_FAILURE; \
return (fwdObject)->ForceRecv(); \
} \
nsISocketTransport *Transport() \
MOZ_OVERRIDE \
{ \
if (!(fwdObject)) \
return nullptr; \
return (fwdObject)->Transport(); \
} \
uint32_t Version() \
uint32_t Version() MOZ_OVERRIDE \
{ \
return (fwdObject) ? \
(fwdObject)->Version() : \
NS_HTTP_VERSION_UNKNOWN; \
} \
bool IsProxyConnectInProgress() \
bool IsProxyConnectInProgress() MOZ_OVERRIDE \
{ \
return (fwdObject)->IsProxyConnectInProgress(); \
} \
bool LastTransactionExpectedNoContent() \
bool LastTransactionExpectedNoContent() MOZ_OVERRIDE \
{ \
return (fwdObject)->LastTransactionExpectedNoContent(); \
} \
void SetLastTransactionExpectedNoContent(bool val) \
MOZ_OVERRIDE \
{ \
return (fwdObject)->SetLastTransactionExpectedNoContent(val); \
} \
void Classify(nsAHttpTransaction::Classifier newclass) \
MOZ_OVERRIDE \
{ \
if (fwdObject) \
return (fwdObject)->Classify(newclass); \
} \
int64_t BytesWritten() \
int64_t BytesWritten() MOZ_OVERRIDE \
{ return fwdObject ? (fwdObject)->BytesWritten() : 0; } \
void SetSecurityCallbacks(nsIInterfaceRequestor* aCallbacks) \
MOZ_OVERRIDE \
{ \
if (fwdObject) \
(fwdObject)->SetSecurityCallbacks(aCallbacks); \

46
netwerk/protocol/http/nsAHttpTransaction.h
View File

@ -194,28 +194,28 @@ public:
NS_DEFINE_STATIC_IID_ACCESSOR(nsAHttpTransaction, NS_AHTTPTRANSACTION_IID)
#define NS_DECL_NSAHTTPTRANSACTION \
void SetConnection(nsAHttpConnection *); \
nsAHttpConnection *Connection(); \
void GetSecurityCallbacks(nsIInterfaceRequestor **); \
void SetConnection(nsAHttpConnection *) MOZ_OVERRIDE; \
nsAHttpConnection *Connection() MOZ_OVERRIDE; \
void GetSecurityCallbacks(nsIInterfaceRequestor **) MOZ_OVERRIDE; \
void OnTransportStatus(nsITransport* transport, \
nsresult status, uint64_t progress); \
bool IsDone(); \
nsresult Status(); \
uint32_t Caps(); \
void SetDNSWasRefreshed(); \
uint64_t Available(); \
virtual nsresult ReadSegments(nsAHttpSegmentReader *, uint32_t, uint32_t *); \
virtual nsresult WriteSegments(nsAHttpSegmentWriter *, uint32_t, uint32_t *); \
virtual void Close(nsresult reason); \
nsHttpConnectionInfo *ConnectionInfo(); \
void SetProxyConnectFailed(); \
virtual nsHttpRequestHead *RequestHead(); \
uint32_t Http1xTransactionCount(); \
nsresult TakeSubTransactions(nsTArray<nsRefPtr<nsAHttpTransaction> > &outTransactions); \
nsresult AddTransaction(nsAHttpTransaction *); \
uint32_t PipelineDepth(); \
nsresult SetPipelinePosition(int32_t); \
int32_t PipelinePosition();
nsresult status, uint64_t progress) MOZ_OVERRIDE; \
bool IsDone() MOZ_OVERRIDE; \
nsresult Status() MOZ_OVERRIDE; \
uint32_t Caps() MOZ_OVERRIDE; \
void SetDNSWasRefreshed() MOZ_OVERRIDE; \
uint64_t Available() MOZ_OVERRIDE; \
virtual nsresult ReadSegments(nsAHttpSegmentReader *, uint32_t, uint32_t *) MOZ_OVERRIDE; \
virtual nsresult WriteSegments(nsAHttpSegmentWriter *, uint32_t, uint32_t *) MOZ_OVERRIDE; \
virtual void Close(nsresult reason) MOZ_OVERRIDE; \
nsHttpConnectionInfo *ConnectionInfo() MOZ_OVERRIDE; \
void SetProxyConnectFailed() MOZ_OVERRIDE; \
virtual nsHttpRequestHead *RequestHead() MOZ_OVERRIDE; \
uint32_t Http1xTransactionCount() MOZ_OVERRIDE; \
nsresult TakeSubTransactions(nsTArray<nsRefPtr<nsAHttpTransaction> > &outTransactions) MOZ_OVERRIDE; \
nsresult AddTransaction(nsAHttpTransaction *) MOZ_OVERRIDE; \
uint32_t PipelineDepth() MOZ_OVERRIDE; \
nsresult SetPipelinePosition(int32_t) MOZ_OVERRIDE; \
int32_t PipelinePosition() MOZ_OVERRIDE;
//-----------------------------------------------------------------------------
// nsAHttpSegmentReader
@ -246,7 +246,7 @@ public:
};
#define NS_DECL_NSAHTTPSEGMENTREADER \
nsresult OnReadSegment(const char *, uint32_t, uint32_t *);
nsresult OnReadSegment(const char *, uint32_t, uint32_t *) MOZ_OVERRIDE;
//-----------------------------------------------------------------------------
// nsAHttpSegmentWriter
@ -262,7 +262,7 @@ public:
};
#define NS_DECL_NSAHTTPSEGMENTWRITER \
nsresult OnWriteSegment(char *, uint32_t, uint32_t *);
nsresult OnWriteSegment(char *, uint32_t, uint32_t *) MOZ_OVERRIDE;
}} // namespace mozilla::net

4
netwerk/protocol/http/nsHttpChannel.cpp
View File

@ -5912,11 +5912,11 @@ class nsHttpChannelCacheKey MOZ_FINAL : public nsISupportsPRUint32,
// Both interfaces declares toString method with the same signature.
// Thus we have to delegate only to nsISupportsPRUint32 implementation.
NS_IMETHOD GetData(nsACString & aData)
NS_IMETHOD GetData(nsACString & aData) MOZ_OVERRIDE
{
return mSupportsCString->GetData(aData);
}
NS_IMETHOD SetData(const nsACString & aData)
NS_IMETHOD SetData(const nsACString & aData) MOZ_OVERRIDE
{
return mSupportsCString->SetData(aData);
}

74
netwerk/protocol/http/nsHttpChannel.h
View File

@ -82,63 +82,63 @@ public:
// nsIHttpAuthenticableChannel. We can't use
// NS_DECL_NSIHTTPAUTHENTICABLECHANNEL because it duplicates cancel() and
// others.
NS_IMETHOD GetIsSSL(bool *aIsSSL);
NS_IMETHOD GetProxyMethodIsConnect(bool *aProxyMethodIsConnect);
NS_IMETHOD GetServerResponseHeader(nsACString & aServerResponseHeader);
NS_IMETHOD GetProxyChallenges(nsACString & aChallenges);
NS_IMETHOD GetWWWChallenges(nsACString & aChallenges);
NS_IMETHOD SetProxyCredentials(const nsACString & aCredentials);
NS_IMETHOD SetWWWCredentials(const nsACString & aCredentials);
NS_IMETHOD OnAuthAvailable();
NS_IMETHOD OnAuthCancelled(bool userCancel);
NS_IMETHOD GetIsSSL(bool *aIsSSL) MOZ_OVERRIDE;
NS_IMETHOD GetProxyMethodIsConnect(bool *aProxyMethodIsConnect) MOZ_OVERRIDE;
NS_IMETHOD GetServerResponseHeader(nsACString & aServerResponseHeader) MOZ_OVERRIDE;
NS_IMETHOD GetProxyChallenges(nsACString & aChallenges) MOZ_OVERRIDE;
NS_IMETHOD GetWWWChallenges(nsACString & aChallenges) MOZ_OVERRIDE;
NS_IMETHOD SetProxyCredentials(const nsACString & aCredentials) MOZ_OVERRIDE;
NS_IMETHOD SetWWWCredentials(const nsACString & aCredentials) MOZ_OVERRIDE;
NS_IMETHOD OnAuthAvailable() MOZ_OVERRIDE;
NS_IMETHOD OnAuthCancelled(bool userCancel) MOZ_OVERRIDE;
// Functions we implement from nsIHttpAuthenticableChannel but are
// declared in HttpBaseChannel must be implemented in this class. We
// just call the HttpBaseChannel:: impls.
NS_IMETHOD GetLoadFlags(nsLoadFlags *aLoadFlags);
NS_IMETHOD GetURI(nsIURI **aURI);
NS_IMETHOD GetNotificationCallbacks(nsIInterfaceRequestor **aCallbacks);
NS_IMETHOD GetLoadGroup(nsILoadGroup **aLoadGroup);
NS_IMETHOD GetRequestMethod(nsACString& aMethod);
NS_IMETHOD GetLoadFlags(nsLoadFlags *aLoadFlags) MOZ_OVERRIDE;
NS_IMETHOD GetURI(nsIURI **aURI) MOZ_OVERRIDE;
NS_IMETHOD GetNotificationCallbacks(nsIInterfaceRequestor **aCallbacks) MOZ_OVERRIDE;
NS_IMETHOD GetLoadGroup(nsILoadGroup **aLoadGroup) MOZ_OVERRIDE;
NS_IMETHOD GetRequestMethod(nsACString& aMethod) MOZ_OVERRIDE;
nsHttpChannel();
virtual nsresult Init(nsIURI *aURI, uint32_t aCaps, nsProxyInfo *aProxyInfo,
uint32_t aProxyResolveFlags,
nsIURI *aProxyURI);
nsIURI *aProxyURI) MOZ_OVERRIDE;
nsresult OnPush(const nsACString &uri, Http2PushedStream *pushedStream);
// Methods HttpBaseChannel didn't implement for us or that we override.
//
// nsIRequest
NS_IMETHOD Cancel(nsresult status);
NS_IMETHOD Suspend();
NS_IMETHOD Resume();
NS_IMETHOD Cancel(nsresult status) MOZ_OVERRIDE;
NS_IMETHOD Suspend() MOZ_OVERRIDE;
NS_IMETHOD Resume() MOZ_OVERRIDE;
// nsIChannel
NS_IMETHOD GetSecurityInfo(nsISupports **aSecurityInfo);
NS_IMETHOD AsyncOpen(nsIStreamListener *listener, nsISupports *aContext);
NS_IMETHOD GetSecurityInfo(nsISupports **aSecurityInfo) MOZ_OVERRIDE;
NS_IMETHOD AsyncOpen(nsIStreamListener *listener, nsISupports *aContext) MOZ_OVERRIDE;
// nsIHttpChannelInternal
NS_IMETHOD SetupFallbackChannel(const char *aFallbackKey);
NS_IMETHOD SetupFallbackChannel(const char *aFallbackKey) MOZ_OVERRIDE;
// nsISupportsPriority
NS_IMETHOD SetPriority(int32_t value);
NS_IMETHOD SetPriority(int32_t value) MOZ_OVERRIDE;
// nsIClassOfService
NS_IMETHOD SetClassFlags(uint32_t inFlags);
NS_IMETHOD AddClassFlags(uint32_t inFlags);
NS_IMETHOD ClearClassFlags(uint32_t inFlags);
NS_IMETHOD SetClassFlags(uint32_t inFlags) MOZ_OVERRIDE;
NS_IMETHOD AddClassFlags(uint32_t inFlags) MOZ_OVERRIDE;
NS_IMETHOD ClearClassFlags(uint32_t inFlags) MOZ_OVERRIDE;
// nsIResumableChannel
NS_IMETHOD ResumeAt(uint64_t startPos, const nsACString& entityID);
NS_IMETHOD ResumeAt(uint64_t startPos, const nsACString& entityID) MOZ_OVERRIDE;
NS_IMETHOD SetNotificationCallbacks(nsIInterfaceRequestor *aCallbacks);
NS_IMETHOD SetLoadGroup(nsILoadGroup *aLoadGroup);
NS_IMETHOD SetNotificationCallbacks(nsIInterfaceRequestor *aCallbacks) MOZ_OVERRIDE;
NS_IMETHOD SetLoadGroup(nsILoadGroup *aLoadGroup) MOZ_OVERRIDE;
// nsITimedChannel
NS_IMETHOD GetDomainLookupStart(mozilla::TimeStamp *aDomainLookupStart);
NS_IMETHOD GetDomainLookupEnd(mozilla::TimeStamp *aDomainLookupEnd);
NS_IMETHOD GetConnectStart(mozilla::TimeStamp *aConnectStart);
NS_IMETHOD GetConnectEnd(mozilla::TimeStamp *aConnectEnd);
NS_IMETHOD GetRequestStart(mozilla::TimeStamp *aRequestStart);
NS_IMETHOD GetResponseStart(mozilla::TimeStamp *aResponseStart);
NS_IMETHOD GetResponseEnd(mozilla::TimeStamp *aResponseEnd);
NS_IMETHOD GetDomainLookupStart(mozilla::TimeStamp *aDomainLookupStart) MOZ_OVERRIDE;
NS_IMETHOD GetDomainLookupEnd(mozilla::TimeStamp *aDomainLookupEnd) MOZ_OVERRIDE;
NS_IMETHOD GetConnectStart(mozilla::TimeStamp *aConnectStart) MOZ_OVERRIDE;
NS_IMETHOD GetConnectEnd(mozilla::TimeStamp *aConnectEnd) MOZ_OVERRIDE;
NS_IMETHOD GetRequestStart(mozilla::TimeStamp *aRequestStart) MOZ_OVERRIDE;
NS_IMETHOD GetResponseStart(mozilla::TimeStamp *aResponseStart) MOZ_OVERRIDE;
NS_IMETHOD GetResponseEnd(mozilla::TimeStamp *aResponseEnd) MOZ_OVERRIDE;
public: /* internal necko use only */
@ -261,7 +261,7 @@ private:
void HandleAsyncFallback();
nsresult ContinueHandleAsyncFallback(nsresult);
nsresult PromptTempRedirect();
virtual nsresult SetupReplacementChannel(nsIURI *, nsIChannel *, bool preserveMethod);
virtual nsresult SetupReplacementChannel(nsIURI *, nsIChannel *, bool preserveMethod) MOZ_OVERRIDE;
// proxy specific methods
nsresult ProxyFailover();
@ -473,7 +473,7 @@ private:
nsCString mUsername;
protected:
virtual void DoNotifyListenerCleanup();
virtual void DoNotifyListenerCleanup() MOZ_OVERRIDE;
private: // cache telemetry
bool mDidReval;

2
netwerk/protocol/http/nsHttpPipeline.h
View File

@ -57,7 +57,7 @@ private:
}
// overload of nsAHttpTransaction::QueryPipeline()
nsHttpPipeline *QueryPipeline();
nsHttpPipeline *QueryPipeline() MOZ_OVERRIDE;
nsRefPtr<nsAHttpConnection> mConnection;
nsTArray<nsAHttpTransaction*> mRequestQ; // array of transactions

4
netwerk/protocol/http/nsHttpTransaction.h
View File

@ -132,7 +132,7 @@ public:
bool UsesPipelining() const { return mCaps & NS_HTTP_ALLOW_PIPELINING; }
// overload of nsAHttpTransaction::LoadGroupConnectionInfo()
nsILoadGroupConnectionInfo *LoadGroupConnectionInfo() { return mLoadGroupCI.get(); }
nsILoadGroupConnectionInfo *LoadGroupConnectionInfo() MOZ_OVERRIDE { return mLoadGroupCI.get(); }
void SetLoadGroupConnectionInfo(nsILoadGroupConnectionInfo *aLoadGroupCI) { mLoadGroupCI = aLoadGroupCI; }
void DispatchedAsBlocking();
void RemoveDispatchedAsBlocking();
@ -372,7 +372,7 @@ public:
// token bucket submission the transaction just posts an event that causes
// the pending transaction queue to be rerun (and TryToRunPacedRequest() to
// be run again.
void OnTokenBucketAdmitted(); // ATokenBucketEvent
void OnTokenBucketAdmitted() MOZ_OVERRIDE; // ATokenBucketEvent
// CancelPacing() can be used to tell the token bucket to remove this
// transaction from the list of pending transactions. This is used when a

36
netwerk/protocol/websocket/BaseWebSocketChannel.h
View File

@ -31,27 +31,27 @@ class BaseWebSocketChannel : public nsIWebSocketChannel,
NS_DECL_NSIPROTOCOLHANDLER
NS_DECL_NSITHREADRETARGETABLEREQUEST
NS_IMETHOD QueryInterface(const nsIID & uuid, void **result) = 0;
NS_IMETHOD_(MozExternalRefCountType ) AddRef(void) = 0;
NS_IMETHOD_(MozExternalRefCountType ) Release(void) = 0;
NS_IMETHOD QueryInterface(const nsIID & uuid, void **result) MOZ_OVERRIDE = 0;
NS_IMETHOD_(MozExternalRefCountType ) AddRef(void) MOZ_OVERRIDE = 0;
NS_IMETHOD_(MozExternalRefCountType ) Release(void) MOZ_OVERRIDE = 0;
// Partial implementation of nsIWebSocketChannel
//
NS_IMETHOD GetOriginalURI(nsIURI **aOriginalURI);
NS_IMETHOD GetURI(nsIURI **aURI);
NS_IMETHOD GetNotificationCallbacks(nsIInterfaceRequestor **aNotificationCallbacks);
NS_IMETHOD SetNotificationCallbacks(nsIInterfaceRequestor *aNotificationCallbacks);
NS_IMETHOD GetLoadGroup(nsILoadGroup **aLoadGroup);
NS_IMETHOD SetLoadGroup(nsILoadGroup *aLoadGroup);
NS_IMETHOD SetLoadInfo(nsILoadInfo *aLoadInfo);
NS_IMETHOD GetLoadInfo(nsILoadInfo **aLoadInfo);
NS_IMETHOD GetExtensions(nsACString &aExtensions);
NS_IMETHOD GetProtocol(nsACString &aProtocol);
NS_IMETHOD SetProtocol(const nsACString &aProtocol);
NS_IMETHOD GetPingInterval(uint32_t *aSeconds);
NS_IMETHOD SetPingInterval(uint32_t aSeconds);
NS_IMETHOD GetPingTimeout(uint32_t *aSeconds);
NS_IMETHOD SetPingTimeout(uint32_t aSeconds);
NS_IMETHOD GetOriginalURI(nsIURI **aOriginalURI) MOZ_OVERRIDE;
NS_IMETHOD GetURI(nsIURI **aURI) MOZ_OVERRIDE;
NS_IMETHOD GetNotificationCallbacks(nsIInterfaceRequestor **aNotificationCallbacks) MOZ_OVERRIDE;
NS_IMETHOD SetNotificationCallbacks(nsIInterfaceRequestor *aNotificationCallbacks) MOZ_OVERRIDE;
NS_IMETHOD GetLoadGroup(nsILoadGroup **aLoadGroup) MOZ_OVERRIDE;
NS_IMETHOD SetLoadGroup(nsILoadGroup *aLoadGroup) MOZ_OVERRIDE;
NS_IMETHOD SetLoadInfo(nsILoadInfo *aLoadInfo) MOZ_OVERRIDE;
NS_IMETHOD GetLoadInfo(nsILoadInfo **aLoadInfo) MOZ_OVERRIDE;
NS_IMETHOD GetExtensions(nsACString &aExtensions) MOZ_OVERRIDE;
NS_IMETHOD GetProtocol(nsACString &aProtocol) MOZ_OVERRIDE;
NS_IMETHOD SetProtocol(const nsACString &aProtocol) MOZ_OVERRIDE;
NS_IMETHOD GetPingInterval(uint32_t *aSeconds) MOZ_OVERRIDE;
NS_IMETHOD SetPingInterval(uint32_t aSeconds) MOZ_OVERRIDE;
NS_IMETHOD GetPingTimeout(uint32_t *aSeconds) MOZ_OVERRIDE;
NS_IMETHOD SetPingTimeout(uint32_t aSeconds) MOZ_OVERRIDE;
// Off main thread URI access.
virtual void GetEffectiveURL(nsAString& aEffectiveURL) const = 0;

10
netwerk/protocol/websocket/WebSocketChannel.cpp
View File

@ -562,7 +562,7 @@ public:
mData(aData),
mLen(aLen) {}
NS_IMETHOD Run()
NS_IMETHOD Run() MOZ_OVERRIDE
{
MOZ_ASSERT(mChannel->IsOnTargetThread());
@ -596,7 +596,7 @@ public:
: mChannel(aChannel),
mReason(aReason) {}
NS_IMETHOD Run()
NS_IMETHOD Run() MOZ_OVERRIDE
{
MOZ_ASSERT(mChannel->IsOnTargetThread());
@ -634,7 +634,7 @@ public:
mCode(aCode),
mReason(aReason) {}
NS_IMETHOD Run()
NS_IMETHOD Run() MOZ_OVERRIDE
{
MOZ_ASSERT(mChannel->IsOnTargetThread());
@ -697,7 +697,7 @@ public:
mSocketIn(aSocketIn),
mSocketOut(aSocketOut) {}
NS_IMETHOD Run()
NS_IMETHOD Run() MOZ_OVERRIDE
{
LOG(("WebSocketChannel::CallOnTransportAvailable %p\n", this));
return mChannel->OnTransportAvailable(mTransport, mSocketIn, mSocketOut);
@ -1061,7 +1061,7 @@ public:
OutboundEnqueuer(WebSocketChannel *aChannel, OutboundMessage *aMsg)
: mChannel(aChannel), mMessage(aMsg) {}
NS_IMETHOD Run()
NS_IMETHOD Run() MOZ_OVERRIDE
{
mChannel->EnqueueOutgoingMessage(mChannel->mOutgoingMessages, mMessage);
return NS_OK;

12
netwerk/protocol/websocket/WebSocketChannel.h
View File

@ -88,12 +88,12 @@ public:
NS_IMETHOD AsyncOpen(nsIURI *aURI,
const nsACString &aOrigin,
nsIWebSocketListener *aListener,
nsISupports *aContext);
NS_IMETHOD Close(uint16_t aCode, const nsACString & aReason);
NS_IMETHOD SendMsg(const nsACString &aMsg);
NS_IMETHOD SendBinaryMsg(const nsACString &aMsg);
NS_IMETHOD SendBinaryStream(nsIInputStream *aStream, uint32_t length);
NS_IMETHOD GetSecurityInfo(nsISupports **aSecurityInfo);
nsISupports *aContext) MOZ_OVERRIDE;
NS_IMETHOD Close(uint16_t aCode, const nsACString & aReason) MOZ_OVERRIDE;
NS_IMETHOD SendMsg(const nsACString &aMsg) MOZ_OVERRIDE;
NS_IMETHOD SendBinaryMsg(const nsACString &aMsg) MOZ_OVERRIDE;
NS_IMETHOD SendBinaryStream(nsIInputStream *aStream, uint32_t length) MOZ_OVERRIDE;
NS_IMETHOD GetSecurityInfo(nsISupports **aSecurityInfo) MOZ_OVERRIDE;
WebSocketChannel();
static void Shutdown();

12
netwerk/protocol/websocket/WebSocketChannelChild.h
View File

@ -29,13 +29,13 @@ class WebSocketChannelChild : public BaseWebSocketChannel,
// nsIWebSocketChannel methods BaseWebSocketChannel didn't implement for us
//
NS_IMETHOD AsyncOpen(nsIURI *aURI, const nsACString &aOrigin,
nsIWebSocketListener *aListener, nsISupports *aContext);
NS_IMETHOD Close(uint16_t code, const nsACString & reason);
NS_IMETHOD SendMsg(const nsACString &aMsg);
NS_IMETHOD SendBinaryMsg(const nsACString &aMsg);
NS_IMETHOD SendBinaryStream(nsIInputStream *aStream, uint32_t aLength);
nsIWebSocketListener *aListener, nsISupports *aContext) MOZ_OVERRIDE;
NS_IMETHOD Close(uint16_t code, const nsACString & reason) MOZ_OVERRIDE;
NS_IMETHOD SendMsg(const nsACString &aMsg) MOZ_OVERRIDE;
NS_IMETHOD SendBinaryMsg(const nsACString &aMsg) MOZ_OVERRIDE;
NS_IMETHOD SendBinaryStream(nsIInputStream *aStream, uint32_t aLength) MOZ_OVERRIDE;
nsresult SendBinaryStream(OptionalInputStreamParams *aStream, uint32_t aLength);
NS_IMETHOD GetSecurityInfo(nsISupports **aSecurityInfo);
NS_IMETHOD GetSecurityInfo(nsISupports **aSecurityInfo) MOZ_OVERRIDE;
void AddIPDLReference();
void ReleaseIPDLReference();