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

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

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

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

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

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

@ -82,8 +82,8 @@ public:
protected: protected:
virtual ~nsBufferedInputStream() {} virtual ~nsBufferedInputStream() {}
NS_IMETHOD Fill(); NS_IMETHOD Fill() MOZ_OVERRIDE;
NS_IMETHOD Flush() { return NS_OK; } // no-op for input streams NS_IMETHOD Flush() MOZ_OVERRIDE { return NS_OK; } // no-op for input streams
}; };
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
@ -112,7 +112,7 @@ public:
protected: protected:
virtual ~nsBufferedOutputStream() { nsBufferedOutputStream::Close(); } 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 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_NSILINEINPUTSTREAM
NS_DECL_NSIIPCSERIALIZABLEINPUTSTREAM NS_DECL_NSIIPCSERIALIZABLEINPUTSTREAM
NS_IMETHOD Close(); NS_IMETHOD Close() MOZ_OVERRIDE;
NS_IMETHOD Tell(int64_t *aResult); NS_IMETHOD Tell(int64_t *aResult) MOZ_OVERRIDE;
NS_IMETHOD Available(uint64_t* _retval); NS_IMETHOD Available(uint64_t* _retval) MOZ_OVERRIDE;
NS_IMETHOD Read(char* aBuf, uint32_t aCount, uint32_t* _retval); NS_IMETHOD Read(char* aBuf, uint32_t aCount, uint32_t* _retval) MOZ_OVERRIDE;
NS_IMETHOD ReadSegments(nsWriteSegmentFun aWriter, void *aClosure, 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, return nsFileStreamBase::ReadSegments(aWriter, aClosure, aCount,
_retval); _retval);
} }
NS_IMETHOD IsNonBlocking(bool* _retval) NS_IMETHOD IsNonBlocking(bool* _retval) MOZ_OVERRIDE
{ {
return nsFileStreamBase::IsNonBlocking(_retval); return nsFileStreamBase::IsNonBlocking(_retval);
} }
// Overrided from nsFileStreamBase // Overrided from nsFileStreamBase
NS_IMETHOD Seek(int32_t aWhence, int64_t aOffset); NS_IMETHOD Seek(int32_t aWhence, int64_t aOffset) MOZ_OVERRIDE;
nsFileInputStream() nsFileInputStream()
: mLineBuffer(nullptr), mIOFlags(0), mPerm(0), mCachedPosition(0) : mLineBuffer(nullptr), mIOFlags(0), mPerm(0), mCachedPosition(0)
@ -187,10 +187,10 @@ public:
: mStart(0), mLength(0), mPosition(0) : mStart(0), mLength(0), mPosition(0)
{ } { }
NS_IMETHOD Tell(int64_t *aResult); NS_IMETHOD Tell(int64_t *aResult) MOZ_OVERRIDE;
NS_IMETHOD Available(uint64_t *aResult); NS_IMETHOD Available(uint64_t *aResult) MOZ_OVERRIDE;
NS_IMETHOD Read(char* aBuf, uint32_t aCount, uint32_t* aResult); NS_IMETHOD Read(char* aBuf, uint32_t aCount, uint32_t* aResult) MOZ_OVERRIDE;
NS_IMETHOD Seek(int32_t aWhence, int64_t aOffset); NS_IMETHOD Seek(int32_t aWhence, int64_t aOffset) MOZ_OVERRIDE;
static nsresult static nsresult
Create(nsISupports *aOuter, REFNSIID aIID, void **aResult); Create(nsISupports *aOuter, REFNSIID aIID, void **aResult);
@ -249,9 +249,9 @@ public:
virtual nsresult DoOpen() MOZ_OVERRIDE; virtual nsresult DoOpen() MOZ_OVERRIDE;
NS_IMETHODIMP Close(); NS_IMETHODIMP Close() MOZ_OVERRIDE;
NS_IMETHODIMP Write(const char *buf, uint32_t count, uint32_t *result); 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); NS_IMETHODIMP Init(nsIFile* file, int32_t ioFlags, int32_t perm, int32_t behaviorFlags) MOZ_OVERRIDE;
protected: protected:
virtual ~nsAtomicFileOutputStream() virtual ~nsAtomicFileOutputStream()
@ -279,7 +279,7 @@ class nsSafeFileOutputStream : public nsAtomicFileOutputStream
{ {
public: public:
NS_IMETHOD Finish(); NS_IMETHOD Finish() MOZ_OVERRIDE;
}; };
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
@ -296,21 +296,21 @@ public:
// Can't use NS_FORWARD_NSIOUTPUTSTREAM due to overlapping methods // Can't use NS_FORWARD_NSIOUTPUTSTREAM due to overlapping methods
// Close() and IsNonBlocking() // Close() and IsNonBlocking()
NS_IMETHOD Flush() NS_IMETHOD Flush() MOZ_OVERRIDE
{ {
return nsFileStreamBase::Flush(); 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); return nsFileStreamBase::Write(aBuf, aCount, _retval);
} }
NS_IMETHOD WriteFrom(nsIInputStream* aFromStream, uint32_t aCount, NS_IMETHOD WriteFrom(nsIInputStream* aFromStream, uint32_t aCount,
uint32_t* _retval) uint32_t* _retval) MOZ_OVERRIDE
{ {
return nsFileStreamBase::WriteFrom(aFromStream, aCount, _retval); return nsFileStreamBase::WriteFrom(aFromStream, aCount, _retval);
} }
NS_IMETHOD WriteSegments(nsReadSegmentFun aReader, void* aClosure, 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, return nsFileStreamBase::WriteSegments(aReader, aClosure, aCount,
_retval); _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; *aMode = mMode;
return NS_OK; return NS_OK;
} }
NS_IMETHODIMP GetAppId(uint32_t *aAppId) NS_IMETHODIMP GetAppId(uint32_t *aAppId) MOZ_OVERRIDE
{ {
*aAppId = mAppId; *aAppId = mAppId;
return NS_OK; return NS_OK;

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

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

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

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

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

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

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

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

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

@ -52,8 +52,8 @@ public:
// - nsJSURI: mBaseURI // - nsJSURI: mBaseURI
// - nsSimpleNestedURI: mInnerURI // - nsSimpleNestedURI: mInnerURI
// - nsBlobURI: mPrincipal // - nsBlobURI: mPrincipal
virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const; virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE;
virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const; virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE;
protected: protected:
// enum used in a few places to specify how .ref attribute should be handled // 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); nsresult InitWithFilename(const char *filename);
// nsASocketHandler methods: // nsASocketHandler methods:
void OnSocketReady(PRFileDesc *, int16_t outFlags); void OnSocketReady(PRFileDesc *, int16_t outFlags) MOZ_OVERRIDE;
void OnSocketDetached(PRFileDesc *); void OnSocketDetached(PRFileDesc *) MOZ_OVERRIDE;
void IsLocal(bool *aIsLocal); void IsLocal(bool *aIsLocal) MOZ_OVERRIDE;
void OnKeepaliveEnabledPrefChange(bool aEnabled) MOZ_OVERRIDE MOZ_FINAL; void OnKeepaliveEnabledPrefChange(bool aEnabled) MOZ_OVERRIDE MOZ_FINAL;
// called when a socket event is handled // called when a socket event is handled
void OnSocketEvent(uint32_t type, nsresult status, nsISupports *param); void OnSocketEvent(uint32_t type, nsresult status, nsISupports *param);
uint64_t ByteCountReceived() { return mInput.ByteCount(); } uint64_t ByteCountReceived() MOZ_OVERRIDE { return mInput.ByteCount(); }
uint64_t ByteCountSent() { return mOutput.ByteCount(); } uint64_t ByteCountSent() MOZ_OVERRIDE { return mOutput.ByteCount(); }
protected: protected:
virtual ~nsSocketTransport(); virtual ~nsSocketTransport();

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

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

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

@ -22,12 +22,12 @@ public:
NS_DECL_NSIUDPSOCKET NS_DECL_NSIUDPSOCKET
// nsASocketHandler methods: // nsASocketHandler methods:
virtual void OnSocketReady(PRFileDesc* fd, int16_t outFlags); virtual void OnSocketReady(PRFileDesc* fd, int16_t outFlags) MOZ_OVERRIDE;
virtual void OnSocketDetached(PRFileDesc* fd); virtual void OnSocketDetached(PRFileDesc* fd) MOZ_OVERRIDE;
virtual void IsLocal(bool* aIsLocal); virtual void IsLocal(bool* aIsLocal) MOZ_OVERRIDE;
uint64_t ByteCountSent() { return mByteWriteCount; } uint64_t ByteCountSent() MOZ_OVERRIDE { return mByteWriteCount; }
uint64_t ByteCountReceived() { return mByteReadCount; } uint64_t ByteCountReceived() MOZ_OVERRIDE { return mByteReadCount; }
void AddOutputBytes(uint64_t aBytes); 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, NS_IMETHOD ParseFilePath(const char *, int32_t,
uint32_t *, int32_t *, uint32_t *, int32_t *,
uint32_t *, int32_t *, uint32_t *, int32_t *,
uint32_t *, int32_t *); uint32_t *, int32_t *) MOZ_OVERRIDE;
#endif #endif
NS_IMETHOD ParseAuthority(const char *auth, int32_t authLen, NS_IMETHOD ParseAuthority(const char *auth, int32_t authLen,
uint32_t *usernamePos, int32_t *usernameLen, uint32_t *usernamePos, int32_t *usernameLen,
uint32_t *passwordPos, int32_t *passwordLen, uint32_t *passwordPos, int32_t *passwordLen,
uint32_t *hostnamePos, int32_t *hostnameLen, uint32_t *hostnamePos, int32_t *hostnameLen,
int32_t *port); int32_t *port) MOZ_OVERRIDE;
void ParseAfterScheme(const char *spec, int32_t specLen, void ParseAfterScheme(const char *spec, int32_t specLen,
uint32_t *authPos, int32_t *authLen, 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 *usernamePos, int32_t *usernameLen,
uint32_t *passwordPos, int32_t *passwordLen, uint32_t *passwordPos, int32_t *passwordLen,
uint32_t *hostnamePos, int32_t *hostnameLen, uint32_t *hostnamePos, int32_t *hostnameLen,
int32_t *port); int32_t *port) MOZ_OVERRIDE;
NS_IMETHOD ParseUserInfo(const char *userinfo, int32_t userinfoLen, NS_IMETHOD ParseUserInfo(const char *userinfo, int32_t userinfoLen,
uint32_t *usernamePos, int32_t *usernameLen, 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, NS_IMETHOD ParseServerInfo(const char *serverinfo, int32_t serverinfoLen,
uint32_t *hostnamePos, int32_t *hostnameLen, uint32_t *hostnamePos, int32_t *hostnameLen,
int32_t *port); int32_t *port) MOZ_OVERRIDE;
void ParseAfterScheme(const char *spec, int32_t specLen, void ParseAfterScheme(const char *spec, int32_t specLen,
uint32_t *authPos, int32_t *authLen, 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. // nsIObserver implementation.
NS_IMETHODIMP 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)); 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) , mStreamEnded(false)
{ {
} }
NS_IMETHOD Read(char* buf, uint32_t count, uint32_t * result); NS_IMETHOD Read(char* buf, uint32_t count, uint32_t * result) MOZ_OVERRIDE;
NS_IMETHOD Close(); NS_IMETHOD Close() MOZ_OVERRIDE;
private: private:
virtual ~nsDecompressInputStreamWrapper() virtual ~nsDecompressInputStreamWrapper()
{ {
@ -209,8 +209,8 @@ private:
, mUncompressedCount(0) , mUncompressedCount(0)
{ {
} }
NS_IMETHOD Write(const char* buf, uint32_t count, uint32_t * result); NS_IMETHOD Write(const char* buf, uint32_t count, uint32_t * result) MOZ_OVERRIDE;
NS_IMETHOD Close(); NS_IMETHOD Close() MOZ_OVERRIDE;
private: private:
virtual ~nsCompressOutputStreamWrapper() virtual ~nsCompressOutputStreamWrapper()
{ {

2
netwerk/cache/nsCacheService.cpp vendored
View File

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

26
netwerk/cache/nsDiskCacheDeviceSQL.h vendored
View File

@ -74,34 +74,34 @@ public:
* nsCacheDevice methods * nsCacheDevice methods
*/ */
virtual nsresult Init(); virtual nsresult Init() MOZ_OVERRIDE;
nsresult InitWithSqlite(mozIStorageService * ss); nsresult InitWithSqlite(mozIStorageService * ss);
virtual nsresult Shutdown(); virtual nsresult Shutdown() MOZ_OVERRIDE;
virtual const char * GetDeviceID(void); virtual const char * GetDeviceID(void) MOZ_OVERRIDE;
virtual nsCacheEntry * FindEntry(nsCString * key, bool *collision); virtual nsCacheEntry * FindEntry(nsCString * key, bool *collision) MOZ_OVERRIDE;
virtual nsresult DeactivateEntry(nsCacheEntry * entry); virtual nsresult DeactivateEntry(nsCacheEntry * entry) MOZ_OVERRIDE;
virtual nsresult BindEntry(nsCacheEntry * entry); virtual nsresult BindEntry(nsCacheEntry * entry) MOZ_OVERRIDE;
virtual void DoomEntry( nsCacheEntry * entry ); virtual void DoomEntry( nsCacheEntry * entry ) MOZ_OVERRIDE;
virtual nsresult OpenInputStreamForEntry(nsCacheEntry * entry, virtual nsresult OpenInputStreamForEntry(nsCacheEntry * entry,
nsCacheAccessMode mode, nsCacheAccessMode mode,
uint32_t offset, uint32_t offset,
nsIInputStream ** result); nsIInputStream ** result) MOZ_OVERRIDE;
virtual nsresult OpenOutputStreamForEntry(nsCacheEntry * entry, virtual nsresult OpenOutputStreamForEntry(nsCacheEntry * entry,
nsCacheAccessMode mode, nsCacheAccessMode mode,
uint32_t offset, uint32_t offset,
nsIOutputStream ** result); nsIOutputStream ** result) MOZ_OVERRIDE;
virtual nsresult GetFileForEntry(nsCacheEntry * entry, 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 */ /* Entry ownership */
nsresult GetOwnerDomains(const char * clientID, nsresult GetOwnerDomains(const char * clientID,

4
netwerk/cache2/CacheEntry.h
View File

@ -123,8 +123,8 @@ private:
virtual ~CacheEntry(); virtual ~CacheEntry();
// CacheFileListener // CacheFileListener
NS_IMETHOD OnFileReady(nsresult aResult, bool aIsNew); NS_IMETHOD OnFileReady(nsresult aResult, bool aIsNew) MOZ_OVERRIDE;
NS_IMETHOD OnFileDoomed(nsresult aResult); NS_IMETHOD OnFileDoomed(nsresult aResult) MOZ_OVERRIDE;
// Keep the service alive during life-time of an entry // Keep the service alive during life-time of an entry
nsRefPtr<CacheStorageService> mService; 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!"); MOZ_CRASH("DoomFileHelper::OnFileOpened should not be called!");
return NS_ERROR_UNEXPECTED; return NS_ERROR_UNEXPECTED;
} }
NS_IMETHOD OnDataWritten(CacheFileHandle *aHandle, const char *aBuf, NS_IMETHOD OnDataWritten(CacheFileHandle *aHandle, const char *aBuf,
nsresult aResult) nsresult aResult) MOZ_OVERRIDE
{ {
MOZ_CRASH("DoomFileHelper::OnDataWritten should not be called!"); MOZ_CRASH("DoomFileHelper::OnDataWritten should not be called!");
return NS_ERROR_UNEXPECTED; 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!"); MOZ_CRASH("DoomFileHelper::OnDataRead should not be called!");
return NS_ERROR_UNEXPECTED; return NS_ERROR_UNEXPECTED;
} }
NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult) NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE
{ {
if (mListener) if (mListener)
mListener->OnFileDoomed(aResult); mListener->OnFileDoomed(aResult);
return NS_OK; 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!"); MOZ_CRASH("DoomFileHelper::OnEOFSet should not be called!");
return NS_ERROR_UNEXPECTED; 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!"); MOZ_CRASH("DoomFileHelper::OnFileRenamed should not be called!");
return NS_ERROR_UNEXPECTED; return NS_ERROR_UNEXPECTED;

24
netwerk/cache2/CacheFile.h
View File

@ -59,22 +59,22 @@ public:
bool aPriority, bool aPriority,
CacheFileListener *aCallback); CacheFileListener *aCallback);
NS_IMETHOD OnChunkRead(nsresult aResult, CacheFileChunk *aChunk); NS_IMETHOD OnChunkRead(nsresult aResult, CacheFileChunk *aChunk) MOZ_OVERRIDE;
NS_IMETHOD OnChunkWritten(nsresult aResult, CacheFileChunk *aChunk); NS_IMETHOD OnChunkWritten(nsresult aResult, CacheFileChunk *aChunk) MOZ_OVERRIDE;
NS_IMETHOD OnChunkAvailable(nsresult aResult, uint32_t aChunkIdx, NS_IMETHOD OnChunkAvailable(nsresult aResult, uint32_t aChunkIdx,
CacheFileChunk *aChunk); CacheFileChunk *aChunk) MOZ_OVERRIDE;
NS_IMETHOD OnChunkUpdated(CacheFileChunk *aChunk); 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, NS_IMETHOD OnDataWritten(CacheFileHandle *aHandle, const char *aBuf,
nsresult aResult); nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf, nsresult aResult); NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult); NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult); NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult); NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnMetadataRead(nsresult aResult); NS_IMETHOD OnMetadataRead(nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnMetadataWritten(nsresult aResult); NS_IMETHOD OnMetadataWritten(nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OpenInputStream(nsIInputStream **_retval); NS_IMETHOD OpenInputStream(nsIInputStream **_retval);
NS_IMETHOD OpenOutputStream(CacheOutputCloseListener *aCloseListener, nsIOutputStream **_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, void UpdateDataSize(uint32_t aOffset, uint32_t aLen,
bool aEOF); 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, NS_IMETHOD OnDataWritten(CacheFileHandle *aHandle, const char *aBuf,
nsresult aResult); nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf, nsresult aResult); NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult); NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult); NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult); NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
bool IsReady() const; bool IsReady() const;
bool IsDirty() const; bool IsDirty() const;

8
netwerk/cache2/CacheFileInputStream.h
View File

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

12
netwerk/cache2/CacheFileMetadata.h
View File

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

8
netwerk/cache2/CacheFileOutputStream.h
View File

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

12
netwerk/cache2/CacheIndex.cpp
View File

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

12
netwerk/cache2/CacheIndex.h
View File

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

12
netwerk/cache2/CacheStorageService.cpp
View File

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

131
netwerk/cache2/OldWrappers.h
View File

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

30
netwerk/cookie/nsCookieService.cpp
View File

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

6
netwerk/dns/nsDNSService2.cpp
View File

@ -270,13 +270,13 @@ public:
, mFlags(flags) , mFlags(flags)
, mAF(af) {} , 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 // Returns TRUE if the DNS listener arg is the same as the member listener
// Used in Cancellations to remove DNS requests associated with a // Used in Cancellations to remove DNS requests associated with a
// particular hostname and nsIDNSListener // 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; nsRefPtr<nsHostResolver> mResolver;
nsCString mHost; // hostname we're resolving nsCString mHost; // hostname we're resolving

11
netwerk/ipc/NeckoParent.h
View File

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -91,120 +91,120 @@ public:
nsIURI *aProxyURI); nsIURI *aProxyURI);
// nsIRequest // nsIRequest
NS_IMETHOD GetName(nsACString& aName); NS_IMETHOD GetName(nsACString& aName) MOZ_OVERRIDE;
NS_IMETHOD IsPending(bool *aIsPending); NS_IMETHOD IsPending(bool *aIsPending) MOZ_OVERRIDE;
NS_IMETHOD GetStatus(nsresult *aStatus); NS_IMETHOD GetStatus(nsresult *aStatus) MOZ_OVERRIDE;
NS_IMETHOD GetLoadGroup(nsILoadGroup **aLoadGroup); NS_IMETHOD GetLoadGroup(nsILoadGroup **aLoadGroup) MOZ_OVERRIDE;
NS_IMETHOD SetLoadGroup(nsILoadGroup *aLoadGroup); NS_IMETHOD SetLoadGroup(nsILoadGroup *aLoadGroup) MOZ_OVERRIDE;
NS_IMETHOD GetLoadFlags(nsLoadFlags *aLoadFlags); NS_IMETHOD GetLoadFlags(nsLoadFlags *aLoadFlags) MOZ_OVERRIDE;
NS_IMETHOD SetLoadFlags(nsLoadFlags aLoadFlags); NS_IMETHOD SetLoadFlags(nsLoadFlags aLoadFlags) MOZ_OVERRIDE;
// nsIChannel // nsIChannel
NS_IMETHOD GetOriginalURI(nsIURI **aOriginalURI); NS_IMETHOD GetOriginalURI(nsIURI **aOriginalURI) MOZ_OVERRIDE;
NS_IMETHOD SetOriginalURI(nsIURI *aOriginalURI); NS_IMETHOD SetOriginalURI(nsIURI *aOriginalURI) MOZ_OVERRIDE;
NS_IMETHOD GetURI(nsIURI **aURI); NS_IMETHOD GetURI(nsIURI **aURI) MOZ_OVERRIDE;
NS_IMETHOD GetOwner(nsISupports **aOwner); NS_IMETHOD GetOwner(nsISupports **aOwner) MOZ_OVERRIDE;
NS_IMETHOD SetOwner(nsISupports *aOwner); NS_IMETHOD SetOwner(nsISupports *aOwner) MOZ_OVERRIDE;
NS_IMETHOD GetLoadInfo(nsILoadInfo **aLoadInfo); NS_IMETHOD GetLoadInfo(nsILoadInfo **aLoadInfo) MOZ_OVERRIDE;
NS_IMETHOD SetLoadInfo(nsILoadInfo *aLoadInfo); NS_IMETHOD SetLoadInfo(nsILoadInfo *aLoadInfo) MOZ_OVERRIDE;
NS_IMETHOD GetNotificationCallbacks(nsIInterfaceRequestor **aCallbacks); NS_IMETHOD GetNotificationCallbacks(nsIInterfaceRequestor **aCallbacks) MOZ_OVERRIDE;
NS_IMETHOD SetNotificationCallbacks(nsIInterfaceRequestor *aCallbacks); NS_IMETHOD SetNotificationCallbacks(nsIInterfaceRequestor *aCallbacks) MOZ_OVERRIDE;
NS_IMETHOD GetContentType(nsACString& aContentType); NS_IMETHOD GetContentType(nsACString& aContentType) MOZ_OVERRIDE;
NS_IMETHOD SetContentType(const nsACString& aContentType); NS_IMETHOD SetContentType(const nsACString& aContentType) MOZ_OVERRIDE;
NS_IMETHOD GetContentCharset(nsACString& aContentCharset); NS_IMETHOD GetContentCharset(nsACString& aContentCharset) MOZ_OVERRIDE;
NS_IMETHOD SetContentCharset(const nsACString& aContentCharset); NS_IMETHOD SetContentCharset(const nsACString& aContentCharset) MOZ_OVERRIDE;
NS_IMETHOD GetContentDisposition(uint32_t *aContentDisposition); NS_IMETHOD GetContentDisposition(uint32_t *aContentDisposition) MOZ_OVERRIDE;
NS_IMETHOD SetContentDisposition(uint32_t aContentDisposition); NS_IMETHOD SetContentDisposition(uint32_t aContentDisposition) MOZ_OVERRIDE;
NS_IMETHOD GetContentDispositionFilename(nsAString& aContentDispositionFilename); NS_IMETHOD GetContentDispositionFilename(nsAString& aContentDispositionFilename) MOZ_OVERRIDE;
NS_IMETHOD SetContentDispositionFilename(const nsAString& aContentDispositionFilename); NS_IMETHOD SetContentDispositionFilename(const nsAString& aContentDispositionFilename) MOZ_OVERRIDE;
NS_IMETHOD GetContentDispositionHeader(nsACString& aContentDispositionHeader); NS_IMETHOD GetContentDispositionHeader(nsACString& aContentDispositionHeader) MOZ_OVERRIDE;
NS_IMETHOD GetContentLength(int64_t *aContentLength); NS_IMETHOD GetContentLength(int64_t *aContentLength) MOZ_OVERRIDE;
NS_IMETHOD SetContentLength(int64_t aContentLength); NS_IMETHOD SetContentLength(int64_t aContentLength) MOZ_OVERRIDE;
NS_IMETHOD Open(nsIInputStream **aResult); NS_IMETHOD Open(nsIInputStream **aResult) MOZ_OVERRIDE;
// nsIEncodedChannel // nsIEncodedChannel
NS_IMETHOD GetApplyConversion(bool *value); NS_IMETHOD GetApplyConversion(bool *value) MOZ_OVERRIDE;
NS_IMETHOD SetApplyConversion(bool value); NS_IMETHOD SetApplyConversion(bool value) MOZ_OVERRIDE;
NS_IMETHOD GetContentEncodings(nsIUTF8StringEnumerator** aEncodings); NS_IMETHOD GetContentEncodings(nsIUTF8StringEnumerator** aEncodings) MOZ_OVERRIDE;
NS_IMETHOD DoApplyContentConversions(nsIStreamListener *aNextListener, NS_IMETHOD DoApplyContentConversions(nsIStreamListener *aNextListener,
nsIStreamListener **aNewNextListener, nsIStreamListener **aNewNextListener,
nsISupports *aCtxt); nsISupports *aCtxt) MOZ_OVERRIDE;
// HttpBaseChannel::nsIHttpChannel // HttpBaseChannel::nsIHttpChannel
NS_IMETHOD GetRequestMethod(nsACString& aMethod); NS_IMETHOD GetRequestMethod(nsACString& aMethod) MOZ_OVERRIDE;
NS_IMETHOD SetRequestMethod(const nsACString& aMethod); NS_IMETHOD SetRequestMethod(const nsACString& aMethod) MOZ_OVERRIDE;
NS_IMETHOD GetReferrer(nsIURI **referrer); NS_IMETHOD GetReferrer(nsIURI **referrer) MOZ_OVERRIDE;
NS_IMETHOD SetReferrer(nsIURI *referrer); NS_IMETHOD SetReferrer(nsIURI *referrer) MOZ_OVERRIDE;
NS_IMETHOD GetReferrerPolicy(uint32_t *referrerPolicy); NS_IMETHOD GetReferrerPolicy(uint32_t *referrerPolicy) MOZ_OVERRIDE;
NS_IMETHOD SetReferrerWithPolicy(nsIURI *referrer, uint32_t referrerPolicy); NS_IMETHOD SetReferrerWithPolicy(nsIURI *referrer, uint32_t referrerPolicy) MOZ_OVERRIDE;
NS_IMETHOD GetRequestHeader(const nsACString& aHeader, nsACString& aValue); NS_IMETHOD GetRequestHeader(const nsACString& aHeader, nsACString& aValue) MOZ_OVERRIDE;
NS_IMETHOD SetRequestHeader(const nsACString& aHeader, NS_IMETHOD SetRequestHeader(const nsACString& aHeader,
const nsACString& aValue, bool aMerge); const nsACString& aValue, bool aMerge) MOZ_OVERRIDE;
NS_IMETHOD VisitRequestHeaders(nsIHttpHeaderVisitor *visitor); NS_IMETHOD VisitRequestHeaders(nsIHttpHeaderVisitor *visitor) MOZ_OVERRIDE;
NS_IMETHOD GetResponseHeader(const nsACString &header, nsACString &value); NS_IMETHOD GetResponseHeader(const nsACString &header, nsACString &value) MOZ_OVERRIDE;
NS_IMETHOD SetResponseHeader(const nsACString& header, NS_IMETHOD SetResponseHeader(const nsACString& header,
const nsACString& value, bool merge); const nsACString& value, bool merge) MOZ_OVERRIDE;
NS_IMETHOD VisitResponseHeaders(nsIHttpHeaderVisitor *visitor); NS_IMETHOD VisitResponseHeaders(nsIHttpHeaderVisitor *visitor) MOZ_OVERRIDE;
NS_IMETHOD GetAllowPipelining(bool *value); NS_IMETHOD GetAllowPipelining(bool *value) MOZ_OVERRIDE;
NS_IMETHOD SetAllowPipelining(bool value); NS_IMETHOD SetAllowPipelining(bool value) MOZ_OVERRIDE;
NS_IMETHOD GetAllowSTS(bool *value); NS_IMETHOD GetAllowSTS(bool *value) MOZ_OVERRIDE;
NS_IMETHOD SetAllowSTS(bool value); NS_IMETHOD SetAllowSTS(bool value) MOZ_OVERRIDE;
NS_IMETHOD GetRedirectionLimit(uint32_t *value); NS_IMETHOD GetRedirectionLimit(uint32_t *value) MOZ_OVERRIDE;
NS_IMETHOD SetRedirectionLimit(uint32_t value); NS_IMETHOD SetRedirectionLimit(uint32_t value) MOZ_OVERRIDE;
NS_IMETHOD IsNoStoreResponse(bool *value); NS_IMETHOD IsNoStoreResponse(bool *value) MOZ_OVERRIDE;
NS_IMETHOD IsNoCacheResponse(bool *value); NS_IMETHOD IsNoCacheResponse(bool *value) MOZ_OVERRIDE;
NS_IMETHOD GetResponseStatus(uint32_t *aValue); NS_IMETHOD GetResponseStatus(uint32_t *aValue) MOZ_OVERRIDE;
NS_IMETHOD GetResponseStatusText(nsACString& aValue); NS_IMETHOD GetResponseStatusText(nsACString& aValue) MOZ_OVERRIDE;
NS_IMETHOD GetRequestSucceeded(bool *aValue); NS_IMETHOD GetRequestSucceeded(bool *aValue) MOZ_OVERRIDE;
NS_IMETHOD RedirectTo(nsIURI *newURI); NS_IMETHOD RedirectTo(nsIURI *newURI) MOZ_OVERRIDE;
// nsIHttpChannelInternal // nsIHttpChannelInternal
NS_IMETHOD GetDocumentURI(nsIURI **aDocumentURI); NS_IMETHOD GetDocumentURI(nsIURI **aDocumentURI) MOZ_OVERRIDE;
NS_IMETHOD SetDocumentURI(nsIURI *aDocumentURI); NS_IMETHOD SetDocumentURI(nsIURI *aDocumentURI) MOZ_OVERRIDE;
NS_IMETHOD GetRequestVersion(uint32_t *major, uint32_t *minor); NS_IMETHOD GetRequestVersion(uint32_t *major, uint32_t *minor) MOZ_OVERRIDE;
NS_IMETHOD GetResponseVersion(uint32_t *major, uint32_t *minor); NS_IMETHOD GetResponseVersion(uint32_t *major, uint32_t *minor) MOZ_OVERRIDE;
NS_IMETHOD SetCookie(const char *aCookieHeader); NS_IMETHOD SetCookie(const char *aCookieHeader) MOZ_OVERRIDE;
NS_IMETHOD GetThirdPartyFlags(uint32_t *aForce); NS_IMETHOD GetThirdPartyFlags(uint32_t *aForce) MOZ_OVERRIDE;
NS_IMETHOD SetThirdPartyFlags(uint32_t aForce); NS_IMETHOD SetThirdPartyFlags(uint32_t aForce) MOZ_OVERRIDE;
NS_IMETHOD GetForceAllowThirdPartyCookie(bool *aForce); NS_IMETHOD GetForceAllowThirdPartyCookie(bool *aForce) MOZ_OVERRIDE;
NS_IMETHOD SetForceAllowThirdPartyCookie(bool aForce); NS_IMETHOD SetForceAllowThirdPartyCookie(bool aForce) MOZ_OVERRIDE;
NS_IMETHOD GetCanceled(bool *aCanceled); NS_IMETHOD GetCanceled(bool *aCanceled) MOZ_OVERRIDE;
NS_IMETHOD GetChannelIsForDownload(bool *aChannelIsForDownload); NS_IMETHOD GetChannelIsForDownload(bool *aChannelIsForDownload) MOZ_OVERRIDE;
NS_IMETHOD SetChannelIsForDownload(bool aChannelIsForDownload); NS_IMETHOD SetChannelIsForDownload(bool aChannelIsForDownload) MOZ_OVERRIDE;
NS_IMETHOD SetCacheKeysRedirectChain(nsTArray<nsCString> *cacheKeys); NS_IMETHOD SetCacheKeysRedirectChain(nsTArray<nsCString> *cacheKeys) MOZ_OVERRIDE;
NS_IMETHOD GetLocalAddress(nsACString& addr); NS_IMETHOD GetLocalAddress(nsACString& addr) MOZ_OVERRIDE;
NS_IMETHOD GetLocalPort(int32_t* port); NS_IMETHOD GetLocalPort(int32_t* port) MOZ_OVERRIDE;
NS_IMETHOD GetRemoteAddress(nsACString& addr); NS_IMETHOD GetRemoteAddress(nsACString& addr) MOZ_OVERRIDE;
NS_IMETHOD GetRemotePort(int32_t* port); NS_IMETHOD GetRemotePort(int32_t* port) MOZ_OVERRIDE;
NS_IMETHOD GetAllowSpdy(bool *aAllowSpdy); NS_IMETHOD GetAllowSpdy(bool *aAllowSpdy) MOZ_OVERRIDE;
NS_IMETHOD SetAllowSpdy(bool aAllowSpdy); NS_IMETHOD SetAllowSpdy(bool aAllowSpdy) MOZ_OVERRIDE;
NS_IMETHOD GetApiRedirectToURI(nsIURI * *aApiRedirectToURI); NS_IMETHOD GetApiRedirectToURI(nsIURI * *aApiRedirectToURI) MOZ_OVERRIDE;
NS_IMETHOD AddSecurityMessage(const nsAString &aMessageTag, const nsAString &aMessageCategory); nsresult AddSecurityMessage(const nsAString &aMessageTag, const nsAString &aMessageCategory);
NS_IMETHOD TakeAllSecurityMessages(nsCOMArray<nsISecurityConsoleMessage> &aMessages); NS_IMETHOD TakeAllSecurityMessages(nsCOMArray<nsISecurityConsoleMessage> &aMessages) MOZ_OVERRIDE;
NS_IMETHOD GetResponseTimeoutEnabled(bool *aEnable); NS_IMETHOD GetResponseTimeoutEnabled(bool *aEnable) MOZ_OVERRIDE;
NS_IMETHOD SetResponseTimeoutEnabled(bool aEnable); NS_IMETHOD SetResponseTimeoutEnabled(bool aEnable) MOZ_OVERRIDE;
NS_IMETHOD AddRedirect(nsIPrincipal *aRedirect); NS_IMETHOD AddRedirect(nsIPrincipal *aRedirect) MOZ_OVERRIDE;
NS_IMETHOD ForcePending(bool aForcePending); NS_IMETHOD ForcePending(bool aForcePending) MOZ_OVERRIDE;
NS_IMETHOD GetLastModifiedTime(PRTime* lastModifiedTime); NS_IMETHOD GetLastModifiedTime(PRTime* lastModifiedTime) MOZ_OVERRIDE;
NS_IMETHOD ForceNoIntercept(); NS_IMETHOD ForceNoIntercept() MOZ_OVERRIDE;
NS_IMETHOD GetTopWindowURI(nsIURI **aTopWindowURI); NS_IMETHOD GetTopWindowURI(nsIURI **aTopWindowURI) MOZ_OVERRIDE;
inline void CleanRedirectCacheChainIfNecessary() inline void CleanRedirectCacheChainIfNecessary()
{ {
mRedirectedCachekeys = nullptr; mRedirectedCachekeys = nullptr;
} }
NS_IMETHOD HTTPUpgrade(const nsACString & aProtocolName, NS_IMETHOD HTTPUpgrade(const nsACString & aProtocolName,
nsIHttpUpgradeListener *aListener); nsIHttpUpgradeListener *aListener) MOZ_OVERRIDE;
// nsISupportsPriority // nsISupportsPriority
NS_IMETHOD GetPriority(int32_t *value); NS_IMETHOD GetPriority(int32_t *value) MOZ_OVERRIDE;
NS_IMETHOD AdjustPriority(int32_t delta); NS_IMETHOD AdjustPriority(int32_t delta) MOZ_OVERRIDE;
// nsIClassOfService // 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 // nsIResumableChannel
NS_IMETHOD GetEntityID(nsACString& aEntityID); NS_IMETHOD GetEntityID(nsACString& aEntityID) MOZ_OVERRIDE;
class nsContentEncodings : public nsIUTF8StringEnumerator 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. // Methods HttpBaseChannel didn't implement for us or that we override.
// //
// nsIRequest // nsIRequest
NS_IMETHOD Cancel(nsresult status); NS_IMETHOD Cancel(nsresult status) MOZ_OVERRIDE;
NS_IMETHOD Suspend(); NS_IMETHOD Suspend() MOZ_OVERRIDE;
NS_IMETHOD Resume(); NS_IMETHOD Resume() MOZ_OVERRIDE;
// nsIChannel // nsIChannel
NS_IMETHOD GetSecurityInfo(nsISupports **aSecurityInfo); NS_IMETHOD GetSecurityInfo(nsISupports **aSecurityInfo) MOZ_OVERRIDE;
NS_IMETHOD AsyncOpen(nsIStreamListener *listener, nsISupports *aContext); NS_IMETHOD AsyncOpen(nsIStreamListener *listener, nsISupports *aContext) MOZ_OVERRIDE;
// HttpBaseChannel::nsIHttpChannel // HttpBaseChannel::nsIHttpChannel
NS_IMETHOD SetRequestHeader(const nsACString& aHeader, NS_IMETHOD SetRequestHeader(const nsACString& aHeader,
const nsACString& aValue, const nsACString& aValue,
bool aMerge); bool aMerge) MOZ_OVERRIDE;
NS_IMETHOD RedirectTo(nsIURI *newURI); NS_IMETHOD RedirectTo(nsIURI *newURI) MOZ_OVERRIDE;
// nsIHttpChannelInternal // nsIHttpChannelInternal
NS_IMETHOD SetupFallbackChannel(const char *aFallbackKey); NS_IMETHOD SetupFallbackChannel(const char *aFallbackKey) MOZ_OVERRIDE;
NS_IMETHOD GetLocalAddress(nsACString& addr); NS_IMETHOD GetLocalAddress(nsACString& addr) MOZ_OVERRIDE;
NS_IMETHOD GetLocalPort(int32_t* port); NS_IMETHOD GetLocalPort(int32_t* port) MOZ_OVERRIDE;
NS_IMETHOD GetRemoteAddress(nsACString& addr); NS_IMETHOD GetRemoteAddress(nsACString& addr) MOZ_OVERRIDE;
NS_IMETHOD GetRemotePort(int32_t* port); NS_IMETHOD GetRemotePort(int32_t* port) MOZ_OVERRIDE;
// nsISupportsPriority // nsISupportsPriority
NS_IMETHOD SetPriority(int32_t value); NS_IMETHOD SetPriority(int32_t value) MOZ_OVERRIDE;
// nsIClassOfService // nsIClassOfService
NS_IMETHOD SetClassFlags(uint32_t inFlags); NS_IMETHOD SetClassFlags(uint32_t inFlags) MOZ_OVERRIDE;
NS_IMETHOD AddClassFlags(uint32_t inFlags); NS_IMETHOD AddClassFlags(uint32_t inFlags) MOZ_OVERRIDE;
NS_IMETHOD ClearClassFlags(uint32_t inFlags); NS_IMETHOD ClearClassFlags(uint32_t inFlags) MOZ_OVERRIDE;
// nsIResumableChannel // 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 // IPDL holds a reference while the PHttpChannel protocol is live (starting at
// AsyncOpen, and ending at either OnStopRequest or any IPDL error, either of // AsyncOpen, and ending at either OnStopRequest or any IPDL error, either of
@ -125,7 +125,7 @@ protected:
const nsCString& data, const nsCString& data,
const uint64_t& offset, const uint64_t& offset,
const uint32_t& count) MOZ_OVERRIDE; 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 RecvOnProgress(const uint64_t& progress, const uint64_t& progressMax) MOZ_OVERRIDE;
bool RecvOnStatus(const nsresult& status) MOZ_OVERRIDE; bool RecvOnStatus(const nsresult& status) MOZ_OVERRIDE;
bool RecvFailedAsyncOpen(const nsresult& status) MOZ_OVERRIDE; bool RecvFailedAsyncOpen(const nsresult& status) MOZ_OVERRIDE;
@ -141,7 +141,7 @@ protected:
bool RecvDeleteSelf() MOZ_OVERRIDE; bool RecvDeleteSelf() MOZ_OVERRIDE;
bool GetAssociatedContentSecurity(nsIAssociatedContentSecurity** res = nullptr); bool GetAssociatedContentSecurity(nsIAssociatedContentSecurity** res = nullptr);
virtual void DoNotifyListenerCleanup(); virtual void DoNotifyListenerCleanup() MOZ_OVERRIDE;
private: private:
nsresult ContinueAsyncOpen(); nsresult ContinueAsyncOpen();

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

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

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

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

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

@ -771,23 +771,23 @@ class SocketInWrapper : public nsIAsyncInputStream
, mTLSFilter(aFilter) , mTLSFilter(aFilter)
{ } { }
NS_IMETHODIMP Close() NS_IMETHODIMP Close() MOZ_OVERRIDE
{ {
mTLSFilter = nullptr; mTLSFilter = nullptr;
return mStream->Close(); return mStream->Close();
} }
NS_IMETHODIMP Available(uint64_t *_retval) NS_IMETHODIMP Available(uint64_t *_retval) MOZ_OVERRIDE
{ {
return mStream->Available(_retval); return mStream->Available(_retval);
} }
NS_IMETHODIMP IsNonBlocking(bool *_retval) NS_IMETHODIMP IsNonBlocking(bool *_retval) MOZ_OVERRIDE
{ {
return mStream->IsNonBlocking(_retval); 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); return mStream->ReadSegments(aWriter, aClosure, aCount, _retval);
} }
@ -838,28 +838,28 @@ class SocketOutWrapper : public nsIAsyncOutputStream
, mTLSFilter(aFilter) , mTLSFilter(aFilter)
{ } { }
NS_IMETHODIMP Close() NS_IMETHODIMP Close() MOZ_OVERRIDE
{ {
mTLSFilter = nullptr; mTLSFilter = nullptr;
return mStream->Close(); return mStream->Close();
} }
NS_IMETHODIMP Flush() NS_IMETHODIMP Flush() MOZ_OVERRIDE
{ {
return mStream->Flush(); return mStream->Flush();
} }
NS_IMETHODIMP IsNonBlocking(bool *_retval) NS_IMETHODIMP IsNonBlocking(bool *_retval) MOZ_OVERRIDE
{ {
return mStream->IsNonBlocking(_retval); 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); 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); return mStream->WriteFrom(aFromStream, aCount, _retval);
} }

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

@ -93,7 +93,7 @@ public:
virtual void OnTunnelNudged(TLSFilterTransaction *) = 0; 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 class TLSFilterTransaction MOZ_FINAL
: public nsAHttpTransaction : public nsAHttpTransaction
@ -115,8 +115,8 @@ public:
nsAHttpSegmentWriter *writer); nsAHttpSegmentWriter *writer);
const nsAHttpTransaction *Transaction() const { return mTransaction.get(); } const nsAHttpTransaction *Transaction() const { return mTransaction.get(); }
nsresult CommitToSegmentSize(uint32_t size, bool forceCommitment); nsresult CommitToSegmentSize(uint32_t size, bool forceCommitment) MOZ_OVERRIDE;
nsresult GetTransactionSecurityInfo(nsISupports **); nsresult GetTransactionSecurityInfo(nsISupports **) MOZ_OVERRIDE;
nsresult NudgeTunnel(NudgeTunnelCallback *callback); nsresult NudgeTunnel(NudgeTunnelCallback *callback);
nsresult SetProxiedTransaction(nsAHttpTransaction *aTrans); nsresult SetProxiedTransaction(nsAHttpTransaction *aTrans);
void newIODriver(nsIAsyncInputStream *aSocketIn, void newIODriver(nsIAsyncInputStream *aSocketIn,
@ -184,7 +184,7 @@ public:
nsAHttpConnection *session); nsAHttpConnection *session);
~SpdyConnectTransaction(); ~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 // 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. // 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) NS_DEFINE_STATIC_IID_ACCESSOR(nsAHttpConnection, NS_AHTTPCONNECTION_IID)
#define NS_DECL_NSAHTTPCONNECTION(fwdObject) \ #define NS_DECL_NSAHTTPCONNECTION(fwdObject) \
nsresult OnHeadersAvailable(nsAHttpTransaction *, nsHttpRequestHead *, nsHttpResponseHead *, bool *reset); \ nsresult OnHeadersAvailable(nsAHttpTransaction *, nsHttpRequestHead *, nsHttpResponseHead *, bool *reset) MOZ_OVERRIDE; \
void CloseTransaction(nsAHttpTransaction *, nsresult); \ void CloseTransaction(nsAHttpTransaction *, nsresult) MOZ_OVERRIDE; \
nsresult TakeTransport(nsISocketTransport **, \ nsresult TakeTransport(nsISocketTransport **, \
nsIAsyncInputStream **, \ nsIAsyncInputStream **, \
nsIAsyncOutputStream **); \ nsIAsyncOutputStream **) MOZ_OVERRIDE; \
bool IsPersistent(); \ bool IsPersistent() MOZ_OVERRIDE; \
bool IsReused(); \ bool IsReused() MOZ_OVERRIDE; \
void DontReuse(); \ void DontReuse() MOZ_OVERRIDE; \
nsresult PushBack(const char *, uint32_t); \ nsresult PushBack(const char *, uint32_t) MOZ_OVERRIDE; \
nsHttpConnection *TakeHttpConnection(); \ nsHttpConnection *TakeHttpConnection() MOZ_OVERRIDE; \
uint32_t CancelPipeline(nsresult originalReason); \ uint32_t CancelPipeline(nsresult originalReason) MOZ_OVERRIDE; \
nsAHttpTransaction::Classifier Classification(); \ nsAHttpTransaction::Classifier Classification() MOZ_OVERRIDE; \
/* \ /* \
Thes methods below have automatic definitions that just forward the \ Thes methods below have automatic definitions that just forward the \
function to a lower level connection object \ function to a lower level connection object \
*/ \ */ \
void GetConnectionInfo(nsHttpConnectionInfo **result) \ void GetConnectionInfo(nsHttpConnectionInfo **result) \
MOZ_OVERRIDE \
{ \ { \
if (!(fwdObject)) { \ if (!(fwdObject)) { \
*result = nullptr; \ *result = nullptr; \
@ -173,6 +174,7 @@ NS_DEFINE_STATIC_IID_ACCESSOR(nsAHttpConnection, NS_AHTTPCONNECTION_IID)
return (fwdObject)->GetConnectionInfo(result); \ return (fwdObject)->GetConnectionInfo(result); \
} \ } \
void GetSecurityInfo(nsISupports **result) \ void GetSecurityInfo(nsISupports **result) \
MOZ_OVERRIDE \
{ \ { \
if (!(fwdObject)) { \ if (!(fwdObject)) { \
*result = nullptr; \ *result = nullptr; \
@ -180,62 +182,66 @@ NS_DEFINE_STATIC_IID_ACCESSOR(nsAHttpConnection, NS_AHTTPCONNECTION_IID)
} \ } \
return (fwdObject)->GetSecurityInfo(result); \ return (fwdObject)->GetSecurityInfo(result); \
} \ } \
nsresult ResumeSend() \ nsresult ResumeSend() MOZ_OVERRIDE \
{ \ { \
if (!(fwdObject)) \ if (!(fwdObject)) \
return NS_ERROR_FAILURE; \ return NS_ERROR_FAILURE; \
return (fwdObject)->ResumeSend(); \ return (fwdObject)->ResumeSend(); \
} \ } \
nsresult ResumeRecv() \ nsresult ResumeRecv() MOZ_OVERRIDE \
{ \ { \
if (!(fwdObject)) \ if (!(fwdObject)) \
return NS_ERROR_FAILURE; \ return NS_ERROR_FAILURE; \
return (fwdObject)->ResumeRecv(); \ return (fwdObject)->ResumeRecv(); \
} \ } \
nsresult ForceSend() \ nsresult ForceSend() MOZ_OVERRIDE \
{ \ { \
if (!(fwdObject)) \ if (!(fwdObject)) \
return NS_ERROR_FAILURE; \ return NS_ERROR_FAILURE; \
return (fwdObject)->ForceSend(); \ return (fwdObject)->ForceSend(); \
} \ } \
nsresult ForceRecv() \ nsresult ForceRecv() MOZ_OVERRIDE \
{ \ { \
if (!(fwdObject)) \ if (!(fwdObject)) \
return NS_ERROR_FAILURE; \ return NS_ERROR_FAILURE; \
return (fwdObject)->ForceRecv(); \ return (fwdObject)->ForceRecv(); \
} \ } \
nsISocketTransport *Transport() \ nsISocketTransport *Transport() \
MOZ_OVERRIDE \
{ \ { \
if (!(fwdObject)) \ if (!(fwdObject)) \
return nullptr; \ return nullptr; \
return (fwdObject)->Transport(); \ return (fwdObject)->Transport(); \
} \ } \
uint32_t Version() \ uint32_t Version() MOZ_OVERRIDE \
{ \ { \
return (fwdObject) ? \ return (fwdObject) ? \
(fwdObject)->Version() : \ (fwdObject)->Version() : \
NS_HTTP_VERSION_UNKNOWN; \ NS_HTTP_VERSION_UNKNOWN; \
} \ } \
bool IsProxyConnectInProgress() \ bool IsProxyConnectInProgress() MOZ_OVERRIDE \
{ \ { \
return (fwdObject)->IsProxyConnectInProgress(); \ return (fwdObject)->IsProxyConnectInProgress(); \
} \ } \
bool LastTransactionExpectedNoContent() \ bool LastTransactionExpectedNoContent() MOZ_OVERRIDE \
{ \ { \
return (fwdObject)->LastTransactionExpectedNoContent(); \ return (fwdObject)->LastTransactionExpectedNoContent(); \
} \ } \
void SetLastTransactionExpectedNoContent(bool val) \ void SetLastTransactionExpectedNoContent(bool val) \
MOZ_OVERRIDE \
{ \ { \
return (fwdObject)->SetLastTransactionExpectedNoContent(val); \ return (fwdObject)->SetLastTransactionExpectedNoContent(val); \
} \ } \
void Classify(nsAHttpTransaction::Classifier newclass) \ void Classify(nsAHttpTransaction::Classifier newclass) \
MOZ_OVERRIDE \
{ \ { \
if (fwdObject) \ if (fwdObject) \
return (fwdObject)->Classify(newclass); \ return (fwdObject)->Classify(newclass); \
} \ } \
int64_t BytesWritten() \ int64_t BytesWritten() MOZ_OVERRIDE \
{ return fwdObject ? (fwdObject)->BytesWritten() : 0; } \ { return fwdObject ? (fwdObject)->BytesWritten() : 0; } \
void SetSecurityCallbacks(nsIInterfaceRequestor* aCallbacks) \ void SetSecurityCallbacks(nsIInterfaceRequestor* aCallbacks) \
MOZ_OVERRIDE \
{ \ { \
if (fwdObject) \ if (fwdObject) \
(fwdObject)->SetSecurityCallbacks(aCallbacks); \ (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) NS_DEFINE_STATIC_IID_ACCESSOR(nsAHttpTransaction, NS_AHTTPTRANSACTION_IID)
#define NS_DECL_NSAHTTPTRANSACTION \ #define NS_DECL_NSAHTTPTRANSACTION \
void SetConnection(nsAHttpConnection *); \ void SetConnection(nsAHttpConnection *) MOZ_OVERRIDE; \
nsAHttpConnection *Connection(); \ nsAHttpConnection *Connection() MOZ_OVERRIDE; \
void GetSecurityCallbacks(nsIInterfaceRequestor **); \ void GetSecurityCallbacks(nsIInterfaceRequestor **) MOZ_OVERRIDE; \
void OnTransportStatus(nsITransport* transport, \ void OnTransportStatus(nsITransport* transport, \
nsresult status, uint64_t progress); \ nsresult status, uint64_t progress) MOZ_OVERRIDE; \
bool IsDone(); \ bool IsDone() MOZ_OVERRIDE; \
nsresult Status(); \ nsresult Status() MOZ_OVERRIDE; \
uint32_t Caps(); \ uint32_t Caps() MOZ_OVERRIDE; \
void SetDNSWasRefreshed(); \ void SetDNSWasRefreshed() MOZ_OVERRIDE; \
uint64_t Available(); \ uint64_t Available() MOZ_OVERRIDE; \
virtual nsresult ReadSegments(nsAHttpSegmentReader *, uint32_t, uint32_t *); \ virtual nsresult ReadSegments(nsAHttpSegmentReader *, uint32_t, uint32_t *) MOZ_OVERRIDE; \
virtual nsresult WriteSegments(nsAHttpSegmentWriter *, uint32_t, uint32_t *); \ virtual nsresult WriteSegments(nsAHttpSegmentWriter *, uint32_t, uint32_t *) MOZ_OVERRIDE; \
virtual void Close(nsresult reason); \ virtual void Close(nsresult reason) MOZ_OVERRIDE; \
nsHttpConnectionInfo *ConnectionInfo(); \ nsHttpConnectionInfo *ConnectionInfo() MOZ_OVERRIDE; \
void SetProxyConnectFailed(); \ void SetProxyConnectFailed() MOZ_OVERRIDE; \
virtual nsHttpRequestHead *RequestHead(); \ virtual nsHttpRequestHead *RequestHead() MOZ_OVERRIDE; \
uint32_t Http1xTransactionCount(); \ uint32_t Http1xTransactionCount() MOZ_OVERRIDE; \
nsresult TakeSubTransactions(nsTArray<nsRefPtr<nsAHttpTransaction> > &outTransactions); \ nsresult TakeSubTransactions(nsTArray<nsRefPtr<nsAHttpTransaction> > &outTransactions) MOZ_OVERRIDE; \
nsresult AddTransaction(nsAHttpTransaction *); \ nsresult AddTransaction(nsAHttpTransaction *) MOZ_OVERRIDE; \
uint32_t PipelineDepth(); \ uint32_t PipelineDepth() MOZ_OVERRIDE; \
nsresult SetPipelinePosition(int32_t); \ nsresult SetPipelinePosition(int32_t) MOZ_OVERRIDE; \
int32_t PipelinePosition(); int32_t PipelinePosition() MOZ_OVERRIDE;
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// nsAHttpSegmentReader // nsAHttpSegmentReader
@ -246,7 +246,7 @@ public:
}; };
#define NS_DECL_NSAHTTPSEGMENTREADER \ #define NS_DECL_NSAHTTPSEGMENTREADER \
nsresult OnReadSegment(const char *, uint32_t, uint32_t *); nsresult OnReadSegment(const char *, uint32_t, uint32_t *) MOZ_OVERRIDE;
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// nsAHttpSegmentWriter // nsAHttpSegmentWriter
@ -262,7 +262,7 @@ public:
}; };
#define NS_DECL_NSAHTTPSEGMENTWRITER \ #define NS_DECL_NSAHTTPSEGMENTWRITER \
nsresult OnWriteSegment(char *, uint32_t, uint32_t *); nsresult OnWriteSegment(char *, uint32_t, uint32_t *) MOZ_OVERRIDE;
}} // namespace mozilla::net }} // 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. // Both interfaces declares toString method with the same signature.
// Thus we have to delegate only to nsISupportsPRUint32 implementation. // 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); return mSupportsCString->GetData(aData);
} }
NS_IMETHOD SetData(const nsACString & aData) NS_IMETHOD SetData(const nsACString & aData) MOZ_OVERRIDE
{ {
return mSupportsCString->SetData(aData); return mSupportsCString->SetData(aData);
} }

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

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

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

@ -57,7 +57,7 @@ private:
} }
// overload of nsAHttpTransaction::QueryPipeline() // overload of nsAHttpTransaction::QueryPipeline()
nsHttpPipeline *QueryPipeline(); nsHttpPipeline *QueryPipeline() MOZ_OVERRIDE;
nsRefPtr<nsAHttpConnection> mConnection; nsRefPtr<nsAHttpConnection> mConnection;
nsTArray<nsAHttpTransaction*> mRequestQ; // array of transactions 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; } bool UsesPipelining() const { return mCaps & NS_HTTP_ALLOW_PIPELINING; }
// overload of nsAHttpTransaction::LoadGroupConnectionInfo() // overload of nsAHttpTransaction::LoadGroupConnectionInfo()
nsILoadGroupConnectionInfo *LoadGroupConnectionInfo() { return mLoadGroupCI.get(); } nsILoadGroupConnectionInfo *LoadGroupConnectionInfo() MOZ_OVERRIDE { return mLoadGroupCI.get(); }
void SetLoadGroupConnectionInfo(nsILoadGroupConnectionInfo *aLoadGroupCI) { mLoadGroupCI = aLoadGroupCI; } void SetLoadGroupConnectionInfo(nsILoadGroupConnectionInfo *aLoadGroupCI) { mLoadGroupCI = aLoadGroupCI; }
void DispatchedAsBlocking(); void DispatchedAsBlocking();
void RemoveDispatchedAsBlocking(); void RemoveDispatchedAsBlocking();
@ -372,7 +372,7 @@ public:
// token bucket submission the transaction just posts an event that causes // token bucket submission the transaction just posts an event that causes
// the pending transaction queue to be rerun (and TryToRunPacedRequest() to // the pending transaction queue to be rerun (and TryToRunPacedRequest() to
// be run again. // be run again.
void OnTokenBucketAdmitted(); // ATokenBucketEvent void OnTokenBucketAdmitted() MOZ_OVERRIDE; // ATokenBucketEvent
// CancelPacing() can be used to tell the token bucket to remove this // CancelPacing() can be used to tell the token bucket to remove this
// transaction from the list of pending transactions. This is used when a // 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_NSIPROTOCOLHANDLER
NS_DECL_NSITHREADRETARGETABLEREQUEST NS_DECL_NSITHREADRETARGETABLEREQUEST
NS_IMETHOD QueryInterface(const nsIID & uuid, void **result) = 0; NS_IMETHOD QueryInterface(const nsIID & uuid, void **result) MOZ_OVERRIDE = 0;
NS_IMETHOD_(MozExternalRefCountType ) AddRef(void) = 0; NS_IMETHOD_(MozExternalRefCountType ) AddRef(void) MOZ_OVERRIDE = 0;
NS_IMETHOD_(MozExternalRefCountType ) Release(void) = 0; NS_IMETHOD_(MozExternalRefCountType ) Release(void) MOZ_OVERRIDE = 0;
// Partial implementation of nsIWebSocketChannel // Partial implementation of nsIWebSocketChannel
// //
NS_IMETHOD GetOriginalURI(nsIURI **aOriginalURI); NS_IMETHOD GetOriginalURI(nsIURI **aOriginalURI) MOZ_OVERRIDE;
NS_IMETHOD GetURI(nsIURI **aURI); NS_IMETHOD GetURI(nsIURI **aURI) MOZ_OVERRIDE;
NS_IMETHOD GetNotificationCallbacks(nsIInterfaceRequestor **aNotificationCallbacks); NS_IMETHOD GetNotificationCallbacks(nsIInterfaceRequestor **aNotificationCallbacks) MOZ_OVERRIDE;
NS_IMETHOD SetNotificationCallbacks(nsIInterfaceRequestor *aNotificationCallbacks); NS_IMETHOD SetNotificationCallbacks(nsIInterfaceRequestor *aNotificationCallbacks) MOZ_OVERRIDE;
NS_IMETHOD GetLoadGroup(nsILoadGroup **aLoadGroup); NS_IMETHOD GetLoadGroup(nsILoadGroup **aLoadGroup) MOZ_OVERRIDE;
NS_IMETHOD SetLoadGroup(nsILoadGroup *aLoadGroup); NS_IMETHOD SetLoadGroup(nsILoadGroup *aLoadGroup) MOZ_OVERRIDE;
NS_IMETHOD SetLoadInfo(nsILoadInfo *aLoadInfo); NS_IMETHOD SetLoadInfo(nsILoadInfo *aLoadInfo) MOZ_OVERRIDE;
NS_IMETHOD GetLoadInfo(nsILoadInfo **aLoadInfo); NS_IMETHOD GetLoadInfo(nsILoadInfo **aLoadInfo) MOZ_OVERRIDE;
NS_IMETHOD GetExtensions(nsACString &aExtensions); NS_IMETHOD GetExtensions(nsACString &aExtensions) MOZ_OVERRIDE;
NS_IMETHOD GetProtocol(nsACString &aProtocol); NS_IMETHOD GetProtocol(nsACString &aProtocol) MOZ_OVERRIDE;
NS_IMETHOD SetProtocol(const nsACString &aProtocol); NS_IMETHOD SetProtocol(const nsACString &aProtocol) MOZ_OVERRIDE;
NS_IMETHOD GetPingInterval(uint32_t *aSeconds); NS_IMETHOD GetPingInterval(uint32_t *aSeconds) MOZ_OVERRIDE;
NS_IMETHOD SetPingInterval(uint32_t aSeconds); NS_IMETHOD SetPingInterval(uint32_t aSeconds) MOZ_OVERRIDE;
NS_IMETHOD GetPingTimeout(uint32_t *aSeconds); NS_IMETHOD GetPingTimeout(uint32_t *aSeconds) MOZ_OVERRIDE;
NS_IMETHOD SetPingTimeout(uint32_t aSeconds); NS_IMETHOD SetPingTimeout(uint32_t aSeconds) MOZ_OVERRIDE;
// Off main thread URI access. // Off main thread URI access.
virtual void GetEffectiveURL(nsAString& aEffectiveURL) const = 0; virtual void GetEffectiveURL(nsAString& aEffectiveURL) const = 0;

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

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

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

@ -88,12 +88,12 @@ public:
NS_IMETHOD AsyncOpen(nsIURI *aURI, NS_IMETHOD AsyncOpen(nsIURI *aURI,
const nsACString &aOrigin, const nsACString &aOrigin,
nsIWebSocketListener *aListener, nsIWebSocketListener *aListener,
nsISupports *aContext); nsISupports *aContext) MOZ_OVERRIDE;
NS_IMETHOD Close(uint16_t aCode, const nsACString & aReason); NS_IMETHOD Close(uint16_t aCode, const nsACString & aReason) MOZ_OVERRIDE;
NS_IMETHOD SendMsg(const nsACString &aMsg); NS_IMETHOD SendMsg(const nsACString &aMsg) MOZ_OVERRIDE;
NS_IMETHOD SendBinaryMsg(const nsACString &aMsg); NS_IMETHOD SendBinaryMsg(const nsACString &aMsg) MOZ_OVERRIDE;
NS_IMETHOD SendBinaryStream(nsIInputStream *aStream, uint32_t length); NS_IMETHOD SendBinaryStream(nsIInputStream *aStream, uint32_t length) MOZ_OVERRIDE;
NS_IMETHOD GetSecurityInfo(nsISupports **aSecurityInfo); NS_IMETHOD GetSecurityInfo(nsISupports **aSecurityInfo) MOZ_OVERRIDE;
WebSocketChannel(); WebSocketChannel();
static void Shutdown(); 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 // nsIWebSocketChannel methods BaseWebSocketChannel didn't implement for us
// //
NS_IMETHOD AsyncOpen(nsIURI *aURI, const nsACString &aOrigin, NS_IMETHOD AsyncOpen(nsIURI *aURI, const nsACString &aOrigin,
nsIWebSocketListener *aListener, nsISupports *aContext); nsIWebSocketListener *aListener, nsISupports *aContext) MOZ_OVERRIDE;
NS_IMETHOD Close(uint16_t code, const nsACString & reason); NS_IMETHOD Close(uint16_t code, const nsACString & reason) MOZ_OVERRIDE;
NS_IMETHOD SendMsg(const nsACString &aMsg); NS_IMETHOD SendMsg(const nsACString &aMsg) MOZ_OVERRIDE;
NS_IMETHOD SendBinaryMsg(const nsACString &aMsg); NS_IMETHOD SendBinaryMsg(const nsACString &aMsg) MOZ_OVERRIDE;
NS_IMETHOD SendBinaryStream(nsIInputStream *aStream, uint32_t aLength); NS_IMETHOD SendBinaryStream(nsIInputStream *aStream, uint32_t aLength) MOZ_OVERRIDE;
nsresult SendBinaryStream(OptionalInputStreamParams *aStream, uint32_t aLength); nsresult SendBinaryStream(OptionalInputStreamParams *aStream, uint32_t aLength);
NS_IMETHOD GetSecurityInfo(nsISupports **aSecurityInfo); NS_IMETHOD GetSecurityInfo(nsISupports **aSecurityInfo) MOZ_OVERRIDE;
void AddIPDLReference(); void AddIPDLReference();
void ReleaseIPDLReference(); void ReleaseIPDLReference();