--- a/netwerk/base/src/BackgroundFileSaver.h
+++ b/netwerk/base/src/BackgroundFileSaver.h
@@ -49,17 +49,17 @@ public:
* This is called automatically by the XPCOM infrastructure, and if this
* fails, the factory will delete this object without returning a reference.
*/
nsresult Init();
/**
* Used by nsNSSShutDownList to manage nsNSSShutDownObjects.
*/
- void virtualDestroyNSSReference();
+ void virtualDestroyNSSReference() MOZ_OVERRIDE;
/**
* Number of worker threads that are currently running.
*/
static uint32_t sThreadCount;
/**
* Maximum number of worker threads reached during the current download session,
@@ -395,17 +395,17 @@ class DigestOutputStream : public nsNSSS
{
public:
NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIOUTPUTSTREAM
// Constructor. Neither parameter may be null. The caller owns both.
DigestOutputStream(nsIOutputStream* outputStream, PK11Context* aContext);
// We don't own any NSS objects here, so no need to clean up
- void virtualDestroyNSSReference() { }
+ void virtualDestroyNSSReference() MOZ_OVERRIDE { }
private:
~DigestOutputStream();
// Calls to write are passed to this stream.
nsCOMPtr<nsIOutputStream> mOutputStream;
// Digest context used to compute the hash, owned by the caller.
PK11Context* mDigestContext;
--- a/netwerk/base/src/ProxyAutoConfig.cpp
+++ b/netwerk/base/src/ProxyAutoConfig.cpp
@@ -267,31 +267,31 @@ public:
PACResolver()
: mStatus(NS_ERROR_FAILURE)
{
}
// nsIDNSListener
NS_IMETHODIMP OnLookupComplete(nsICancelable *request,
nsIDNSRecord *record,
- nsresult status)
+ nsresult status) MOZ_OVERRIDE
{
if (mTimer) {
mTimer->Cancel();
mTimer = nullptr;
}
mRequest = nullptr;
mStatus = status;
mResponse = record;
return NS_OK;
}
// nsITimerCallback
- NS_IMETHODIMP Notify(nsITimer *timer)
+ NS_IMETHODIMP Notify(nsITimer *timer) MOZ_OVERRIDE
{
if (mRequest)
mRequest->Cancel(NS_ERROR_NET_TIMEOUT);
mTimer = nullptr;
return NS_OK;
}
nsresult mStatus;
--- a/netwerk/base/src/nsAsyncStreamCopier.h
+++ b/netwerk/base/src/nsAsyncStreamCopier.h
@@ -26,17 +26,17 @@ public:
// nsIAsyncStreamCopier2
// We declare it by hand instead of NS_DECL_NSIASYNCSTREAMCOPIER2
// as nsIAsyncStreamCopier2 duplicates methods of nsIAsyncStreamCopier
NS_IMETHOD Init(nsIInputStream *aSource,
nsIOutputStream *aSink,
nsIEventTarget *aTarget,
uint32_t aChunkSize,
bool aCloseSource,
- bool aCloseSink);
+ bool aCloseSink) MOZ_OVERRIDE;
nsAsyncStreamCopier();
//-------------------------------------------------------------------------
// these methods may be called on any thread
bool IsComplete(nsresult *status = nullptr);
void Complete(nsresult status);
--- a/netwerk/base/src/nsBufferedStreams.h
+++ b/netwerk/base/src/nsBufferedStreams.h
@@ -77,18 +77,18 @@ public:
nsIInputStream* Source() {
return (nsIInputStream*)mStream;
}
protected:
virtual ~nsBufferedInputStream() {}
- NS_IMETHOD Fill();
- NS_IMETHOD Flush() { return NS_OK; } // no-op for input streams
+ NS_IMETHOD Fill() MOZ_OVERRIDE;
+ NS_IMETHOD Flush() MOZ_OVERRIDE { return NS_OK; } // no-op for input streams
};
////////////////////////////////////////////////////////////////////////////////
class nsBufferedOutputStream : public nsBufferedStream,
public nsISafeOutputStream,
public nsIBufferedOutputStream,
public nsIStreamBufferAccess
@@ -107,16 +107,16 @@ public:
nsIOutputStream* Sink() {
return (nsIOutputStream*)mStream;
}
protected:
virtual ~nsBufferedOutputStream() { nsBufferedOutputStream::Close(); }
- NS_IMETHOD Fill() { return NS_OK; } // no-op for output streams
+ NS_IMETHOD Fill() MOZ_OVERRIDE { return NS_OK; } // no-op for output streams
nsCOMPtr<nsISafeOutputStream> mSafeStream; // QI'd from mStream
};
////////////////////////////////////////////////////////////////////////////////
#endif // nsBufferedStreams_h__
--- a/netwerk/base/src/nsFileStreams.h
+++ b/netwerk/base/src/nsFileStreams.h
@@ -107,33 +107,33 @@ class nsFileInputStream : public nsFileS
public nsIIPCSerializableInputStream
{
public:
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_NSIFILEINPUTSTREAM
NS_DECL_NSILINEINPUTSTREAM
NS_DECL_NSIIPCSERIALIZABLEINPUTSTREAM
- NS_IMETHOD Close();
- NS_IMETHOD Tell(int64_t *aResult);
- NS_IMETHOD Available(uint64_t* _retval);
- NS_IMETHOD Read(char* aBuf, uint32_t aCount, uint32_t* _retval);
+ NS_IMETHOD Close() MOZ_OVERRIDE;
+ NS_IMETHOD Tell(int64_t *aResult) MOZ_OVERRIDE;
+ NS_IMETHOD Available(uint64_t* _retval) MOZ_OVERRIDE;
+ NS_IMETHOD Read(char* aBuf, uint32_t aCount, uint32_t* _retval) MOZ_OVERRIDE;
NS_IMETHOD ReadSegments(nsWriteSegmentFun aWriter, void *aClosure,
- uint32_t aCount, uint32_t* _retval)
+ uint32_t aCount, uint32_t* _retval) MOZ_OVERRIDE
{
return nsFileStreamBase::ReadSegments(aWriter, aClosure, aCount,
_retval);
}
- NS_IMETHOD IsNonBlocking(bool* _retval)
+ NS_IMETHOD IsNonBlocking(bool* _retval) MOZ_OVERRIDE
{
return nsFileStreamBase::IsNonBlocking(_retval);
}
// Overrided from nsFileStreamBase
- NS_IMETHOD Seek(int32_t aWhence, int64_t aOffset);
+ NS_IMETHOD Seek(int32_t aWhence, int64_t aOffset) MOZ_OVERRIDE;
nsFileInputStream()
: mLineBuffer(nullptr), mIOFlags(0), mPerm(0), mCachedPosition(0)
{}
static nsresult
Create(nsISupports *aOuter, REFNSIID aIID, void **aResult);
@@ -182,20 +182,20 @@ public:
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_NSIPARTIALFILEINPUTSTREAM
NS_DECL_NSIIPCSERIALIZABLEINPUTSTREAM
nsPartialFileInputStream()
: mStart(0), mLength(0), mPosition(0)
{ }
- NS_IMETHOD Tell(int64_t *aResult);
- NS_IMETHOD Available(uint64_t *aResult);
- NS_IMETHOD Read(char* aBuf, uint32_t aCount, uint32_t* aResult);
- NS_IMETHOD Seek(int32_t aWhence, int64_t aOffset);
+ NS_IMETHOD Tell(int64_t *aResult) MOZ_OVERRIDE;
+ NS_IMETHOD Available(uint64_t *aResult) MOZ_OVERRIDE;
+ NS_IMETHOD Read(char* aBuf, uint32_t aCount, uint32_t* aResult) MOZ_OVERRIDE;
+ NS_IMETHOD Seek(int32_t aWhence, int64_t aOffset) MOZ_OVERRIDE;
static nsresult
Create(nsISupports *aOuter, REFNSIID aIID, void **aResult);
protected:
~nsPartialFileInputStream()
{ }
@@ -244,19 +244,19 @@ public:
NS_DECL_NSISAFEOUTPUTSTREAM
nsAtomicFileOutputStream() :
mTargetFileExists(true),
mWriteResult(NS_OK) {}
virtual nsresult DoOpen() MOZ_OVERRIDE;
- NS_IMETHODIMP Close();
- NS_IMETHODIMP Write(const char *buf, uint32_t count, uint32_t *result);
- NS_IMETHODIMP Init(nsIFile* file, int32_t ioFlags, int32_t perm, int32_t behaviorFlags);
+ NS_IMETHODIMP Close() MOZ_OVERRIDE;
+ NS_IMETHODIMP Write(const char *buf, uint32_t count, uint32_t *result) MOZ_OVERRIDE;
+ NS_IMETHODIMP Init(nsIFile* file, int32_t ioFlags, int32_t perm, int32_t behaviorFlags) MOZ_OVERRIDE;
protected:
virtual ~nsAtomicFileOutputStream()
{
Close();
}
nsCOMPtr<nsIFile> mTargetFile;
@@ -274,48 +274,48 @@ protected:
* once writing + flushing is complete. This protects against more
* classes of software/hardware errors than nsAtomicFileOutputStream,
* at the expense of being more costly to the disk, OS and battery.
*/
class nsSafeFileOutputStream : public nsAtomicFileOutputStream
{
public:
- NS_IMETHOD Finish();
+ NS_IMETHOD Finish() MOZ_OVERRIDE;
};
////////////////////////////////////////////////////////////////////////////////
class nsFileStream : public nsFileStreamBase,
public nsIInputStream,
public nsIOutputStream,
public nsIFileStream
{
public:
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_NSIFILESTREAM
NS_FORWARD_NSIINPUTSTREAM(nsFileStreamBase::)
// Can't use NS_FORWARD_NSIOUTPUTSTREAM due to overlapping methods
// Close() and IsNonBlocking()
- NS_IMETHOD Flush()
+ NS_IMETHOD Flush() MOZ_OVERRIDE
{
return nsFileStreamBase::Flush();
}
- NS_IMETHOD Write(const char* aBuf, uint32_t aCount, uint32_t* _retval)
+ NS_IMETHOD Write(const char* aBuf, uint32_t aCount, uint32_t* _retval) MOZ_OVERRIDE
{
return nsFileStreamBase::Write(aBuf, aCount, _retval);
}
NS_IMETHOD WriteFrom(nsIInputStream* aFromStream, uint32_t aCount,
- uint32_t* _retval)
+ uint32_t* _retval) MOZ_OVERRIDE
{
return nsFileStreamBase::WriteFrom(aFromStream, aCount, _retval);
}
NS_IMETHOD WriteSegments(nsReadSegmentFun aReader, void* aClosure,
- uint32_t aCount, uint32_t* _retval)
+ uint32_t aCount, uint32_t* _retval) MOZ_OVERRIDE
{
return nsFileStreamBase::WriteSegments(aReader, aClosure, aCount,
_retval);
}
protected:
virtual ~nsFileStream()
{
--- a/netwerk/base/src/nsIOService.h
+++ b/netwerk/base/src/nsIOService.h
@@ -169,23 +169,23 @@ class nsAppOfflineInfo : public nsIAppOf
{
NS_DECL_THREADSAFE_ISUPPORTS
public:
nsAppOfflineInfo(uint32_t aAppId, int32_t aMode)
: mAppId(aAppId), mMode(aMode)
{
}
- NS_IMETHODIMP GetMode(int32_t *aMode)
+ NS_IMETHODIMP GetMode(int32_t *aMode) MOZ_OVERRIDE
{
*aMode = mMode;
return NS_OK;
}
- NS_IMETHODIMP GetAppId(uint32_t *aAppId)
+ NS_IMETHODIMP GetAppId(uint32_t *aAppId) MOZ_OVERRIDE
{
*aAppId = mAppId;
return NS_OK;
}
private:
virtual ~nsAppOfflineInfo() {}
--- a/netwerk/base/src/nsInputStreamChannel.h
+++ b/netwerk/base/src/nsInputStreamChannel.h
@@ -20,17 +20,17 @@ public:
nsInputStreamChannel() :
mIsSrcdocChannel(false) {}
protected:
virtual ~nsInputStreamChannel() {}
virtual nsresult OpenContentStream(bool async, nsIInputStream **result,
- nsIChannel** channel);
+ nsIChannel** channel) MOZ_OVERRIDE;
virtual void OnChannelDone() MOZ_OVERRIDE {
mContentStream = nullptr;
}
private:
nsCOMPtr<nsIInputStream> mContentStream;
nsString mSrcdocData;
--- a/netwerk/base/src/nsProtocolProxyService.cpp
+++ b/netwerk/base/src/nsProtocolProxyService.cpp
@@ -131,24 +131,24 @@ private:
public:
void SetResult(nsresult status, nsIProxyInfo *pi)
{
mStatus = status;
mProxyInfo = pi;
}
- NS_IMETHOD Run()
+ NS_IMETHOD Run() MOZ_OVERRIDE
{
if (mCallback)
DoCallback();
return NS_OK;
}
- NS_IMETHOD Cancel(nsresult reason)
+ NS_IMETHOD Cancel(nsresult reason) MOZ_OVERRIDE
{
NS_ENSURE_ARG(NS_FAILED(reason));
// If we've already called DoCallback then, nothing more to do.
if (!mCallback)
return NS_OK;
SetResult(reason, nullptr);
@@ -173,17 +173,17 @@ public:
}
private:
// Called asynchronously, so we do not need to post another PLEvent
// before calling DoCallback.
void OnQueryComplete(nsresult status,
const nsCString &pacString,
- const nsCString &newPACURL)
+ const nsCString &newPACURL) MOZ_OVERRIDE
{
// If we've already called DoCallback then, nothing more to do.
if (!mCallback)
return;
// Provided we haven't been canceled...
if (mStatus == NS_OK) {
mStatus = status;
@@ -1062,17 +1062,17 @@ class nsAsyncBridgeRequest MOZ_FINAL :
: mMutex("nsDeprecatedCallback")
, mCondVar(mMutex, "nsDeprecatedCallback")
, mCompleted(false)
{
}
void OnQueryComplete(nsresult status,
const nsCString &pacString,
- const nsCString &newPACURL)
+ const nsCString &newPACURL) MOZ_OVERRIDE
{
MutexAutoLock lock(mMutex);
mCompleted = true;
mStatus = status;
mPACString = pacString;
mPACURL = newPACURL;
mCondVar.Notify();
}
--- a/netwerk/base/src/nsServerSocket.h
+++ b/netwerk/base/src/nsServerSocket.h
@@ -21,23 +21,23 @@ union NetAddr;
class nsServerSocket : public nsASocketHandler
, public nsIServerSocket
{
public:
NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSISERVERSOCKET
// nsASocketHandler methods:
- virtual void OnSocketReady(PRFileDesc *fd, int16_t outFlags);
- virtual void OnSocketDetached(PRFileDesc *fd);
- virtual void IsLocal(bool *aIsLocal);
- virtual void KeepWhenOffline(bool *aKeepWhenOffline);
+ virtual void OnSocketReady(PRFileDesc *fd, int16_t outFlags) MOZ_OVERRIDE;
+ virtual void OnSocketDetached(PRFileDesc *fd) MOZ_OVERRIDE;
+ virtual void IsLocal(bool *aIsLocal) MOZ_OVERRIDE;
+ virtual void KeepWhenOffline(bool *aKeepWhenOffline) MOZ_OVERRIDE;
- virtual uint64_t ByteCountSent() { return 0; }
- virtual uint64_t ByteCountReceived() { return 0; }
+ virtual uint64_t ByteCountSent() MOZ_OVERRIDE { return 0; }
+ virtual uint64_t ByteCountReceived() MOZ_OVERRIDE { return 0; }
nsServerSocket();
virtual void CreateClientTransport(PRFileDesc* clientFD,
const mozilla::net::NetAddr& clientAddr);
virtual nsresult SetSocketDefaults() { return NS_OK; }
virtual nsresult OnSocketListen() { return NS_OK; }
protected:
--- a/netwerk/base/src/nsSimpleNestedURI.h
+++ b/netwerk/base/src/nsSimpleNestedURI.h
@@ -40,24 +40,24 @@ public:
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_NSINESTEDURI
// Overrides for various methods nsSimpleURI implements follow.
// nsSimpleURI overrides
virtual nsresult EqualsInternal(nsIURI* other,
RefHandlingEnum refHandlingMode,
- bool* result);
- virtual nsSimpleURI* StartClone(RefHandlingEnum refHandlingMode);
+ bool* result) MOZ_OVERRIDE;
+ virtual nsSimpleURI* StartClone(RefHandlingEnum refHandlingMode) MOZ_OVERRIDE;
// nsISerializable overrides
- NS_IMETHOD Read(nsIObjectInputStream* aStream);
- NS_IMETHOD Write(nsIObjectOutputStream* aStream);
+ NS_IMETHOD Read(nsIObjectInputStream* aStream) MOZ_OVERRIDE;
+ NS_IMETHOD Write(nsIObjectOutputStream* aStream) MOZ_OVERRIDE;
// Override the nsIClassInfo method GetClassIDNoAlloc to make sure our
// nsISerializable impl works right.
- NS_IMETHOD GetClassIDNoAlloc(nsCID *aClassIDNoAlloc);
+ NS_IMETHOD GetClassIDNoAlloc(nsCID *aClassIDNoAlloc) MOZ_OVERRIDE;
protected:
nsCOMPtr<nsIURI> mInnerURI;
};
#endif /* nsSimpleNestedURI_h__ */
--- a/netwerk/base/src/nsSimpleURI.h
+++ b/netwerk/base/src/nsSimpleURI.h
@@ -47,18 +47,18 @@ public:
// nsISizeOf
// Among the sub-classes that inherit (directly or indirectly) from
// nsSimpleURI, measurement of the following members may be added later if
// DMD finds it is worthwhile:
// - nsJSURI: mBaseURI
// - nsSimpleNestedURI: mInnerURI
// - nsBlobURI: mPrincipal
- virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
- virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+ virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE;
+ virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE;
protected:
// enum used in a few places to specify how .ref attribute should be handled
enum RefHandlingEnum {
eIgnoreRef,
eHonorRef
};
--- a/netwerk/base/src/nsSocketTransport2.h
+++ b/netwerk/base/src/nsSocketTransport2.h
@@ -138,26 +138,26 @@ public:
nsISupports* aSecInfo);
// This method instructs the socket transport to open a socket
// connected to the given Unix domain address. We can only create
// unlayered, simple, stream sockets.
nsresult InitWithFilename(const char *filename);
// nsASocketHandler methods:
- void OnSocketReady(PRFileDesc *, int16_t outFlags);
- void OnSocketDetached(PRFileDesc *);
- void IsLocal(bool *aIsLocal);
+ void OnSocketReady(PRFileDesc *, int16_t outFlags) MOZ_OVERRIDE;
+ void OnSocketDetached(PRFileDesc *) MOZ_OVERRIDE;
+ void IsLocal(bool *aIsLocal) MOZ_OVERRIDE;
void OnKeepaliveEnabledPrefChange(bool aEnabled) MOZ_OVERRIDE MOZ_FINAL;
// called when a socket event is handled
void OnSocketEvent(uint32_t type, nsresult status, nsISupports *param);
- uint64_t ByteCountReceived() { return mInput.ByteCount(); }
- uint64_t ByteCountSent() { return mOutput.ByteCount(); }
+ uint64_t ByteCountReceived() MOZ_OVERRIDE { return mInput.ByteCount(); }
+ uint64_t ByteCountSent() MOZ_OVERRIDE { return mOutput.ByteCount(); }
protected:
virtual ~nsSocketTransport();
void CleanupTypes();
private:
// event types
--- a/netwerk/base/src/nsStandardURL.h
+++ b/netwerk/base/src/nsStandardURL.h
@@ -53,18 +53,18 @@ public:
NS_DECL_NSIFILEURL
NS_DECL_NSISTANDARDURL
NS_DECL_NSISERIALIZABLE
NS_DECL_NSICLASSINFO
NS_DECL_NSIMUTABLE
NS_DECL_NSIIPCSERIALIZABLEURI
// nsISizeOf
- virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
- virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+ virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE;
+ virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE;
explicit nsStandardURL(bool aSupportsFileURL = false, bool aTrackURL = true);
static void InitGlobalObjects();
static void ShutdownGlobalObjects();
public: /* internal -- HPUX compiler can't handle this being private */
//
--- a/netwerk/base/src/nsUDPSocket.h
+++ b/netwerk/base/src/nsUDPSocket.h
@@ -17,22 +17,22 @@
class nsUDPSocket MOZ_FINAL : public nsASocketHandler
, public nsIUDPSocket
{
public:
NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIUDPSOCKET
// nsASocketHandler methods:
- virtual void OnSocketReady(PRFileDesc* fd, int16_t outFlags);
- virtual void OnSocketDetached(PRFileDesc* fd);
- virtual void IsLocal(bool* aIsLocal);
+ virtual void OnSocketReady(PRFileDesc* fd, int16_t outFlags) MOZ_OVERRIDE;
+ virtual void OnSocketDetached(PRFileDesc* fd) MOZ_OVERRIDE;
+ virtual void IsLocal(bool* aIsLocal) MOZ_OVERRIDE;
- uint64_t ByteCountSent() { return mByteWriteCount; }
- uint64_t ByteCountReceived() { return mByteReadCount; }
+ uint64_t ByteCountSent() MOZ_OVERRIDE { return mByteWriteCount; }
+ uint64_t ByteCountReceived() MOZ_OVERRIDE { return mByteReadCount; }
void AddOutputBytes(uint64_t aBytes);
nsUDPSocket();
private:
virtual ~nsUDPSocket();
--- a/netwerk/base/src/nsURLParsers.h
+++ b/netwerk/base/src/nsURLParsers.h
@@ -46,28 +46,28 @@ class nsNoAuthURLParser MOZ_FINAL : publ
public:
NS_DECL_THREADSAFE_ISUPPORTS
#if defined(XP_WIN)
NS_IMETHOD ParseFilePath(const char *, int32_t,
uint32_t *, int32_t *,
uint32_t *, int32_t *,
- uint32_t *, int32_t *);
+ uint32_t *, int32_t *) MOZ_OVERRIDE;
#endif
NS_IMETHOD ParseAuthority(const char *auth, int32_t authLen,
uint32_t *usernamePos, int32_t *usernameLen,
uint32_t *passwordPos, int32_t *passwordLen,
uint32_t *hostnamePos, int32_t *hostnameLen,
- int32_t *port);
+ int32_t *port) MOZ_OVERRIDE;
void ParseAfterScheme(const char *spec, int32_t specLen,
uint32_t *authPos, int32_t *authLen,
- uint32_t *pathPos, int32_t *pathLen);
+ uint32_t *pathPos, int32_t *pathLen) MOZ_OVERRIDE;
};
//----------------------------------------------------------------------------
// an url parser for urls that must have an authority section
//
// eg. http:www.foo.com/bar.html
// http:/www.foo.com/bar.html
// http://www.foo.com/bar.html (treated equivalently)
@@ -81,29 +81,29 @@ protected:
public:
NS_DECL_THREADSAFE_ISUPPORTS
NS_IMETHOD ParseAuthority(const char *auth, int32_t authLen,
uint32_t *usernamePos, int32_t *usernameLen,
uint32_t *passwordPos, int32_t *passwordLen,
uint32_t *hostnamePos, int32_t *hostnameLen,
- int32_t *port);
+ int32_t *port) MOZ_OVERRIDE;
NS_IMETHOD ParseUserInfo(const char *userinfo, int32_t userinfoLen,
uint32_t *usernamePos, int32_t *usernameLen,
- uint32_t *passwordPos, int32_t *passwordLen);
+ uint32_t *passwordPos, int32_t *passwordLen) MOZ_OVERRIDE;
NS_IMETHOD ParseServerInfo(const char *serverinfo, int32_t serverinfoLen,
uint32_t *hostnamePos, int32_t *hostnameLen,
- int32_t *port);
+ int32_t *port) MOZ_OVERRIDE;
void ParseAfterScheme(const char *spec, int32_t specLen,
uint32_t *authPos, int32_t *authLen,
- uint32_t *pathPos, int32_t *pathLen);
+ uint32_t *pathPos, int32_t *pathLen) MOZ_OVERRIDE;
};
//----------------------------------------------------------------------------
// an url parser for urls that may or may not have an authority section
//
// eg. http:www.foo.com (www.foo.com is authority)
// http:www.foo.com/bar.html (www.foo.com is authority)
// http:/www.foo.com/bar.html (www.foo.com is part of file path)
--- a/netwerk/cache/nsApplicationCacheService.cpp
+++ b/netwerk/cache/nsApplicationCacheService.cpp
@@ -208,17 +208,17 @@ nsApplicationCacheService::GetGroupsTime
namespace {
class AppCacheClearDataObserver MOZ_FINAL : public nsIObserver {
public:
NS_DECL_ISUPPORTS
// nsIObserver implementation.
NS_IMETHODIMP
- Observe(nsISupports *aSubject, const char *aTopic, const char16_t *aData)
+ Observe(nsISupports *aSubject, const char *aTopic, const char16_t *aData) MOZ_OVERRIDE
{
MOZ_ASSERT(!nsCRT::strcmp(aTopic, TOPIC_WEB_APP_CLEAR_DATA));
uint32_t appId = NECKO_UNKNOWN_APP_ID;
bool browserOnly = false;
nsresult rv = NS_GetAppInfoFromClearDataNotification(aSubject, &appId,
&browserOnly);
NS_ENSURE_SUCCESS(rv, rv);
--- a/netwerk/cache/nsCacheEntryDescriptor.h
+++ b/netwerk/cache/nsCacheEntryDescriptor.h
@@ -123,18 +123,18 @@ private:
uint32_t off)
: nsInputStreamWrapper(desc, off)
, mReadBuffer(0)
, mReadBufferLen(0)
, mStreamInitialized(false)
, mStreamEnded(false)
{
}
- NS_IMETHOD Read(char* buf, uint32_t count, uint32_t * result);
- NS_IMETHOD Close();
+ NS_IMETHOD Read(char* buf, uint32_t count, uint32_t * result) MOZ_OVERRIDE;
+ NS_IMETHOD Close() MOZ_OVERRIDE;
private:
virtual ~nsDecompressInputStreamWrapper()
{
Close();
}
nsresult InitZstream();
nsresult EndZstream();
};
@@ -204,18 +204,18 @@ private:
: nsOutputStreamWrapper(desc, off)
, mWriteBuffer(0)
, mWriteBufferLen(0)
, mStreamInitialized(false)
, mStreamEnded(false)
, mUncompressedCount(0)
{
}
- NS_IMETHOD Write(const char* buf, uint32_t count, uint32_t * result);
- NS_IMETHOD Close();
+ NS_IMETHOD Write(const char* buf, uint32_t count, uint32_t * result) MOZ_OVERRIDE;
+ NS_IMETHOD Close() MOZ_OVERRIDE;
private:
virtual ~nsCompressOutputStreamWrapper()
{
Close();
}
nsresult InitZstream();
nsresult WriteBuffer();
};
--- a/netwerk/cache/nsCacheService.cpp
+++ b/netwerk/cache/nsCacheService.cpp
@@ -205,17 +205,17 @@ NS_IMPL_ISUPPORTS(nsCacheProfilePrefObse
class nsSetDiskSmartSizeCallback MOZ_FINAL : public nsITimerCallback
{
~nsSetDiskSmartSizeCallback() {}
public:
NS_DECL_THREADSAFE_ISUPPORTS
- NS_IMETHOD Notify(nsITimer* aTimer) {
+ NS_IMETHOD Notify(nsITimer* aTimer) MOZ_OVERRIDE {
if (nsCacheService::gService) {
nsCacheServiceAutoLock autoLock(LOCK_TELEM(NSSETDISKSMARTSIZECALLBACK_NOTIFY));
nsCacheService::gService->SetDiskSmartSize_Locked();
nsCacheService::gService->mSmartSizeTimer = nullptr;
}
return NS_OK;
}
};
--- a/netwerk/cache/nsDiskCacheDeviceSQL.h
+++ b/netwerk/cache/nsDiskCacheDeviceSQL.h
@@ -69,44 +69,44 @@ public:
nsOfflineCacheDevice();
NS_DECL_THREADSAFE_ISUPPORTS
/**
* nsCacheDevice methods
*/
- virtual nsresult Init();
+ virtual nsresult Init() MOZ_OVERRIDE;
nsresult InitWithSqlite(mozIStorageService * ss);
- virtual nsresult Shutdown();
+ virtual nsresult Shutdown() MOZ_OVERRIDE;
- virtual const char * GetDeviceID(void);
- virtual nsCacheEntry * FindEntry(nsCString * key, bool *collision);
- virtual nsresult DeactivateEntry(nsCacheEntry * entry);
- virtual nsresult BindEntry(nsCacheEntry * entry);
- virtual void DoomEntry( nsCacheEntry * entry );
+ virtual const char * GetDeviceID(void) MOZ_OVERRIDE;
+ virtual nsCacheEntry * FindEntry(nsCString * key, bool *collision) MOZ_OVERRIDE;
+ virtual nsresult DeactivateEntry(nsCacheEntry * entry) MOZ_OVERRIDE;
+ virtual nsresult BindEntry(nsCacheEntry * entry) MOZ_OVERRIDE;
+ virtual void DoomEntry( nsCacheEntry * entry ) MOZ_OVERRIDE;
virtual nsresult OpenInputStreamForEntry(nsCacheEntry * entry,
nsCacheAccessMode mode,
uint32_t offset,
- nsIInputStream ** result);
+ nsIInputStream ** result) MOZ_OVERRIDE;
virtual nsresult OpenOutputStreamForEntry(nsCacheEntry * entry,
nsCacheAccessMode mode,
uint32_t offset,
- nsIOutputStream ** result);
+ nsIOutputStream ** result) MOZ_OVERRIDE;
virtual nsresult GetFileForEntry(nsCacheEntry * entry,
- nsIFile ** result);
+ nsIFile ** result) MOZ_OVERRIDE;
- virtual nsresult OnDataSizeChange(nsCacheEntry * entry, int32_t deltaSize);
+ virtual nsresult OnDataSizeChange(nsCacheEntry * entry, int32_t deltaSize) MOZ_OVERRIDE;
- virtual nsresult Visit(nsICacheVisitor * visitor);
+ virtual nsresult Visit(nsICacheVisitor * visitor) MOZ_OVERRIDE;
- virtual nsresult EvictEntries(const char * clientID);
+ virtual nsresult EvictEntries(const char * clientID) MOZ_OVERRIDE;
/* Entry ownership */
nsresult GetOwnerDomains(const char * clientID,
uint32_t * count,
char *** domains);
nsresult GetOwnerURIs(const char * clientID,
const nsACString & ownerDomain,
uint32_t * count,
--- a/netwerk/cache2/CacheEntry.h
+++ b/netwerk/cache2/CacheEntry.h
@@ -118,18 +118,18 @@ public:
// Memory reporting
size_t SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
private:
virtual ~CacheEntry();
// CacheFileListener
- NS_IMETHOD OnFileReady(nsresult aResult, bool aIsNew);
- NS_IMETHOD OnFileDoomed(nsresult aResult);
+ NS_IMETHOD OnFileReady(nsresult aResult, bool aIsNew) MOZ_OVERRIDE;
+ NS_IMETHOD OnFileDoomed(nsresult aResult) MOZ_OVERRIDE;
// Keep the service alive during life-time of an entry
nsRefPtr<CacheStorageService> mService;
// We must monitor when a cache entry whose consumer is responsible
// for writing it the first time gets released. We must then invoke
// waiting callbacks to not break the chain.
class Callback
--- a/netwerk/cache2/CacheFile.cpp
+++ b/netwerk/cache2/CacheFile.cpp
@@ -112,49 +112,49 @@ public:
explicit DoomFileHelper(CacheFileListener *aListener)
: mListener(aListener)
{
MOZ_COUNT_CTOR(DoomFileHelper);
}
- NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult)
+ NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE
{
MOZ_CRASH("DoomFileHelper::OnFileOpened should not be called!");
return NS_ERROR_UNEXPECTED;
}
NS_IMETHOD OnDataWritten(CacheFileHandle *aHandle, const char *aBuf,
- nsresult aResult)
+ nsresult aResult) MOZ_OVERRIDE
{
MOZ_CRASH("DoomFileHelper::OnDataWritten should not be called!");
return NS_ERROR_UNEXPECTED;
}
- NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf, nsresult aResult)
+ NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf, nsresult aResult) MOZ_OVERRIDE
{
MOZ_CRASH("DoomFileHelper::OnDataRead should not be called!");
return NS_ERROR_UNEXPECTED;
}
- NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult)
+ NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE
{
if (mListener)
mListener->OnFileDoomed(aResult);
return NS_OK;
}
- NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult)
+ NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE
{
MOZ_CRASH("DoomFileHelper::OnEOFSet should not be called!");
return NS_ERROR_UNEXPECTED;
}
- NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult)
+ NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE
{
MOZ_CRASH("DoomFileHelper::OnFileRenamed should not be called!");
return NS_ERROR_UNEXPECTED;
}
private:
virtual ~DoomFileHelper()
{
--- a/netwerk/cache2/CacheFile.h
+++ b/netwerk/cache2/CacheFile.h
@@ -54,32 +54,32 @@ public:
CacheFile();
nsresult Init(const nsACString &aKey,
bool aCreateNew,
bool aMemoryOnly,
bool aPriority,
CacheFileListener *aCallback);
- NS_IMETHOD OnChunkRead(nsresult aResult, CacheFileChunk *aChunk);
- NS_IMETHOD OnChunkWritten(nsresult aResult, CacheFileChunk *aChunk);
+ NS_IMETHOD OnChunkRead(nsresult aResult, CacheFileChunk *aChunk) MOZ_OVERRIDE;
+ NS_IMETHOD OnChunkWritten(nsresult aResult, CacheFileChunk *aChunk) MOZ_OVERRIDE;
NS_IMETHOD OnChunkAvailable(nsresult aResult, uint32_t aChunkIdx,
- CacheFileChunk *aChunk);
- NS_IMETHOD OnChunkUpdated(CacheFileChunk *aChunk);
+ CacheFileChunk *aChunk) MOZ_OVERRIDE;
+ NS_IMETHOD OnChunkUpdated(CacheFileChunk *aChunk) MOZ_OVERRIDE;
- NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult);
+ NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnDataWritten(CacheFileHandle *aHandle, const char *aBuf,
- nsresult aResult);
- NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf, nsresult aResult);
- NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult);
- NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult);
- NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult);
+ nsresult aResult) MOZ_OVERRIDE;
+ NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf, nsresult aResult) MOZ_OVERRIDE;
+ NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
+ NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
+ NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
- NS_IMETHOD OnMetadataRead(nsresult aResult);
- NS_IMETHOD OnMetadataWritten(nsresult aResult);
+ NS_IMETHOD OnMetadataRead(nsresult aResult) MOZ_OVERRIDE;
+ NS_IMETHOD OnMetadataWritten(nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OpenInputStream(nsIInputStream **_retval);
NS_IMETHOD OpenOutputStream(CacheOutputCloseListener *aCloseListener, nsIOutputStream **_retval);
NS_IMETHOD SetMemoryOnly();
NS_IMETHOD Doom(CacheFileListener *aCallback);
nsresult ThrowMemoryCachedData();
--- a/netwerk/cache2/CacheFileChunk.h
+++ b/netwerk/cache2/CacheFileChunk.h
@@ -82,23 +82,23 @@ public:
nsresult NotifyUpdateListeners();
uint32_t Index();
CacheHash::Hash16_t Hash();
uint32_t DataSize();
void UpdateDataSize(uint32_t aOffset, uint32_t aLen,
bool aEOF);
- NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult);
+ NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnDataWritten(CacheFileHandle *aHandle, const char *aBuf,
- nsresult aResult);
- NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf, nsresult aResult);
- NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult);
- NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult);
- NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult);
+ nsresult aResult) MOZ_OVERRIDE;
+ NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf, nsresult aResult) MOZ_OVERRIDE;
+ NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
+ NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
+ NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
bool IsReady() const;
bool IsDirty() const;
nsresult GetStatus();
void SetError(nsresult aStatus);
char * BufForWriting() const;
--- a/netwerk/cache2/CacheFileInputStream.h
+++ b/netwerk/cache2/CacheFileInputStream.h
@@ -24,21 +24,21 @@ class CacheFileInputStream : public nsIA
NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIINPUTSTREAM
NS_DECL_NSIASYNCINPUTSTREAM
NS_DECL_NSISEEKABLESTREAM
public:
explicit CacheFileInputStream(CacheFile *aFile);
- NS_IMETHOD OnChunkRead(nsresult aResult, CacheFileChunk *aChunk);
- NS_IMETHOD OnChunkWritten(nsresult aResult, CacheFileChunk *aChunk);
+ NS_IMETHOD OnChunkRead(nsresult aResult, CacheFileChunk *aChunk) MOZ_OVERRIDE;
+ NS_IMETHOD OnChunkWritten(nsresult aResult, CacheFileChunk *aChunk) MOZ_OVERRIDE;
NS_IMETHOD OnChunkAvailable(nsresult aResult, uint32_t aChunkIdx,
- CacheFileChunk *aChunk);
- NS_IMETHOD OnChunkUpdated(CacheFileChunk *aChunk);
+ CacheFileChunk *aChunk) MOZ_OVERRIDE;
+ NS_IMETHOD OnChunkUpdated(CacheFileChunk *aChunk) MOZ_OVERRIDE;
// Memory reporting
size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
uint32_t GetPosition() const { return mPos; };
private:
virtual ~CacheFileInputStream();
--- a/netwerk/cache2/CacheFileMetadata.h
+++ b/netwerk/cache2/CacheFileMetadata.h
@@ -148,23 +148,23 @@ public:
nsresult OnFetched();
int64_t Offset() { return mOffset; }
uint32_t ElementsSize() { return mElementsSize; }
void MarkDirty(bool aUpdateLastModified = true);
bool IsDirty() { return mIsDirty; }
uint32_t MemoryUsage() { return sizeof(CacheFileMetadata) + mHashArraySize + mBufSize; }
- NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult);
+ NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnDataWritten(CacheFileHandle *aHandle, const char *aBuf,
- nsresult aResult);
- NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf, nsresult aResult);
- NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult);
- NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult);
- NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult);
+ nsresult aResult) MOZ_OVERRIDE;
+ NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf, nsresult aResult) MOZ_OVERRIDE;
+ NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
+ NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
+ NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
// Memory reporting
size_t SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
private:
virtual ~CacheFileMetadata();
--- a/netwerk/cache2/CacheFileOutputStream.h
+++ b/netwerk/cache2/CacheFileOutputStream.h
@@ -25,21 +25,21 @@ class CacheFileOutputStream : public nsI
NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIOUTPUTSTREAM
NS_DECL_NSIASYNCOUTPUTSTREAM
NS_DECL_NSISEEKABLESTREAM
public:
CacheFileOutputStream(CacheFile *aFile, CacheOutputCloseListener *aCloseListener);
- NS_IMETHOD OnChunkRead(nsresult aResult, CacheFileChunk *aChunk);
- NS_IMETHOD OnChunkWritten(nsresult aResult, CacheFileChunk *aChunk);
+ NS_IMETHOD OnChunkRead(nsresult aResult, CacheFileChunk *aChunk) MOZ_OVERRIDE;
+ NS_IMETHOD OnChunkWritten(nsresult aResult, CacheFileChunk *aChunk) MOZ_OVERRIDE;
NS_IMETHOD OnChunkAvailable(nsresult aResult, uint32_t aChunkIdx,
- CacheFileChunk *aChunk);
- NS_IMETHOD OnChunkUpdated(CacheFileChunk *aChunk);
+ CacheFileChunk *aChunk) MOZ_OVERRIDE;
+ NS_IMETHOD OnChunkUpdated(CacheFileChunk *aChunk) MOZ_OVERRIDE;
void NotifyCloseListener();
// Memory reporting
size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
private:
virtual ~CacheFileOutputStream();
--- a/netwerk/cache2/CacheIndex.cpp
+++ b/netwerk/cache2/CacheIndex.cpp
@@ -174,36 +174,36 @@ public:
void Cancel() {
mIndex->AssertOwnsLock();
mCanceled = true;
}
private:
virtual ~FileOpenHelper() {}
- NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult);
+ NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
NS_IMETHOD OnDataWritten(CacheFileHandle *aHandle, const char *aBuf,
- nsresult aResult) {
+ nsresult aResult) MOZ_OVERRIDE {
MOZ_CRASH("FileOpenHelper::OnDataWritten should not be called!");
return NS_ERROR_UNEXPECTED;
}
NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf,
- nsresult aResult) {
+ nsresult aResult) MOZ_OVERRIDE {
MOZ_CRASH("FileOpenHelper::OnDataRead should not be called!");
return NS_ERROR_UNEXPECTED;
}
- NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult) {
+ NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE {
MOZ_CRASH("FileOpenHelper::OnFileDoomed should not be called!");
return NS_ERROR_UNEXPECTED;
}
- NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult) {
+ NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE {
MOZ_CRASH("FileOpenHelper::OnEOFSet should not be called!");
return NS_ERROR_UNEXPECTED;
}
- NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult) {
+ NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE {
MOZ_CRASH("FileOpenHelper::OnFileRenamed should not be called!");
return NS_ERROR_UNEXPECTED;
}
nsRefPtr<CacheIndex> mIndex;
bool mCanceled;
};
--- a/netwerk/cache2/CacheIndex.h
+++ b/netwerk/cache2/CacheIndex.h
@@ -678,25 +678,25 @@ private:
friend class CacheIndexEntryAutoManage;
friend class CacheIndexAutoLock;
friend class CacheIndexAutoUnlock;
friend class FileOpenHelper;
friend class CacheIndexIterator;
virtual ~CacheIndex();
- NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult);
+ NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
nsresult OnFileOpenedInternal(FileOpenHelper *aOpener,
CacheFileHandle *aHandle, nsresult aResult);
NS_IMETHOD OnDataWritten(CacheFileHandle *aHandle, const char *aBuf,
- nsresult aResult);
- NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf, nsresult aResult);
- NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult);
- NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult);
- NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult);
+ nsresult aResult) MOZ_OVERRIDE;
+ NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf, nsresult aResult) MOZ_OVERRIDE;
+ NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
+ NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
+ NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
void Lock();
void Unlock();
void AssertOwnsLock();
nsresult InitInternal(nsIFile *aCacheDirectory);
void PreShutdownInternal();
--- a/netwerk/cache2/CacheStorageService.cpp
+++ b/netwerk/cache2/CacheStorageService.cpp
@@ -1501,22 +1501,22 @@ public:
NS_DECL_NSIRUNNABLE
explicit CacheEntryDoomByKeyCallback(nsICacheEntryDoomCallback* aCallback)
: mCallback(aCallback) { }
private:
virtual ~CacheEntryDoomByKeyCallback();
- NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult) { return NS_OK; }
- NS_IMETHOD OnDataWritten(CacheFileHandle *aHandle, const char *aBuf, nsresult aResult) { return NS_OK; }
- NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf, nsresult aResult) { return NS_OK; }
- NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult);
- NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult) { return NS_OK; }
- NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult) { return NS_OK; }
+ NS_IMETHOD OnFileOpened(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE { return NS_OK; }
+ NS_IMETHOD OnDataWritten(CacheFileHandle *aHandle, const char *aBuf, nsresult aResult) MOZ_OVERRIDE { return NS_OK; }
+ NS_IMETHOD OnDataRead(CacheFileHandle *aHandle, char *aBuf, nsresult aResult) MOZ_OVERRIDE { return NS_OK; }
+ NS_IMETHOD OnFileDoomed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE;
+ NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE { return NS_OK; }
+ NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult) MOZ_OVERRIDE { return NS_OK; }
nsCOMPtr<nsICacheEntryDoomCallback> mCallback;
nsresult mResult;
};
CacheEntryDoomByKeyCallback::~CacheEntryDoomByKeyCallback()
{
if (mCallback)
--- a/netwerk/cache2/OldWrappers.h
+++ b/netwerk/cache2/OldWrappers.h
@@ -25,182 +25,111 @@ namespace mozilla { namespace net {
class CacheStorage;
class _OldCacheEntryWrapper : public nsICacheEntry
{
public:
NS_DECL_THREADSAFE_ISUPPORTS
// nsICacheEntryDescriptor
- NS_IMETHOD SetExpirationTime(uint32_t expirationTime)
+ NS_IMETHOD SetExpirationTime(uint32_t expirationTime) MOZ_OVERRIDE
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->SetExpirationTime(expirationTime);
}
- NS_IMETHOD SetDataSize(uint32_t size)
- {
- return !mOldDesc ? NS_ERROR_NULL_POINTER :
- mOldDesc->SetDataSize(size);
- }
- NS_IMETHOD OpenInputStream(uint32_t offset, nsIInputStream * *_retval)
- {
- return !mOldDesc ? NS_ERROR_NULL_POINTER :
- mOldDesc->OpenInputStream(offset, _retval);
- }
- NS_IMETHOD OpenOutputStream(uint32_t offset, nsIOutputStream * *_retval)
- {
- return !mOldDesc ? NS_ERROR_NULL_POINTER :
- mOldDesc->OpenOutputStream(offset, _retval);
- }
- NS_IMETHOD GetCacheElement(nsISupports * *aCacheElement)
- {
- return !mOldDesc ? NS_ERROR_NULL_POINTER :
- mOldDesc->GetCacheElement(aCacheElement);
- }
- NS_IMETHOD SetCacheElement(nsISupports *aCacheElement)
- { return !mOldDesc ? NS_ERROR_NULL_POINTER :
- mOldDesc->SetCacheElement(aCacheElement);
- }
- NS_IMETHOD GetPredictedDataSize(int64_t *aPredictedDataSize)
+ NS_IMETHOD GetPredictedDataSize(int64_t *aPredictedDataSize) MOZ_OVERRIDE
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->GetPredictedDataSize(aPredictedDataSize);
}
- NS_IMETHOD SetPredictedDataSize(int64_t aPredictedDataSize)
+ NS_IMETHOD SetPredictedDataSize(int64_t aPredictedDataSize) MOZ_OVERRIDE
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->SetPredictedDataSize(aPredictedDataSize);
}
- NS_IMETHOD GetAccessGranted(nsCacheAccessMode *aAccessGranted)
- {
- return !mOldDesc ? NS_ERROR_NULL_POINTER :
- mOldDesc->GetAccessGranted(aAccessGranted);
- }
- NS_IMETHOD GetStoragePolicy(nsCacheStoragePolicy *aStoragePolicy)
- {
- return !mOldDesc ? NS_ERROR_NULL_POINTER :
- mOldDesc->GetStoragePolicy(aStoragePolicy);
- }
- NS_IMETHOD SetStoragePolicy(nsCacheStoragePolicy aStoragePolicy)
- {
- return !mOldDesc ? NS_ERROR_NULL_POINTER :
- mOldDesc->SetStoragePolicy(aStoragePolicy);
- }
- NS_IMETHOD GetFile(nsIFile * *aFile)
- {
- return !mOldDesc ? NS_ERROR_NULL_POINTER :
- mOldDesc->GetFile(aFile);
- }
- NS_IMETHOD GetSecurityInfo(nsISupports * *aSecurityInfo)
+ NS_IMETHOD GetSecurityInfo(nsISupports * *aSecurityInfo) MOZ_OVERRIDE
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->GetSecurityInfo(aSecurityInfo);
}
- NS_IMETHOD SetSecurityInfo(nsISupports *aSecurityInfo)
+ NS_IMETHOD SetSecurityInfo(nsISupports *aSecurityInfo) MOZ_OVERRIDE
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->SetSecurityInfo(aSecurityInfo);
}
- NS_IMETHOD GetStorageDataSize(uint32_t *aStorageDataSize)
+ NS_IMETHOD GetStorageDataSize(uint32_t *aStorageDataSize) MOZ_OVERRIDE
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->GetStorageDataSize(aStorageDataSize);
}
- NS_IMETHOD Doom(void)
- {
- return !mOldDesc ? NS_ERROR_NULL_POINTER :
- mOldDesc->Doom();
- }
- NS_IMETHOD DoomAndFailPendingRequests(nsresult status)
- {
- return !mOldDesc ? NS_ERROR_NULL_POINTER :
- mOldDesc->DoomAndFailPendingRequests(status);
- }
- NS_IMETHOD AsyncDoom(nsICacheListener *listener)
+ nsresult AsyncDoom(nsICacheListener *listener)
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->AsyncDoom(listener);
}
- NS_IMETHOD MarkValid(void)
+ NS_IMETHOD MarkValid(void) MOZ_OVERRIDE
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->MarkValid();
}
- NS_IMETHOD Close(void)
+ NS_IMETHOD Close(void) MOZ_OVERRIDE
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->Close();
}
- NS_IMETHOD GetMetaDataElement(const char * key, char * *_retval)
+ NS_IMETHOD GetMetaDataElement(const char * key, char * *_retval) MOZ_OVERRIDE
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->GetMetaDataElement(key, _retval);
}
- NS_IMETHOD SetMetaDataElement(const char * key, const char * value)
+ NS_IMETHOD SetMetaDataElement(const char * key, const char * value) MOZ_OVERRIDE
{
return !mOldDesc ? NS_ERROR_NULL_POINTER :
mOldDesc->SetMetaDataElement(key, value);
}
- NS_IMETHOD VisitMetaData(nsICacheMetaDataVisitor *visitor)
- {
- return !mOldDesc ? NS_ERROR_NULL_POINTER :
- mOldDesc->VisitMetaData(visitor);
- }
// nsICacheEntryInfo
- NS_IMETHOD GetClientID(char * *aClientID)
- {
- return mOldInfo->GetClientID(aClientID);
- }
- NS_IMETHOD GetDeviceID(char * *aDeviceID)
- {
- return mOldInfo->GetDeviceID(aDeviceID);
- }
- NS_IMETHOD GetKey(nsACString & aKey)
+ NS_IMETHOD GetKey(nsACString & aKey) MOZ_OVERRIDE
{
return mOldInfo->GetKey(aKey);
}
- NS_IMETHOD GetFetchCount(int32_t *aFetchCount)
+ NS_IMETHOD GetFetchCount(int32_t *aFetchCount) MOZ_OVERRIDE
{
return mOldInfo->GetFetchCount(aFetchCount);
}
- NS_IMETHOD GetLastFetched(uint32_t *aLastFetched)
+ NS_IMETHOD GetLastFetched(uint32_t *aLastFetched) MOZ_OVERRIDE
{
return mOldInfo->GetLastFetched(aLastFetched);
}
- NS_IMETHOD GetLastModified(uint32_t *aLastModified)
+ NS_IMETHOD GetLastModified(uint32_t *aLastModified) MOZ_OVERRIDE
{
return mOldInfo->GetLastModified(aLastModified);
}
- NS_IMETHOD GetExpirationTime(uint32_t *aExpirationTime)
+ NS_IMETHOD GetExpirationTime(uint32_t *aExpirationTime) MOZ_OVERRIDE
{
return mOldInfo->GetExpirationTime(aExpirationTime);
}
- NS_IMETHOD GetDataSize(uint32_t *aDataSize)
+ nsresult GetDataSize(uint32_t *aDataSize)
{
return mOldInfo->GetDataSize(aDataSize);
}
- NS_IMETHOD IsStreamBased(bool *_retval)
- {
- return mOldInfo->IsStreamBased(_retval);
- }
- NS_IMETHOD AsyncDoom(nsICacheEntryDoomCallback* listener);
- NS_IMETHOD GetPersistent(bool *aPersistToDisk);
- NS_IMETHOD GetIsForcedValid(bool *aIsForcedValid);
- NS_IMETHOD ForceValidFor(uint32_t aSecondsToTheFuture);
- NS_IMETHOD SetValid() { return NS_OK; }
- NS_IMETHOD MetaDataReady() { return NS_OK; }
- NS_IMETHOD Recreate(bool, nsICacheEntry**);
- NS_IMETHOD GetDataSize(int64_t *size);
- NS_IMETHOD OpenInputStream(int64_t offset, nsIInputStream * *_retval);
- NS_IMETHOD OpenOutputStream(int64_t offset, nsIOutputStream * *_retval);
- NS_IMETHOD MaybeMarkValid();
- NS_IMETHOD HasWriteAccess(bool aWriteOnly, bool *aWriteAccess);
- NS_IMETHOD VisitMetaData(nsICacheEntryMetaDataVisitor*);
+ NS_IMETHOD AsyncDoom(nsICacheEntryDoomCallback* listener) MOZ_OVERRIDE;
+ NS_IMETHOD GetPersistent(bool *aPersistToDisk) MOZ_OVERRIDE;
+ NS_IMETHOD GetIsForcedValid(bool *aIsForcedValid) MOZ_OVERRIDE;
+ NS_IMETHOD ForceValidFor(uint32_t aSecondsToTheFuture) MOZ_OVERRIDE;
+ NS_IMETHOD SetValid() MOZ_OVERRIDE { return NS_OK; }
+ NS_IMETHOD MetaDataReady() MOZ_OVERRIDE { return NS_OK; }
+ NS_IMETHOD Recreate(bool, nsICacheEntry**) MOZ_OVERRIDE;
+ NS_IMETHOD GetDataSize(int64_t *size) MOZ_OVERRIDE;
+ NS_IMETHOD OpenInputStream(int64_t offset, nsIInputStream * *_retval) MOZ_OVERRIDE;
+ NS_IMETHOD OpenOutputStream(int64_t offset, nsIOutputStream * *_retval) MOZ_OVERRIDE;
+ NS_IMETHOD MaybeMarkValid() MOZ_OVERRIDE;
+ NS_IMETHOD HasWriteAccess(bool aWriteOnly, bool *aWriteAccess) MOZ_OVERRIDE;
+ NS_IMETHOD VisitMetaData(nsICacheEntryMetaDataVisitor*) MOZ_OVERRIDE;
explicit _OldCacheEntryWrapper(nsICacheEntryDescriptor* desc);
explicit _OldCacheEntryWrapper(nsICacheEntryInfo* info);
private:
virtual ~_OldCacheEntryWrapper();
_OldCacheEntryWrapper() MOZ_DELETE;
--- a/netwerk/cookie/nsCookieService.cpp
+++ b/netwerk/cookie/nsCookieService.cpp
@@ -352,17 +352,17 @@ LogSuccess(bool aSetCookie, nsIURI *aHos
class DBListenerErrorHandler : public mozIStorageStatementCallback
{
protected:
explicit DBListenerErrorHandler(DBState* dbState) : mDBState(dbState) { }
nsRefPtr<DBState> mDBState;
virtual const char *GetOpType() = 0;
public:
- NS_IMETHOD HandleError(mozIStorageError* aError)
+ NS_IMETHOD HandleError(mozIStorageError* aError) MOZ_OVERRIDE
{
int32_t result = -1;
aError->GetResult(&result);
#ifdef PR_LOGGING
nsAutoCString message;
aError->GetMessage(message);
COOKIE_LOGSTRING(PR_LOG_WARNING,
@@ -380,30 +380,30 @@ public:
/******************************************************************************
* InsertCookieDBListener impl:
* mozIStorageStatementCallback used to track asynchronous insertion operations.
******************************************************************************/
class InsertCookieDBListener MOZ_FINAL : public DBListenerErrorHandler
{
private:
- virtual const char *GetOpType() { return "INSERT"; }
+ virtual const char *GetOpType() MOZ_OVERRIDE { return "INSERT"; }
~InsertCookieDBListener() {}
public:
NS_DECL_ISUPPORTS
explicit InsertCookieDBListener(DBState* dbState) : DBListenerErrorHandler(dbState) { }
- NS_IMETHOD HandleResult(mozIStorageResultSet*)
+ NS_IMETHOD HandleResult(mozIStorageResultSet*) MOZ_OVERRIDE
{
NS_NOTREACHED("Unexpected call to InsertCookieDBListener::HandleResult");
return NS_OK;
}
- NS_IMETHOD HandleCompletion(uint16_t aReason)
+ NS_IMETHOD HandleCompletion(uint16_t aReason) MOZ_OVERRIDE
{
// If we were rebuilding the db and we succeeded, make our corruptFlag say
// so.
if (mDBState->corruptFlag == DBState::REBUILDING &&
aReason == mozIStorageStatementCallback::REASON_FINISHED) {
COOKIE_LOGSTRING(PR_LOG_DEBUG,
("InsertCookieDBListener::HandleCompletion(): rebuild complete"));
mDBState->corruptFlag = DBState::OK;
@@ -416,89 +416,89 @@ NS_IMPL_ISUPPORTS(InsertCookieDBListener
/******************************************************************************
* UpdateCookieDBListener impl:
* mozIStorageStatementCallback used to track asynchronous update operations.
******************************************************************************/
class UpdateCookieDBListener MOZ_FINAL : public DBListenerErrorHandler
{
private:
- virtual const char *GetOpType() { return "UPDATE"; }
+ virtual const char *GetOpType() MOZ_OVERRIDE { return "UPDATE"; }
~UpdateCookieDBListener() {}
public:
NS_DECL_ISUPPORTS
explicit UpdateCookieDBListener(DBState* dbState) : DBListenerErrorHandler(dbState) { }
- NS_IMETHOD HandleResult(mozIStorageResultSet*)
+ NS_IMETHOD HandleResult(mozIStorageResultSet*) MOZ_OVERRIDE
{
NS_NOTREACHED("Unexpected call to UpdateCookieDBListener::HandleResult");
return NS_OK;
}
- NS_IMETHOD HandleCompletion(uint16_t aReason)
+ NS_IMETHOD HandleCompletion(uint16_t aReason) MOZ_OVERRIDE
{
return NS_OK;
}
};
NS_IMPL_ISUPPORTS(UpdateCookieDBListener, mozIStorageStatementCallback)
/******************************************************************************
* RemoveCookieDBListener impl:
* mozIStorageStatementCallback used to track asynchronous removal operations.
******************************************************************************/
class RemoveCookieDBListener MOZ_FINAL : public DBListenerErrorHandler
{
private:
- virtual const char *GetOpType() { return "REMOVE"; }
+ virtual const char *GetOpType() MOZ_OVERRIDE { return "REMOVE"; }
~RemoveCookieDBListener() {}
public:
NS_DECL_ISUPPORTS
explicit RemoveCookieDBListener(DBState* dbState) : DBListenerErrorHandler(dbState) { }
- NS_IMETHOD HandleResult(mozIStorageResultSet*)
+ NS_IMETHOD HandleResult(mozIStorageResultSet*) MOZ_OVERRIDE
{
NS_NOTREACHED("Unexpected call to RemoveCookieDBListener::HandleResult");
return NS_OK;
}
- NS_IMETHOD HandleCompletion(uint16_t aReason)
+ NS_IMETHOD HandleCompletion(uint16_t aReason) MOZ_OVERRIDE
{
return NS_OK;
}
};
NS_IMPL_ISUPPORTS(RemoveCookieDBListener, mozIStorageStatementCallback)
/******************************************************************************
* ReadCookieDBListener impl:
* mozIStorageStatementCallback used to track asynchronous removal operations.
******************************************************************************/
class ReadCookieDBListener MOZ_FINAL : public DBListenerErrorHandler
{
private:
- virtual const char *GetOpType() { return "READ"; }
+ virtual const char *GetOpType() MOZ_OVERRIDE { return "READ"; }
bool mCanceled;
~ReadCookieDBListener() {}
public:
NS_DECL_ISUPPORTS
explicit ReadCookieDBListener(DBState* dbState)
: DBListenerErrorHandler(dbState)
, mCanceled(false)
{
}
void Cancel() { mCanceled = true; }
- NS_IMETHOD HandleResult(mozIStorageResultSet *aResult)
+ NS_IMETHOD HandleResult(mozIStorageResultSet *aResult) MOZ_OVERRIDE
{
nsCOMPtr<mozIStorageRow> row;
while (1) {
DebugOnly<nsresult> rv = aResult->GetNextRow(getter_AddRefs(row));
NS_ASSERT_SUCCESS(rv);
if (!row)
@@ -508,17 +508,17 @@ public:
row->GetUTF8String(IDX_BASE_DOMAIN, tuple->key.mBaseDomain);
tuple->key.mAppId = static_cast<uint32_t>(row->AsInt32(IDX_APP_ID));
tuple->key.mInBrowserElement = static_cast<bool>(row->AsInt32(IDX_BROWSER_ELEM));
tuple->cookie = gCookieService->GetCookieFromRow(row);
}
return NS_OK;
}
- NS_IMETHOD HandleCompletion(uint16_t aReason)
+ NS_IMETHOD HandleCompletion(uint16_t aReason) MOZ_OVERRIDE
{
// Process the completion of the read operation. If we have been canceled,
// we cannot assume that the cookieservice still has an open connection
// or that it even refers to the same database, so we must return early.
// Conversely, the cookieservice guarantees that if we have not been
// canceled, the database connection is still alive and we can safely
// operate on it.
@@ -560,17 +560,17 @@ class CloseCookieDBListener MOZ_FINAL :
{
~CloseCookieDBListener() {}
public:
explicit CloseCookieDBListener(DBState* dbState) : mDBState(dbState) { }
nsRefPtr<DBState> mDBState;
NS_DECL_ISUPPORTS
- NS_IMETHOD Complete(nsresult, nsISupports*)
+ NS_IMETHOD Complete(nsresult, nsISupports*) MOZ_OVERRIDE
{
gCookieService->HandleDBClosed(mDBState);
return NS_OK;
}
};
NS_IMPL_ISUPPORTS(CloseCookieDBListener, mozIStorageCompletionCallback)
@@ -580,17 +580,17 @@ class AppClearDataObserver MOZ_FINAL : p
~AppClearDataObserver() {}
public:
NS_DECL_ISUPPORTS
// nsIObserver implementation.
NS_IMETHODIMP
- Observe(nsISupports *aSubject, const char *aTopic, const char16_t *data)
+ Observe(nsISupports *aSubject, const char *aTopic, const char16_t *data) MOZ_OVERRIDE
{
MOZ_ASSERT(!nsCRT::strcmp(aTopic, TOPIC_WEB_APP_CLEAR_DATA));
uint32_t appId = NECKO_UNKNOWN_APP_ID;
bool browserOnly = false;
nsresult rv = NS_GetAppInfoFromClearDataNotification(aSubject, &appId,
&browserOnly);
NS_ENSURE_SUCCESS(rv, rv);
--- a/netwerk/dns/DNSRequestParent.h
+++ b/netwerk/dns/DNSRequestParent.h
@@ -25,18 +25,18 @@ public:
DNSRequestParent();
void DoAsyncResolve(const nsACString &hostname, uint32_t flags);
// Pass args here rather than storing them in the parent; they are only
// needed if the request is to be canceled.
bool RecvCancelDNSRequest(const nsCString& hostName,
const uint32_t& flags,
- const nsresult& reason);
- bool Recv__delete__();
+ const nsresult& reason) MOZ_OVERRIDE;
+ bool Recv__delete__() MOZ_OVERRIDE;
protected:
virtual void ActorDestroy(ActorDestroyReason why) MOZ_OVERRIDE;
private:
virtual ~DNSRequestParent();
uint32_t mFlags;
bool mIPCClosed; // true if IPDL channel has been closed (child crash)
--- a/netwerk/dns/nsDNSService2.cpp
+++ b/netwerk/dns/nsDNSService2.cpp
@@ -265,23 +265,23 @@ public:
uint16_t flags,
uint16_t af)
: mResolver(res)
, mHost(host)
, mListener(listener)
, mFlags(flags)
, mAF(af) {}
- void OnLookupComplete(nsHostResolver *, nsHostRecord *, nsresult);
+ void OnLookupComplete(nsHostResolver *, nsHostRecord *, nsresult) MOZ_OVERRIDE;
// Returns TRUE if the DNS listener arg is the same as the member listener
// Used in Cancellations to remove DNS requests associated with a
// particular hostname and nsIDNSListener
- bool EqualsAsyncListener(nsIDNSListener *aListener);
+ bool EqualsAsyncListener(nsIDNSListener *aListener) MOZ_OVERRIDE;
- size_t SizeOfIncludingThis(mozilla::MallocSizeOf) const;
+ size_t SizeOfIncludingThis(mozilla::MallocSizeOf) const MOZ_OVERRIDE;
nsRefPtr<nsHostResolver> mResolver;
nsCString mHost; // hostname we're resolving
nsCOMPtr<nsIDNSListener> mListener;
uint16_t mFlags;
uint16_t mAF;
};
--- a/netwerk/ipc/NeckoParent.h
+++ b/netwerk/ipc/NeckoParent.h
@@ -75,31 +75,24 @@ public:
{
~NestedFrameAuthPrompt() {}
public:
NS_DECL_ISUPPORTS
NestedFrameAuthPrompt(PNeckoParent* aParent, TabId aNestedFrameId);
- NS_IMETHOD PromptAuth(nsIChannel*, uint32_t, nsIAuthInformation*, bool*)
+ NS_IMETHOD PromptAuth(nsIChannel*, uint32_t, nsIAuthInformation*, bool*) MOZ_OVERRIDE
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHOD AsyncPromptAuth(nsIChannel* aChannel, nsIAuthPromptCallback* callback,
nsISupports*, uint32_t,
- nsIAuthInformation* aInfo, nsICancelable**);
-
- NS_IMETHOD AsyncPromptAuth2(nsIChannel*, nsIDOMElement*,
- nsIAuthPromptCallback*, nsISupports*,
- uint32_t, nsIAuthInformation*, nsICancelable**)
- {
- return NS_ERROR_NOT_IMPLEMENTED;
- }
+ nsIAuthInformation* aInfo, nsICancelable**) MOZ_OVERRIDE;
protected:
PNeckoParent* mNeckoParent;
TabId mNestedFrameId;
};
protected:
virtual PHttpChannelParent*
--- a/netwerk/protocol/app/AppProtocolHandler.cpp
+++ b/netwerk/protocol/app/AppProtocolHandler.cpp
@@ -29,17 +29,17 @@ class DummyChannel : public nsIJARChanne
public:
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_NSIREQUEST
NS_DECL_NSICHANNEL
NS_DECL_NSIJARCHANNEL
DummyChannel();
- NS_IMETHODIMP Run();
+ NS_IMETHODIMP Run() MOZ_OVERRIDE;
private:
~DummyChannel() {}
bool mPending;
uint32_t mSuspendCount;
nsCOMPtr<nsISupports> mListenerContext;
nsCOMPtr<nsIStreamListener> mListener;
--- a/netwerk/protocol/device/nsDeviceChannel.h
+++ b/netwerk/protocol/device/nsDeviceChannel.h
@@ -13,14 +13,14 @@ class nsDeviceChannel : public nsBaseCha
public:
NS_DECL_ISUPPORTS_INHERITED
nsDeviceChannel();
nsresult Init(nsIURI* uri);
nsresult OpenContentStream(bool aAsync,
nsIInputStream **aStream,
- nsIChannel **aChannel);
+ nsIChannel **aChannel) MOZ_OVERRIDE;
protected:
~nsDeviceChannel();
};
#endif
--- a/netwerk/protocol/file/nsFileChannel.cpp
+++ b/netwerk/protocol/file/nsFileChannel.cpp
@@ -170,19 +170,19 @@ public:
, mSink(sink) {
}
bool IsInitialized() {
return mCopyEvent != nullptr;
}
NS_IMETHODIMP ReadSegments(nsWriteSegmentFun fun, void *closure,
- uint32_t count, uint32_t *result);
+ uint32_t count, uint32_t *result) MOZ_OVERRIDE;
NS_IMETHODIMP AsyncWait(nsIInputStreamCallback *callback, uint32_t flags,
- uint32_t count, nsIEventTarget *target);
+ uint32_t count, nsIEventTarget *target) MOZ_OVERRIDE;
private:
virtual ~nsFileUploadContentStream() {}
void OnCopyComplete();
nsRefPtr<nsFileCopyEvent> mCopyEvent;
nsCOMPtr<nsITransportEventSink> mSink;
--- a/netwerk/protocol/file/nsFileChannel.h
+++ b/netwerk/protocol/file/nsFileChannel.h
@@ -28,16 +28,16 @@ protected:
// Called to construct a blocking file input stream for the given file. This
// method also returns a best guess at the content-type for the data stream.
// NOTE: If the channel has a type hint set, contentType will be left
// untouched. The caller should not use it in that case.
nsresult MakeFileInputStream(nsIFile *file, nsCOMPtr<nsIInputStream> &stream,
nsCString &contentType, bool async);
virtual nsresult OpenContentStream(bool async, nsIInputStream **result,
- nsIChannel** channel);
+ nsIChannel** channel) MOZ_OVERRIDE;
private:
nsCOMPtr<nsIInputStream> mUploadStream;
int64_t mUploadLength;
};
#endif // !nsFileChannel_h__
--- a/netwerk/protocol/ftp/FTPChannelChild.h
+++ b/netwerk/protocol/ftp/FTPChannelChild.h
@@ -44,30 +44,30 @@ public:
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_NSIFTPCHANNEL
NS_DECL_NSIUPLOADCHANNEL
NS_DECL_NSIRESUMABLECHANNEL
NS_DECL_NSIPROXIEDCHANNEL
NS_DECL_NSICHILDCHANNEL
NS_DECL_NSIDIVERTABLECHANNEL
- NS_IMETHOD Cancel(nsresult status);
- NS_IMETHOD Suspend();
- NS_IMETHOD Resume();
+ NS_IMETHOD Cancel(nsresult status) MOZ_OVERRIDE;
+ NS_IMETHOD Suspend() MOZ_OVERRIDE;
+ NS_IMETHOD Resume() MOZ_OVERRIDE;
explicit FTPChannelChild(nsIURI* uri);
void AddIPDLReference();
void ReleaseIPDLReference();
- NS_IMETHOD AsyncOpen(nsIStreamListener* listener, nsISupports* aContext);
+ NS_IMETHOD AsyncOpen(nsIStreamListener* listener, nsISupports* aContext) MOZ_OVERRIDE;
// Note that we handle this ourselves, overriding the nsBaseChannel
// default behavior, in order to be e10s-friendly.
- NS_IMETHOD IsPending(bool* result);
+ NS_IMETHOD IsPending(bool* result) MOZ_OVERRIDE;
nsresult OpenContentStream(bool async,
nsIInputStream** stream,
nsIChannel** channel) MOZ_OVERRIDE;
bool IsSuspended();
void FlushedForDiversion();
--- a/netwerk/protocol/ftp/nsFTPChannel.h
+++ b/netwerk/protocol/ftp/nsFTPChannel.h
@@ -67,43 +67,43 @@ public:
// ID of the entity to resume downloading
const nsCString &EntityID() {
return mEntityID;
}
void SetEntityID(const nsCSubstring &entityID) {
mEntityID = entityID;
}
- NS_IMETHODIMP GetLastModifiedTime(PRTime* lastModifiedTime) {
+ NS_IMETHODIMP GetLastModifiedTime(PRTime* lastModifiedTime) MOZ_OVERRIDE {
*lastModifiedTime = mLastModifiedTime;
return NS_OK;
}
- NS_IMETHODIMP SetLastModifiedTime(PRTime lastModifiedTime) {
+ NS_IMETHODIMP SetLastModifiedTime(PRTime lastModifiedTime) MOZ_OVERRIDE {
mLastModifiedTime = lastModifiedTime;
return NS_OK;
}
// Data stream to upload
nsIInputStream *UploadStream() {
return mUploadStream;
}
// Helper function for getting the nsIFTPEventSink.
void GetFTPEventSink(nsCOMPtr<nsIFTPEventSink> &aResult);
public:
- NS_IMETHOD ForcePending(bool aForcePending);
+ NS_IMETHOD ForcePending(bool aForcePending) MOZ_OVERRIDE;
protected:
virtual ~nsFtpChannel() {}
virtual nsresult OpenContentStream(bool async, nsIInputStream **result,
- nsIChannel** channel);
- virtual bool GetStatusArg(nsresult status, nsString &statusArg);
- virtual void OnCallbacksChanged();
+ nsIChannel** channel) MOZ_OVERRIDE;
+ virtual bool GetStatusArg(nsresult status, nsString &statusArg) MOZ_OVERRIDE;
+ virtual void OnCallbacksChanged() MOZ_OVERRIDE;
private:
nsCOMPtr<nsIProxyInfo> mProxyInfo;
nsCOMPtr<nsIFTPEventSink> mFTPEventSink;
nsCOMPtr<nsIInputStream> mUploadStream;
uint64_t mStartPos;
nsCString mEntityID;
bool mResumeRequested;
--- a/netwerk/protocol/ftp/nsFtpConnectionThread.h
+++ b/netwerk/protocol/ftp/nsFtpConnectionThread.h
@@ -88,31 +88,31 @@ public:
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_NSIINPUTSTREAMCALLBACK
NS_DECL_NSITRANSPORTEVENTSINK
NS_DECL_NSICACHELISTENER
NS_DECL_NSIREQUESTOBSERVER
NS_DECL_NSIPROTOCOLPROXYCALLBACK
// Override input stream methods:
- NS_IMETHOD CloseWithStatus(nsresult status);
- NS_IMETHOD Available(uint64_t *result);
+ NS_IMETHOD CloseWithStatus(nsresult status) MOZ_OVERRIDE;
+ NS_IMETHOD Available(uint64_t *result) MOZ_OVERRIDE;
NS_IMETHOD ReadSegments(nsWriteSegmentFun fun, void *closure,
- uint32_t count, uint32_t *result);
+ uint32_t count, uint32_t *result) MOZ_OVERRIDE;
// nsFtpControlConnectionListener methods:
- virtual void OnControlDataAvailable(const char *data, uint32_t dataLen);
- virtual void OnControlError(nsresult status);
+ virtual void OnControlDataAvailable(const char *data, uint32_t dataLen) MOZ_OVERRIDE;
+ virtual void OnControlError(nsresult status) MOZ_OVERRIDE;
nsFtpState();
nsresult Init(nsFtpChannel *channel);
protected:
// Notification from nsBaseContentStream::AsyncWait
- virtual void OnCallbackPending();
+ virtual void OnCallbackPending() MOZ_OVERRIDE;
private:
virtual ~nsFtpState();
///////////////////////////////////
// BEGIN: STATE METHODS
nsresult S_user(); FTP_STATE R_user();
nsresult S_pass(); FTP_STATE R_pass();
--- a/netwerk/protocol/http/Http2Push.h
+++ b/netwerk/protocol/http/Http2Push.h
@@ -34,34 +34,34 @@ public:
// The consumer stream is the synthetic pull stream hooked up to this push
virtual Http2Stream *GetConsumerStream() MOZ_OVERRIDE { return mConsumerStream; };
void SetConsumerStream(Http2Stream *aStream);
bool GetHashKey(nsCString &key);
// override of Http2Stream
- nsresult ReadSegments(nsAHttpSegmentReader *, uint32_t, uint32_t *);
- nsresult WriteSegments(nsAHttpSegmentWriter *, uint32_t, uint32_t *);
+ nsresult ReadSegments(nsAHttpSegmentReader *, uint32_t, uint32_t *) MOZ_OVERRIDE;
+ nsresult WriteSegments(nsAHttpSegmentWriter *, uint32_t, uint32_t *) MOZ_OVERRIDE;
- nsILoadGroupConnectionInfo *LoadGroupConnectionInfo() { return mLoadGroupCI; };
+ nsILoadGroupConnectionInfo *LoadGroupConnectionInfo() MOZ_OVERRIDE { return mLoadGroupCI; };
void ConnectPushedStream(Http2Stream *consumer);
bool TryOnPush();
virtual bool DeferCleanup(nsresult status) MOZ_OVERRIDE;
void SetDeferCleanupOnSuccess(bool val) { mDeferCleanupOnSuccess = val; }
bool IsOrphaned(TimeStamp now);
void OnPushFailed() { mDeferCleanupOnPush = false; mOnPushFailed = true; }
nsresult GetBufferedData(char *buf, uint32_t count, uint32_t *countWritten);
// overload of Http2Stream
- virtual bool HasSink() { return !!mConsumerStream; }
+ virtual bool HasSink() MOZ_OVERRIDE { return !!mConsumerStream; }
nsCString &GetRequestString() { return mRequestString; }
private:
Http2Stream *mConsumerStream; // paired request stream that consumes from
// real http/2 one.. null until a match is made.
--- a/netwerk/protocol/http/Http2Session.h
+++ b/netwerk/protocol/http/Http2Session.h
@@ -39,28 +39,28 @@ public:
NS_DECL_NSAHTTPTRANSACTION
NS_DECL_NSAHTTPCONNECTION(mConnection)
NS_DECL_NSAHTTPSEGMENTREADER
NS_DECL_NSAHTTPSEGMENTWRITER
Http2Session(nsISocketTransport *, uint32_t version);
bool AddStream(nsAHttpTransaction *, int32_t,
- bool, nsIInterfaceRequestor *);
- bool CanReuse() { return !mShouldGoAway && !mClosed; }
- bool RoomForMoreStreams();
+ bool, nsIInterfaceRequestor *) MOZ_OVERRIDE;
+ bool CanReuse() MOZ_OVERRIDE { return !mShouldGoAway && !mClosed; }
+ bool RoomForMoreStreams() MOZ_OVERRIDE;
// When the connection is active this is called up to once every 1 second
// return the interval (in seconds) that the connection next wants to
// have this invoked. It might happen sooner depending on the needs of
// other connections.
- uint32_t ReadTimeoutTick(PRIntervalTime now);
+ uint32_t ReadTimeoutTick(PRIntervalTime now) MOZ_OVERRIDE;
// Idle time represents time since "goodput".. e.g. a data or header frame
- PRIntervalTime IdleTime();
+ PRIntervalTime IdleTime() MOZ_OVERRIDE;
// Registering with a newID of 0 means pick the next available odd ID
uint32_t RegisterStreamID(Http2Stream *, uint32_t aNewID = 0);
/*
HTTP/2 framing
0 1 2 3
@@ -187,38 +187,38 @@ public:
uint8_t frameType, uint8_t frameFlags,
uint32_t streamID);
// For writing the data stream to LOG4
static void LogIO(Http2Session *, Http2Stream *, const char *,
const char *, uint32_t);
// an overload of nsAHttpConnection
- void TransactionHasDataToWrite(nsAHttpTransaction *);
+ void TransactionHasDataToWrite(nsAHttpTransaction *) MOZ_OVERRIDE;
// a similar version for Http2Stream
void TransactionHasDataToWrite(Http2Stream *);
// an overload of nsAHttpSegementReader
- virtual nsresult CommitToSegmentSize(uint32_t size, bool forceCommitment);
+ virtual nsresult CommitToSegmentSize(uint32_t size, bool forceCommitment) MOZ_OVERRIDE;
nsresult BufferOutput(const char *, uint32_t, uint32_t *);
void FlushOutputQueue();
uint32_t AmountOfOutputBuffered() { return mOutputQueueUsed - mOutputQueueSent; }
uint32_t GetServerInitialStreamWindow() { return mServerInitialStreamWindow; }
void ConnectPushedStream(Http2Stream *stream);
void MaybeDecrementConcurrent(Http2Stream *stream);
nsresult ConfirmTLSProfile();
static bool ALPNCallback(nsISupports *securityInfo);
uint64_t Serial() { return mSerial; }
- void PrintDiagnostics (nsCString &log);
+ void PrintDiagnostics (nsCString &log) MOZ_OVERRIDE;
// Streams need access to these
uint32_t SendingChunkSize() { return mSendingChunkSize; }
uint32_t PushAllowance() { return mPushAllowance; }
Http2Compressor *Compressor() { return &mCompressor; }
nsISocketTransport *SocketTransport() { return mSocketTransport; }
int64_t ServerSessionWindow() { return mServerSessionWindow; }
void DecrementServerSessionWindow (uint32_t bytes) { mServerSessionWindow -= bytes; }
--- a/netwerk/protocol/http/HttpBaseChannel.h
+++ b/netwerk/protocol/http/HttpBaseChannel.h
@@ -86,130 +86,130 @@ public:
HttpBaseChannel();
virtual nsresult Init(nsIURI *aURI, uint32_t aCaps, nsProxyInfo *aProxyInfo,
uint32_t aProxyResolveFlags,
nsIURI *aProxyURI);
// nsIRequest
- NS_IMETHOD GetName(nsACString& aName);
- NS_IMETHOD IsPending(bool *aIsPending);
- NS_IMETHOD GetStatus(nsresult *aStatus);
- NS_IMETHOD GetLoadGroup(nsILoadGroup **aLoadGroup);
- NS_IMETHOD SetLoadGroup(nsILoadGroup *aLoadGroup);
- NS_IMETHOD GetLoadFlags(nsLoadFlags *aLoadFlags);
- NS_IMETHOD SetLoadFlags(nsLoadFlags aLoadFlags);
+ NS_IMETHOD GetName(nsACString& aName) MOZ_OVERRIDE;
+ NS_IMETHOD IsPending(bool *aIsPending) MOZ_OVERRIDE;
+ NS_IMETHOD GetStatus(nsresult *aStatus) MOZ_OVERRIDE;
+ NS_IMETHOD GetLoadGroup(nsILoadGroup **aLoadGroup) MOZ_OVERRIDE;
+ NS_IMETHOD SetLoadGroup(nsILoadGroup *aLoadGroup) MOZ_OVERRIDE;
+ NS_IMETHOD GetLoadFlags(nsLoadFlags *aLoadFlags) MOZ_OVERRIDE;
+ NS_IMETHOD SetLoadFlags(nsLoadFlags aLoadFlags) MOZ_OVERRIDE;
// nsIChannel
- NS_IMETHOD GetOriginalURI(nsIURI **aOriginalURI);
- NS_IMETHOD SetOriginalURI(nsIURI *aOriginalURI);
- NS_IMETHOD GetURI(nsIURI **aURI);
- NS_IMETHOD GetOwner(nsISupports **aOwner);
- NS_IMETHOD SetOwner(nsISupports *aOwner);
- NS_IMETHOD GetLoadInfo(nsILoadInfo **aLoadInfo);
- NS_IMETHOD SetLoadInfo(nsILoadInfo *aLoadInfo);
- NS_IMETHOD GetNotificationCallbacks(nsIInterfaceRequestor **aCallbacks);
- NS_IMETHOD SetNotificationCallbacks(nsIInterfaceRequestor *aCallbacks);
- NS_IMETHOD GetContentType(nsACString& aContentType);
- NS_IMETHOD SetContentType(const nsACString& aContentType);
- NS_IMETHOD GetContentCharset(nsACString& aContentCharset);
- NS_IMETHOD SetContentCharset(const nsACString& aContentCharset);
- NS_IMETHOD GetContentDisposition(uint32_t *aContentDisposition);
- NS_IMETHOD SetContentDisposition(uint32_t aContentDisposition);
- NS_IMETHOD GetContentDispositionFilename(nsAString& aContentDispositionFilename);
- NS_IMETHOD SetContentDispositionFilename(const nsAString& aContentDispositionFilename);
- NS_IMETHOD GetContentDispositionHeader(nsACString& aContentDispositionHeader);
- NS_IMETHOD GetContentLength(int64_t *aContentLength);
- NS_IMETHOD SetContentLength(int64_t aContentLength);
- NS_IMETHOD Open(nsIInputStream **aResult);
+ NS_IMETHOD GetOriginalURI(nsIURI **aOriginalURI) MOZ_OVERRIDE;
+ NS_IMETHOD SetOriginalURI(nsIURI *aOriginalURI) MOZ_OVERRIDE;
+ NS_IMETHOD GetURI(nsIURI **aURI) MOZ_OVERRIDE;
+ NS_IMETHOD GetOwner(nsISupports **aOwner) MOZ_OVERRIDE;
+ NS_IMETHOD SetOwner(nsISupports *aOwner) MOZ_OVERRIDE;
+ NS_IMETHOD GetLoadInfo(nsILoadInfo **aLoadInfo) MOZ_OVERRIDE;
+ NS_IMETHOD SetLoadInfo(nsILoadInfo *aLoadInfo) MOZ_OVERRIDE;
+ NS_IMETHOD GetNotificationCallbacks(nsIInterfaceRequestor **aCallbacks) MOZ_OVERRIDE;
+ NS_IMETHOD SetNotificationCallbacks(nsIInterfaceRequestor *aCallbacks) MOZ_OVERRIDE;
+ NS_IMETHOD GetContentType(nsACString& aContentType) MOZ_OVERRIDE;
+ NS_IMETHOD SetContentType(const nsACString& aContentType) MOZ_OVERRIDE;
+ NS_IMETHOD GetContentCharset(nsACString& aContentCharset) MOZ_OVERRIDE;
+ NS_IMETHOD SetContentCharset(const nsACString& aContentCharset) MOZ_OVERRIDE;
+ NS_IMETHOD GetContentDisposition(uint32_t *aContentDisposition) MOZ_OVERRIDE;
+ NS_IMETHOD SetContentDisposition(uint32_t aContentDisposition) MOZ_OVERRIDE;
+ NS_IMETHOD GetContentDispositionFilename(nsAString& aContentDispositionFilename) MOZ_OVERRIDE;
+ NS_IMETHOD SetContentDispositionFilename(const nsAString& aContentDispositionFilename) MOZ_OVERRIDE;
+ NS_IMETHOD GetContentDispositionHeader(nsACString& aContentDispositionHeader) MOZ_OVERRIDE;
+ NS_IMETHOD GetContentLength(int64_t *aContentLength) MOZ_OVERRIDE;
+ NS_IMETHOD SetContentLength(int64_t aContentLength) MOZ_OVERRIDE;
+ NS_IMETHOD Open(nsIInputStream **aResult) MOZ_OVERRIDE;
// nsIEncodedChannel
- NS_IMETHOD GetApplyConversion(bool *value);
- NS_IMETHOD SetApplyConversion(bool value);
- NS_IMETHOD GetContentEncodings(nsIUTF8StringEnumerator** aEncodings);
+ NS_IMETHOD GetApplyConversion(bool *value) MOZ_OVERRIDE;
+ NS_IMETHOD SetApplyConversion(bool value) MOZ_OVERRIDE;
+ NS_IMETHOD GetContentEncodings(nsIUTF8StringEnumerator** aEncodings) MOZ_OVERRIDE;
NS_IMETHOD DoApplyContentConversions(nsIStreamListener *aNextListener,
nsIStreamListener **aNewNextListener,
- nsISupports *aCtxt);
+ nsISupports *aCtxt) MOZ_OVERRIDE;
// HttpBaseChannel::nsIHttpChannel
- NS_IMETHOD GetRequestMethod(nsACString& aMethod);
- NS_IMETHOD SetRequestMethod(const nsACString& aMethod);
- NS_IMETHOD GetReferrer(nsIURI **referrer);
- NS_IMETHOD SetReferrer(nsIURI *referrer);
- NS_IMETHOD GetReferrerPolicy(uint32_t *referrerPolicy);
- NS_IMETHOD SetReferrerWithPolicy(nsIURI *referrer, uint32_t referrerPolicy);
- NS_IMETHOD GetRequestHeader(const nsACString& aHeader, nsACString& aValue);
+ NS_IMETHOD GetRequestMethod(nsACString& aMethod) MOZ_OVERRIDE;
+ NS_IMETHOD SetRequestMethod(const nsACString& aMethod) MOZ_OVERRIDE;
+ NS_IMETHOD GetReferrer(nsIURI **referrer) MOZ_OVERRIDE;
+ NS_IMETHOD SetReferrer(nsIURI *referrer) MOZ_OVERRIDE;
+ NS_IMETHOD GetReferrerPolicy(uint32_t *referrerPolicy) MOZ_OVERRIDE;
+ NS_IMETHOD SetReferrerWithPolicy(nsIURI *referrer, uint32_t referrerPolicy) MOZ_OVERRIDE;
+ NS_IMETHOD GetRequestHeader(const nsACString& aHeader, nsACString& aValue) MOZ_OVERRIDE;
NS_IMETHOD SetRequestHeader(const nsACString& aHeader,
- const nsACString& aValue, bool aMerge);
- NS_IMETHOD VisitRequestHeaders(nsIHttpHeaderVisitor *visitor);
- NS_IMETHOD GetResponseHeader(const nsACString &header, nsACString &value);
+ const nsACString& aValue, bool aMerge) MOZ_OVERRIDE;
+ NS_IMETHOD VisitRequestHeaders(nsIHttpHeaderVisitor *visitor) MOZ_OVERRIDE;
+ NS_IMETHOD GetResponseHeader(const nsACString &header, nsACString &value) MOZ_OVERRIDE;
NS_IMETHOD SetResponseHeader(const nsACString& header,
- const nsACString& value, bool merge);
- NS_IMETHOD VisitResponseHeaders(nsIHttpHeaderVisitor *visitor);
- NS_IMETHOD GetAllowPipelining(bool *value);
- NS_IMETHOD SetAllowPipelining(bool value);
- NS_IMETHOD GetAllowSTS(bool *value);
- NS_IMETHOD SetAllowSTS(bool value);
- NS_IMETHOD GetRedirectionLimit(uint32_t *value);
- NS_IMETHOD SetRedirectionLimit(uint32_t value);
- NS_IMETHOD IsNoStoreResponse(bool *value);
- NS_IMETHOD IsNoCacheResponse(bool *value);
- NS_IMETHOD GetResponseStatus(uint32_t *aValue);
- NS_IMETHOD GetResponseStatusText(nsACString& aValue);
- NS_IMETHOD GetRequestSucceeded(bool *aValue);
- NS_IMETHOD RedirectTo(nsIURI *newURI);
+ const nsACString& value, bool merge) MOZ_OVERRIDE;
+ NS_IMETHOD VisitResponseHeaders(nsIHttpHeaderVisitor *visitor) MOZ_OVERRIDE;
+ NS_IMETHOD GetAllowPipelining(bool *value) MOZ_OVERRIDE;
+ NS_IMETHOD SetAllowPipelining(bool value) MOZ_OVERRIDE;
+ NS_IMETHOD GetAllowSTS(bool *value) MOZ_OVERRIDE;
+ NS_IMETHOD SetAllowSTS(bool value) MOZ_OVERRIDE;
+ NS_IMETHOD GetRedirectionLimit(uint32_t *value) MOZ_OVERRIDE;
+ NS_IMETHOD SetRedirectionLimit(uint32_t value) MOZ_OVERRIDE;
+ NS_IMETHOD IsNoStoreResponse(bool *value) MOZ_OVERRIDE;
+ NS_IMETHOD IsNoCacheResponse(bool *value) MOZ_OVERRIDE;
+ NS_IMETHOD GetResponseStatus(uint32_t *aValue) MOZ_OVERRIDE;
+ NS_IMETHOD GetResponseStatusText(nsACString& aValue) MOZ_OVERRIDE;
+ NS_IMETHOD GetRequestSucceeded(bool *aValue) MOZ_OVERRIDE;
+ NS_IMETHOD RedirectTo(nsIURI *newURI) MOZ_OVERRIDE;
// nsIHttpChannelInternal
- NS_IMETHOD GetDocumentURI(nsIURI **aDocumentURI);
- NS_IMETHOD SetDocumentURI(nsIURI *aDocumentURI);
- NS_IMETHOD GetRequestVersion(uint32_t *major, uint32_t *minor);
- NS_IMETHOD GetResponseVersion(uint32_t *major, uint32_t *minor);
- NS_IMETHOD SetCookie(const char *aCookieHeader);
- NS_IMETHOD GetThirdPartyFlags(uint32_t *aForce);
- NS_IMETHOD SetThirdPartyFlags(uint32_t aForce);
- NS_IMETHOD GetForceAllowThirdPartyCookie(bool *aForce);
- NS_IMETHOD SetForceAllowThirdPartyCookie(bool aForce);
- NS_IMETHOD GetCanceled(bool *aCanceled);
- NS_IMETHOD GetChannelIsForDownload(bool *aChannelIsForDownload);
- NS_IMETHOD SetChannelIsForDownload(bool aChannelIsForDownload);
- NS_IMETHOD SetCacheKeysRedirectChain(nsTArray<nsCString> *cacheKeys);
- NS_IMETHOD GetLocalAddress(nsACString& addr);
- NS_IMETHOD GetLocalPort(int32_t* port);
- NS_IMETHOD GetRemoteAddress(nsACString& addr);
- NS_IMETHOD GetRemotePort(int32_t* port);
- NS_IMETHOD GetAllowSpdy(bool *aAllowSpdy);
- NS_IMETHOD SetAllowSpdy(bool aAllowSpdy);
- NS_IMETHOD GetApiRedirectToURI(nsIURI * *aApiRedirectToURI);
- NS_IMETHOD AddSecurityMessage(const nsAString &aMessageTag, const nsAString &aMessageCategory);
- NS_IMETHOD TakeAllSecurityMessages(nsCOMArray<nsISecurityConsoleMessage> &aMessages);
- NS_IMETHOD GetResponseTimeoutEnabled(bool *aEnable);
- NS_IMETHOD SetResponseTimeoutEnabled(bool aEnable);
- NS_IMETHOD AddRedirect(nsIPrincipal *aRedirect);
- NS_IMETHOD ForcePending(bool aForcePending);
- NS_IMETHOD GetLastModifiedTime(PRTime* lastModifiedTime);
- NS_IMETHOD ForceNoIntercept();
- NS_IMETHOD GetTopWindowURI(nsIURI **aTopWindowURI);
+ NS_IMETHOD GetDocumentURI(nsIURI **aDocumentURI) MOZ_OVERRIDE;
+ NS_IMETHOD SetDocumentURI(nsIURI *aDocumentURI) MOZ_OVERRIDE;
+ NS_IMETHOD GetRequestVersion(uint32_t *major, uint32_t *minor) MOZ_OVERRIDE;
+ NS_IMETHOD GetResponseVersion(uint32_t *major, uint32_t *minor) MOZ_OVERRIDE;
+ NS_IMETHOD SetCookie(const char *aCookieHeader) MOZ_OVERRIDE;
+ NS_IMETHOD GetThirdPartyFlags(uint32_t *aForce) MOZ_OVERRIDE;
+ NS_IMETHOD SetThirdPartyFlags(uint32_t aForce) MOZ_OVERRIDE;
+ NS_IMETHOD GetForceAllowThirdPartyCookie(bool *aForce) MOZ_OVERRIDE;
+ NS_IMETHOD SetForceAllowThirdPartyCookie(bool aForce) MOZ_OVERRIDE;
+ NS_IMETHOD GetCanceled(bool *aCanceled) MOZ_OVERRIDE;
+ NS_IMETHOD GetChannelIsForDownload(bool *aChannelIsForDownload) MOZ_OVERRIDE;
+ NS_IMETHOD SetChannelIsForDownload(bool aChannelIsForDownload) MOZ_OVERRIDE;
+ NS_IMETHOD SetCacheKeysRedirectChain(nsTArray<nsCString> *cacheKeys) MOZ_OVERRIDE;
+ NS_IMETHOD GetLocalAddress(nsACString& addr) MOZ_OVERRIDE;
+ NS_IMETHOD GetLocalPort(int32_t* port) MOZ_OVERRIDE;
+ NS_IMETHOD GetRemoteAddress(nsACString& addr) MOZ_OVERRIDE;
+ NS_IMETHOD GetRemotePort(int32_t* port) MOZ_OVERRIDE;
+ NS_IMETHOD GetAllowSpdy(bool *aAllowSpdy) MOZ_OVERRIDE;
+ NS_IMETHOD SetAllowSpdy(bool aAllowSpdy) MOZ_OVERRIDE;
+ NS_IMETHOD GetApiRedirectToURI(nsIURI * *aApiRedirectToURI) MOZ_OVERRIDE;
+ nsresult AddSecurityMessage(const nsAString &aMessageTag, const nsAString &aMessageCategory);
+ NS_IMETHOD TakeAllSecurityMessages(nsCOMArray<nsISecurityConsoleMessage> &aMessages) MOZ_OVERRIDE;
+ NS_IMETHOD GetResponseTimeoutEnabled(bool *aEnable) MOZ_OVERRIDE;
+ NS_IMETHOD SetResponseTimeoutEnabled(bool aEnable) MOZ_OVERRIDE;
+ NS_IMETHOD AddRedirect(nsIPrincipal *aRedirect) MOZ_OVERRIDE;
+ NS_IMETHOD ForcePending(bool aForcePending) MOZ_OVERRIDE;
+ NS_IMETHOD GetLastModifiedTime(PRTime* lastModifiedTime) MOZ_OVERRIDE;
+ NS_IMETHOD ForceNoIntercept() MOZ_OVERRIDE;
+ NS_IMETHOD GetTopWindowURI(nsIURI **aTopWindowURI) MOZ_OVERRIDE;
inline void CleanRedirectCacheChainIfNecessary()
{
mRedirectedCachekeys = nullptr;
}
NS_IMETHOD HTTPUpgrade(const nsACString & aProtocolName,
- nsIHttpUpgradeListener *aListener);
+ nsIHttpUpgradeListener *aListener) MOZ_OVERRIDE;
// nsISupportsPriority
- NS_IMETHOD GetPriority(int32_t *value);
- NS_IMETHOD AdjustPriority(int32_t delta);
+ NS_IMETHOD GetPriority(int32_t *value) MOZ_OVERRIDE;
+ NS_IMETHOD AdjustPriority(int32_t delta) MOZ_OVERRIDE;
// nsIClassOfService
- NS_IMETHOD GetClassFlags(uint32_t *outFlags) { *outFlags = mClassOfService; return NS_OK; }
+ NS_IMETHOD GetClassFlags(uint32_t *outFlags) MOZ_OVERRIDE { *outFlags = mClassOfService; return NS_OK; }
// nsIResumableChannel
- NS_IMETHOD GetEntityID(nsACString& aEntityID);
+ NS_IMETHOD GetEntityID(nsACString& aEntityID) MOZ_OVERRIDE;
class nsContentEncodings : public nsIUTF8StringEnumerator
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIUTF8STRINGENUMERATOR
nsContentEncodings(nsIHttpChannel* aChannel, const char* aEncodingHeader);
--- a/netwerk/protocol/http/HttpChannelChild.h
+++ b/netwerk/protocol/http/HttpChannelChild.h
@@ -63,41 +63,41 @@ public:
NS_DECL_NSIHTTPCHANNELCHILD
NS_DECL_NSIDIVERTABLECHANNEL
HttpChannelChild();
// Methods HttpBaseChannel didn't implement for us or that we override.
//
// nsIRequest
- NS_IMETHOD Cancel(nsresult status);
- NS_IMETHOD Suspend();
- NS_IMETHOD Resume();
+ NS_IMETHOD Cancel(nsresult status) MOZ_OVERRIDE;
+ NS_IMETHOD Suspend() MOZ_OVERRIDE;
+ NS_IMETHOD Resume() MOZ_OVERRIDE;
// nsIChannel
- NS_IMETHOD GetSecurityInfo(nsISupports **aSecurityInfo);
- NS_IMETHOD AsyncOpen(nsIStreamListener *listener, nsISupports *aContext);
+ NS_IMETHOD GetSecurityInfo(nsISupports **aSecurityInfo) MOZ_OVERRIDE;
+ NS_IMETHOD AsyncOpen(nsIStreamListener *listener, nsISupports *aContext) MOZ_OVERRIDE;
// HttpBaseChannel::nsIHttpChannel
NS_IMETHOD SetRequestHeader(const nsACString& aHeader,
const nsACString& aValue,
- bool aMerge);
- NS_IMETHOD RedirectTo(nsIURI *newURI);
+ bool aMerge) MOZ_OVERRIDE;
+ NS_IMETHOD RedirectTo(nsIURI *newURI) MOZ_OVERRIDE;
// nsIHttpChannelInternal
- NS_IMETHOD SetupFallbackChannel(const char *aFallbackKey);
- NS_IMETHOD GetLocalAddress(nsACString& addr);
- NS_IMETHOD GetLocalPort(int32_t* port);
- NS_IMETHOD GetRemoteAddress(nsACString& addr);
- NS_IMETHOD GetRemotePort(int32_t* port);
+ NS_IMETHOD SetupFallbackChannel(const char *aFallbackKey) MOZ_OVERRIDE;
+ NS_IMETHOD GetLocalAddress(nsACString& addr) MOZ_OVERRIDE;
+ NS_IMETHOD GetLocalPort(int32_t* port) MOZ_OVERRIDE;
+ NS_IMETHOD GetRemoteAddress(nsACString& addr) MOZ_OVERRIDE;
+ NS_IMETHOD GetRemotePort(int32_t* port) MOZ_OVERRIDE;
// nsISupportsPriority
- NS_IMETHOD SetPriority(int32_t value);
+ NS_IMETHOD SetPriority(int32_t value) MOZ_OVERRIDE;
// nsIClassOfService
- NS_IMETHOD SetClassFlags(uint32_t inFlags);
- NS_IMETHOD AddClassFlags(uint32_t inFlags);
- NS_IMETHOD ClearClassFlags(uint32_t inFlags);
+ NS_IMETHOD SetClassFlags(uint32_t inFlags) MOZ_OVERRIDE;
+ NS_IMETHOD AddClassFlags(uint32_t inFlags) MOZ_OVERRIDE;
+ NS_IMETHOD ClearClassFlags(uint32_t inFlags) MOZ_OVERRIDE;
// nsIResumableChannel
- NS_IMETHOD ResumeAt(uint64_t startPos, const nsACString& entityID);
+ NS_IMETHOD ResumeAt(uint64_t startPos, const nsACString& entityID) MOZ_OVERRIDE;
// IPDL holds a reference while the PHttpChannel protocol is live (starting at
// AsyncOpen, and ending at either OnStopRequest or any IPDL error, either of
// which call NeckoChild::DeallocPHttpChannelChild()).
void AddIPDLReference();
void ReleaseIPDLReference();
bool IsSuspended();
@@ -120,33 +120,33 @@ protected:
const int16_t& redirectCount) MOZ_OVERRIDE;
bool RecvOnTransportAndData(const nsresult& channelStatus,
const nsresult& status,
const uint64_t& progress,
const uint64_t& progressMax,
const nsCString& data,
const uint64_t& offset,
const uint32_t& count) MOZ_OVERRIDE;
- bool RecvOnStopRequest(const nsresult& statusCode, const ResourceTimingStruct& timing);
+ bool RecvOnStopRequest(const nsresult& statusCode, const ResourceTimingStruct& timing) MOZ_OVERRIDE;
bool RecvOnProgress(const uint64_t& progress, const uint64_t& progressMax) MOZ_OVERRIDE;
bool RecvOnStatus(const nsresult& status) MOZ_OVERRIDE;
bool RecvFailedAsyncOpen(const nsresult& status) MOZ_OVERRIDE;
bool RecvRedirect1Begin(const uint32_t& newChannel,
const URIParams& newURI,
const uint32_t& redirectFlags,
const nsHttpResponseHead& responseHead) MOZ_OVERRIDE;
bool RecvRedirect3Complete() MOZ_OVERRIDE;
bool RecvAssociateApplicationCache(const nsCString& groupID,
const nsCString& clientID) MOZ_OVERRIDE;
bool RecvFlushedForDiversion() MOZ_OVERRIDE;
bool RecvDivertMessages() MOZ_OVERRIDE;
bool RecvDeleteSelf() MOZ_OVERRIDE;
bool GetAssociatedContentSecurity(nsIAssociatedContentSecurity** res = nullptr);
- virtual void DoNotifyListenerCleanup();
+ virtual void DoNotifyListenerCleanup() MOZ_OVERRIDE;
private:
nsresult ContinueAsyncOpen();
void DoOnStartRequest(nsIRequest* aRequest, nsISupports* aContext);
void DoOnStatus(nsIRequest* aRequest, nsresult status);
void DoOnProgress(nsIRequest* aRequest, uint64_t progress, uint64_t progressMax);
void DoOnDataAvailable(nsIRequest* aRequest, nsISupports* aContext, nsIInputStream* aStream,
--- a/netwerk/protocol/http/SpdySession31.h
+++ b/netwerk/protocol/http/SpdySession31.h
@@ -37,28 +37,28 @@ public:
NS_DECL_NSAHTTPTRANSACTION
NS_DECL_NSAHTTPCONNECTION(mConnection)
NS_DECL_NSAHTTPSEGMENTREADER
NS_DECL_NSAHTTPSEGMENTWRITER
explicit SpdySession31(nsISocketTransport *);
bool AddStream(nsAHttpTransaction *, int32_t,
- bool, nsIInterfaceRequestor *);
- bool CanReuse() { return !mShouldGoAway && !mClosed; }
- bool RoomForMoreStreams();
+ bool, nsIInterfaceRequestor *) MOZ_OVERRIDE;
+ bool CanReuse() MOZ_OVERRIDE { return !mShouldGoAway && !mClosed; }
+ bool RoomForMoreStreams() MOZ_OVERRIDE;
// When the connection is active this is called up to once every 1 second
// return the interval (in seconds) that the connection next wants to
// have this invoked. It might happen sooner depending on the needs of
// other connections.
- uint32_t ReadTimeoutTick(PRIntervalTime now);
+ uint32_t ReadTimeoutTick(PRIntervalTime now) MOZ_OVERRIDE;
// Idle time represents time since "goodput".. e.g. a data or header frame
- PRIntervalTime IdleTime();
+ PRIntervalTime IdleTime() MOZ_OVERRIDE;
// Registering with a newID of 0 means pick the next available odd ID
uint32_t RegisterStreamID(SpdyStream31 *, uint32_t aNewID = 0);
const static uint8_t kVersion = 3;
const static uint8_t kFlag_Control = 0x80;
@@ -160,35 +160,35 @@ public:
static nsresult HandleWindowUpdate(SpdySession31 *);
static nsresult HandleCredential(SpdySession31 *);
// For writing the SPDY data stream to LOG4
static void LogIO(SpdySession31 *, SpdyStream31 *, const char *,
const char *, uint32_t);
// an overload of nsAHttpConnection
- void TransactionHasDataToWrite(nsAHttpTransaction *);
+ void TransactionHasDataToWrite(nsAHttpTransaction *) MOZ_OVERRIDE;
// a similar version for SpdyStream31
void TransactionHasDataToWrite(SpdyStream31 *);
// an overload of nsAHttpSegementReader
- virtual nsresult CommitToSegmentSize(uint32_t size, bool forceCommitment);
+ virtual nsresult CommitToSegmentSize(uint32_t size, bool forceCommitment) MOZ_OVERRIDE;
nsresult BufferOutput(const char *, uint32_t, uint32_t *);
void FlushOutputQueue();
uint32_t AmountOfOutputBuffered() { return mOutputQueueUsed - mOutputQueueSent; }
uint32_t GetServerInitialStreamWindow() { return mServerInitialStreamWindow; }
void ConnectPushedStream(SpdyStream31 *stream);
void DecrementConcurrent(SpdyStream31 *stream);
uint64_t Serial() { return mSerial; }
- void PrintDiagnostics (nsCString &log);
+ void PrintDiagnostics (nsCString &log) MOZ_OVERRIDE;
// Streams need access to these
uint32_t SendingChunkSize() { return mSendingChunkSize; }
uint32_t PushAllowance() { return mPushAllowance; }
z_stream *UpstreamZlib() { return &mUpstreamZlib; }
nsISocketTransport *SocketTransport() { return mSocketTransport; }
int64_t RemoteSessionWindow() { return mRemoteSessionWindow; }
void DecrementRemoteSessionWindow (uint32_t bytes) { mRemoteSessionWindow -= bytes; }
--- a/netwerk/protocol/http/SpdyZlibReporter.h
+++ b/netwerk/protocol/http/SpdyZlibReporter.h
@@ -45,14 +45,14 @@ private:
static Atomic<size_t> sAmount;
MOZ_DEFINE_MALLOC_SIZE_OF(MallocSizeOf)
MOZ_DEFINE_MALLOC_SIZE_OF_ON_ALLOC(MallocSizeOfOnAlloc)
MOZ_DEFINE_MALLOC_SIZE_OF_ON_FREE(MallocSizeOfOnFree)
NS_IMETHODIMP
CollectReports(nsIHandleReportCallback* aHandleReport, nsISupports* aData,
- bool aAnonymize);
+ bool aAnonymize) MOZ_OVERRIDE;
};
} // namespace mozilla
#endif // mozilla_net_SpdyZlibReporter_h
--- a/netwerk/protocol/http/TunnelUtils.cpp
+++ b/netwerk/protocol/http/TunnelUtils.cpp
@@ -766,33 +766,33 @@ class SocketInWrapper : public nsIAsyncI
NS_DECL_THREADSAFE_ISUPPORTS
NS_FORWARD_NSIASYNCINPUTSTREAM(mStream->)
SocketInWrapper(nsIAsyncInputStream *aWrapped, TLSFilterTransaction *aFilter)
: mStream(aWrapped)
, mTLSFilter(aFilter)
{ }
- NS_IMETHODIMP Close()
+ NS_IMETHODIMP Close() MOZ_OVERRIDE
{
mTLSFilter = nullptr;
return mStream->Close();
}
- NS_IMETHODIMP Available(uint64_t *_retval)
+ NS_IMETHODIMP Available(uint64_t *_retval) MOZ_OVERRIDE
{
return mStream->Available(_retval);
}
- NS_IMETHODIMP IsNonBlocking(bool *_retval)
+ NS_IMETHODIMP IsNonBlocking(bool *_retval) MOZ_OVERRIDE
{
return mStream->IsNonBlocking(_retval);
}
- NS_IMETHODIMP ReadSegments(nsWriteSegmentFun aWriter, void *aClosure, uint32_t aCount, uint32_t *_retval)
+ NS_IMETHODIMP ReadSegments(nsWriteSegmentFun aWriter, void *aClosure, uint32_t aCount, uint32_t *_retval) MOZ_OVERRIDE
{
return mStream->ReadSegments(aWriter, aClosure, aCount, _retval);
}
// finally, ones that don't get forwarded :)
NS_IMETHOD Read(char *aBuf, uint32_t aCount, uint32_t *_retval) MOZ_OVERRIDE;
virtual nsresult OnWriteSegment(char *segment, uint32_t count, uint32_t *countWritten) MOZ_OVERRIDE;
@@ -833,38 +833,38 @@ class SocketOutWrapper : public nsIAsync
NS_DECL_THREADSAFE_ISUPPORTS
NS_FORWARD_NSIASYNCOUTPUTSTREAM(mStream->)
SocketOutWrapper(nsIAsyncOutputStream *aWrapped, TLSFilterTransaction *aFilter)
: mStream(aWrapped)
, mTLSFilter(aFilter)
{ }
- NS_IMETHODIMP Close()
+ NS_IMETHODIMP Close() MOZ_OVERRIDE
{
mTLSFilter = nullptr;
return mStream->Close();
}
- NS_IMETHODIMP Flush()
+ NS_IMETHODIMP Flush() MOZ_OVERRIDE
{
return mStream->Flush();
}
- NS_IMETHODIMP IsNonBlocking(bool *_retval)
+ NS_IMETHODIMP IsNonBlocking(bool *_retval) MOZ_OVERRIDE
{
return mStream->IsNonBlocking(_retval);
}
- NS_IMETHODIMP WriteSegments(nsReadSegmentFun aReader, void *aClosure, uint32_t aCount, uint32_t *_retval)
+ NS_IMETHODIMP WriteSegments(nsReadSegmentFun aReader, void *aClosure, uint32_t aCount, uint32_t *_retval) MOZ_OVERRIDE
{
return mStream->WriteSegments(aReader, aClosure, aCount, _retval);
}
- NS_IMETHODIMP WriteFrom(nsIInputStream *aFromStream, uint32_t aCount, uint32_t *_retval)
+ NS_IMETHODIMP WriteFrom(nsIInputStream *aFromStream, uint32_t aCount, uint32_t *_retval) MOZ_OVERRIDE
{
return mStream->WriteFrom(aFromStream, aCount, _retval);
}
// finally, ones that don't get forwarded :)
NS_IMETHOD Write(const char *aBuf, uint32_t aCount, uint32_t *_retval) MOZ_OVERRIDE;
virtual nsresult OnReadSegment(const char *segment, uint32_t count, uint32_t *countRead) MOZ_OVERRIDE;
--- a/netwerk/protocol/http/TunnelUtils.h
+++ b/netwerk/protocol/http/TunnelUtils.h
@@ -88,17 +88,17 @@ class nsHttpRequestHead;
class TLSFilterTransaction;
class NudgeTunnelCallback : public nsISupports
{
public:
virtual void OnTunnelNudged(TLSFilterTransaction *) = 0;
};
-#define NS_DECL_NUDGETUNNELCALLBACK void OnTunnelNudged(TLSFilterTransaction *);
+#define NS_DECL_NUDGETUNNELCALLBACK void OnTunnelNudged(TLSFilterTransaction *) MOZ_OVERRIDE;
class TLSFilterTransaction MOZ_FINAL
: public nsAHttpTransaction
, public nsAHttpSegmentReader
, public nsAHttpSegmentWriter
, public nsITimerCallback
{
~TLSFilterTransaction();
@@ -110,18 +110,18 @@ public:
NS_DECL_NSITIMERCALLBACK
TLSFilterTransaction(nsAHttpTransaction *aWrappedTransaction,
const char *tlsHost, int32_t tlsPort,
nsAHttpSegmentReader *reader,
nsAHttpSegmentWriter *writer);
const nsAHttpTransaction *Transaction() const { return mTransaction.get(); }
- nsresult CommitToSegmentSize(uint32_t size, bool forceCommitment);
- nsresult GetTransactionSecurityInfo(nsISupports **);
+ nsresult CommitToSegmentSize(uint32_t size, bool forceCommitment) MOZ_OVERRIDE;
+ nsresult GetTransactionSecurityInfo(nsISupports **) MOZ_OVERRIDE;
nsresult NudgeTunnel(NudgeTunnelCallback *callback);
nsresult SetProxiedTransaction(nsAHttpTransaction *aTrans);
void newIODriver(nsIAsyncInputStream *aSocketIn,
nsIAsyncOutputStream *aSocketOut,
nsIAsyncInputStream **outSocketIn,
nsIAsyncOutputStream **outSocketOut);
// nsAHttpTransaction overloads
@@ -179,17 +179,17 @@ class SpdyConnectTransaction MOZ_FINAL :
public:
SpdyConnectTransaction(nsHttpConnectionInfo *ci,
nsIInterfaceRequestor *callbacks,
uint32_t caps,
nsHttpTransaction *trans,
nsAHttpConnection *session);
~SpdyConnectTransaction();
- SpdyConnectTransaction *QuerySpdyConnectTransaction() { return this; }
+ SpdyConnectTransaction *QuerySpdyConnectTransaction() MOZ_OVERRIDE { return this; }
// A transaction is forced into plaintext when it is intended to be used as a CONNECT
// tunnel but the setup fails. The plaintext only carries the CONNECT error.
void ForcePlainText();
void MapStreamToHttpConnection(nsISocketTransport *aTransport,
nsHttpConnectionInfo *aConnInfo);
nsresult ReadSegments(nsAHttpSegmentReader *reader,
--- a/netwerk/protocol/http/nsAHttpConnection.h
+++ b/netwerk/protocol/http/nsAHttpConnection.h
@@ -143,104 +143,110 @@ public:
// nsHttp.h version
virtual uint32_t Version() = 0;
};
NS_DEFINE_STATIC_IID_ACCESSOR(nsAHttpConnection, NS_AHTTPCONNECTION_IID)
#define NS_DECL_NSAHTTPCONNECTION(fwdObject) \
- nsresult OnHeadersAvailable(nsAHttpTransaction *, nsHttpRequestHead *, nsHttpResponseHead *, bool *reset); \
- void CloseTransaction(nsAHttpTransaction *, nsresult); \
+ nsresult OnHeadersAvailable(nsAHttpTransaction *, nsHttpRequestHead *, nsHttpResponseHead *, bool *reset) MOZ_OVERRIDE; \
+ void CloseTransaction(nsAHttpTransaction *, nsresult) MOZ_OVERRIDE; \
nsresult TakeTransport(nsISocketTransport **, \
nsIAsyncInputStream **, \
- nsIAsyncOutputStream **); \
- bool IsPersistent(); \
- bool IsReused(); \
- void DontReuse(); \
- nsresult PushBack(const char *, uint32_t); \
- nsHttpConnection *TakeHttpConnection(); \
- uint32_t CancelPipeline(nsresult originalReason); \
- nsAHttpTransaction::Classifier Classification(); \
+ nsIAsyncOutputStream **) MOZ_OVERRIDE; \
+ bool IsPersistent() MOZ_OVERRIDE; \
+ bool IsReused() MOZ_OVERRIDE; \
+ void DontReuse() MOZ_OVERRIDE; \
+ nsresult PushBack(const char *, uint32_t) MOZ_OVERRIDE; \
+ nsHttpConnection *TakeHttpConnection() MOZ_OVERRIDE; \
+ uint32_t CancelPipeline(nsresult originalReason) MOZ_OVERRIDE; \
+ nsAHttpTransaction::Classifier Classification() MOZ_OVERRIDE; \
/* \
Thes methods below have automatic definitions that just forward the \
function to a lower level connection object \
*/ \
void GetConnectionInfo(nsHttpConnectionInfo **result) \
+ MOZ_OVERRIDE \
{ \
if (!(fwdObject)) { \
*result = nullptr; \
return; \
} \
return (fwdObject)->GetConnectionInfo(result); \
} \
void GetSecurityInfo(nsISupports **result) \
+ MOZ_OVERRIDE \
{ \
if (!(fwdObject)) { \
*result = nullptr; \
return; \
} \
return (fwdObject)->GetSecurityInfo(result); \
} \
- nsresult ResumeSend() \
+ nsresult ResumeSend() MOZ_OVERRIDE \
{ \
if (!(fwdObject)) \
return NS_ERROR_FAILURE; \
return (fwdObject)->ResumeSend(); \
} \
- nsresult ResumeRecv() \
+ nsresult ResumeRecv() MOZ_OVERRIDE \
{ \
if (!(fwdObject)) \
return NS_ERROR_FAILURE; \
return (fwdObject)->ResumeRecv(); \
} \
- nsresult ForceSend() \
+ nsresult ForceSend() MOZ_OVERRIDE \
{ \
if (!(fwdObject)) \
return NS_ERROR_FAILURE; \
return (fwdObject)->ForceSend(); \
} \
- nsresult ForceRecv() \
+ nsresult ForceRecv() MOZ_OVERRIDE \
{ \
if (!(fwdObject)) \
return NS_ERROR_FAILURE; \
return (fwdObject)->ForceRecv(); \
} \
nsISocketTransport *Transport() \
+ MOZ_OVERRIDE \
{ \
if (!(fwdObject)) \
return nullptr; \
return (fwdObject)->Transport(); \
} \
- uint32_t Version() \
+ uint32_t Version() MOZ_OVERRIDE \
{ \
return (fwdObject) ? \
(fwdObject)->Version() : \
NS_HTTP_VERSION_UNKNOWN; \
} \
- bool IsProxyConnectInProgress() \
+ bool IsProxyConnectInProgress() MOZ_OVERRIDE \
{ \
return (fwdObject)->IsProxyConnectInProgress(); \
} \
- bool LastTransactionExpectedNoContent() \
+ bool LastTransactionExpectedNoContent() MOZ_OVERRIDE \
{ \
return (fwdObject)->LastTransactionExpectedNoContent(); \
} \
void SetLastTransactionExpectedNoContent(bool val) \
+ MOZ_OVERRIDE \
{ \
return (fwdObject)->SetLastTransactionExpectedNoContent(val); \
} \
void Classify(nsAHttpTransaction::Classifier newclass) \
+ MOZ_OVERRIDE \
{ \
if (fwdObject) \
return (fwdObject)->Classify(newclass); \
} \
- int64_t BytesWritten() \
+ int64_t BytesWritten() MOZ_OVERRIDE \
{ return fwdObject ? (fwdObject)->BytesWritten() : 0; } \
void SetSecurityCallbacks(nsIInterfaceRequestor* aCallbacks) \
+ MOZ_OVERRIDE \
{ \
if (fwdObject) \
(fwdObject)->SetSecurityCallbacks(aCallbacks); \
}
}} // namespace mozilla::net
#endif // nsAHttpConnection_h__
--- a/netwerk/protocol/http/nsAHttpTransaction.h
+++ b/netwerk/protocol/http/nsAHttpTransaction.h
@@ -189,38 +189,38 @@ public:
virtual void DisableSpdy() { }
virtual void ReuseConnectionOnRestartOK(bool) { }
};
NS_DEFINE_STATIC_IID_ACCESSOR(nsAHttpTransaction, NS_AHTTPTRANSACTION_IID)
#define NS_DECL_NSAHTTPTRANSACTION \
- void SetConnection(nsAHttpConnection *); \
- nsAHttpConnection *Connection(); \
- void GetSecurityCallbacks(nsIInterfaceRequestor **); \
+ void SetConnection(nsAHttpConnection *) MOZ_OVERRIDE; \
+ nsAHttpConnection *Connection() MOZ_OVERRIDE; \
+ void GetSecurityCallbacks(nsIInterfaceRequestor **) MOZ_OVERRIDE; \
void OnTransportStatus(nsITransport* transport, \
- nsresult status, uint64_t progress); \
- bool IsDone(); \
- nsresult Status(); \
- uint32_t Caps(); \
- void SetDNSWasRefreshed(); \
- uint64_t Available(); \
- virtual nsresult ReadSegments(nsAHttpSegmentReader *, uint32_t, uint32_t *); \
- virtual nsresult WriteSegments(nsAHttpSegmentWriter *, uint32_t, uint32_t *); \
- virtual void Close(nsresult reason); \
- nsHttpConnectionInfo *ConnectionInfo(); \
- void SetProxyConnectFailed(); \
- virtual nsHttpRequestHead *RequestHead(); \
- uint32_t Http1xTransactionCount(); \
- nsresult TakeSubTransactions(nsTArray<nsRefPtr<nsAHttpTransaction> > &outTransactions); \
- nsresult AddTransaction(nsAHttpTransaction *); \
- uint32_t PipelineDepth(); \
- nsresult SetPipelinePosition(int32_t); \
- int32_t PipelinePosition();
+ nsresult status, uint64_t progress) MOZ_OVERRIDE; \
+ bool IsDone() MOZ_OVERRIDE; \
+ nsresult Status() MOZ_OVERRIDE; \
+ uint32_t Caps() MOZ_OVERRIDE; \
+ void SetDNSWasRefreshed() MOZ_OVERRIDE; \
+ uint64_t Available() MOZ_OVERRIDE; \
+ virtual nsresult ReadSegments(nsAHttpSegmentReader *, uint32_t, uint32_t *) MOZ_OVERRIDE; \
+ virtual nsresult WriteSegments(nsAHttpSegmentWriter *, uint32_t, uint32_t *) MOZ_OVERRIDE; \
+ virtual void Close(nsresult reason) MOZ_OVERRIDE; \
+ nsHttpConnectionInfo *ConnectionInfo() MOZ_OVERRIDE; \
+ void SetProxyConnectFailed() MOZ_OVERRIDE; \
+ virtual nsHttpRequestHead *RequestHead() MOZ_OVERRIDE; \
+ uint32_t Http1xTransactionCount() MOZ_OVERRIDE; \
+ nsresult TakeSubTransactions(nsTArray<nsRefPtr<nsAHttpTransaction> > &outTransactions) MOZ_OVERRIDE; \
+ nsresult AddTransaction(nsAHttpTransaction *) MOZ_OVERRIDE; \
+ uint32_t PipelineDepth() MOZ_OVERRIDE; \
+ nsresult SetPipelinePosition(int32_t) MOZ_OVERRIDE; \
+ int32_t PipelinePosition() MOZ_OVERRIDE;
//-----------------------------------------------------------------------------
// nsAHttpSegmentReader
//-----------------------------------------------------------------------------
class nsAHttpSegmentReader
{
public:
@@ -241,29 +241,29 @@ public:
// SpdySession uses this to make sure frames are atomic.
virtual nsresult CommitToSegmentSize(uint32_t size, bool forceCommitment)
{
return NS_ERROR_FAILURE;
}
};
#define NS_DECL_NSAHTTPSEGMENTREADER \
- nsresult OnReadSegment(const char *, uint32_t, uint32_t *);
+ nsresult OnReadSegment(const char *, uint32_t, uint32_t *) MOZ_OVERRIDE;
//-----------------------------------------------------------------------------
// nsAHttpSegmentWriter
//-----------------------------------------------------------------------------
class nsAHttpSegmentWriter
{
public:
// any returned failure code stops segment iteration
virtual nsresult OnWriteSegment(char *segment,
uint32_t count,
uint32_t *countWritten) = 0;
};
#define NS_DECL_NSAHTTPSEGMENTWRITER \
- nsresult OnWriteSegment(char *, uint32_t, uint32_t *);
+ nsresult OnWriteSegment(char *, uint32_t, uint32_t *) MOZ_OVERRIDE;
}} // namespace mozilla::net
#endif // nsAHttpTransaction_h__
--- a/netwerk/protocol/http/nsHttpChannel.cpp
+++ b/netwerk/protocol/http/nsHttpChannel.cpp
@@ -5907,21 +5907,21 @@ class nsHttpChannelCacheKey MOZ_FINAL :
{
NS_DECL_ISUPPORTS
NS_DECL_NSISUPPORTSPRIMITIVE
NS_FORWARD_NSISUPPORTSPRUINT32(mSupportsPRUint32->)
// Both interfaces declares toString method with the same signature.
// Thus we have to delegate only to nsISupportsPRUint32 implementation.
- NS_IMETHOD GetData(nsACString & aData)
+ NS_IMETHOD GetData(nsACString & aData) MOZ_OVERRIDE
{
return mSupportsCString->GetData(aData);
}
- NS_IMETHOD SetData(const nsACString & aData)
+ NS_IMETHOD SetData(const nsACString & aData) MOZ_OVERRIDE
{
return mSupportsCString->SetData(aData);
}
public:
nsresult SetData(uint32_t aPostID, const nsACString& aKey);
protected:
--- a/netwerk/protocol/http/nsHttpChannel.h
+++ b/netwerk/protocol/http/nsHttpChannel.h
@@ -77,73 +77,73 @@ public:
NS_DECL_NSIASYNCVERIFYREDIRECTCALLBACK
NS_DECL_NSITHREADRETARGETABLEREQUEST
NS_DECL_NSIDNSLISTENER
NS_DECLARE_STATIC_IID_ACCESSOR(NS_HTTPCHANNEL_IID)
// nsIHttpAuthenticableChannel. We can't use
// NS_DECL_NSIHTTPAUTHENTICABLECHANNEL because it duplicates cancel() and
// others.
- NS_IMETHOD GetIsSSL(bool *aIsSSL);
- NS_IMETHOD GetProxyMethodIsConnect(bool *aProxyMethodIsConnect);
- NS_IMETHOD GetServerResponseHeader(nsACString & aServerResponseHeader);
- NS_IMETHOD GetProxyChallenges(nsACString & aChallenges);
- NS_IMETHOD GetWWWChallenges(nsACString & aChallenges);
- NS_IMETHOD SetProxyCredentials(const nsACString & aCredentials);
- NS_IMETHOD SetWWWCredentials(const nsACString & aCredentials);
- NS_IMETHOD OnAuthAvailable();
- NS_IMETHOD OnAuthCancelled(bool userCancel);
+ NS_IMETHOD GetIsSSL(bool *aIsSSL) MOZ_OVERRIDE;
+ NS_IMETHOD GetProxyMethodIsConnect(bool *aProxyMethodIsConnect) MOZ_OVERRIDE;
+ NS_IMETHOD GetServerResponseHeader(nsACString & aServerResponseHeader) MOZ_OVERRIDE;
+ NS_IMETHOD GetProxyChallenges(nsACString & aChallenges) MOZ_OVERRIDE;
+ NS_IMETHOD GetWWWChallenges(nsACString & aChallenges) MOZ_OVERRIDE;
+ NS_IMETHOD SetProxyCredentials(const nsACString & aCredentials) MOZ_OVERRIDE;
+ NS_IMETHOD SetWWWCredentials(const nsACString & aCredentials) MOZ_OVERRIDE;
+ NS_IMETHOD OnAuthAvailable() MOZ_OVERRIDE;
+ NS_IMETHOD OnAuthCancelled(bool userCancel) MOZ_OVERRIDE;
// Functions we implement from nsIHttpAuthenticableChannel but are
// declared in HttpBaseChannel must be implemented in this class. We
// just call the HttpBaseChannel:: impls.
- NS_IMETHOD GetLoadFlags(nsLoadFlags *aLoadFlags);
- NS_IMETHOD GetURI(nsIURI **aURI);
- NS_IMETHOD GetNotificationCallbacks(nsIInterfaceRequestor **aCallbacks);
- NS_IMETHOD GetLoadGroup(nsILoadGroup **aLoadGroup);
- NS_IMETHOD GetRequestMethod(nsACString& aMethod);
+ NS_IMETHOD GetLoadFlags(nsLoadFlags *aLoadFlags) MOZ_OVERRIDE;
+ NS_IMETHOD GetURI(nsIURI **aURI) MOZ_OVERRIDE;
+ NS_IMETHOD GetNotificationCallbacks(nsIInterfaceRequestor **aCallbacks) MOZ_OVERRIDE;
+ NS_IMETHOD GetLoadGroup(nsILoadGroup **aLoadGroup) MOZ_OVERRIDE;
+ NS_IMETHOD GetRequestMethod(nsACString& aMethod) MOZ_OVERRIDE;
nsHttpChannel();
virtual nsresult Init(nsIURI *aURI, uint32_t aCaps, nsProxyInfo *aProxyInfo,
uint32_t aProxyResolveFlags,
- nsIURI *aProxyURI);
+ nsIURI *aProxyURI) MOZ_OVERRIDE;
nsresult OnPush(const nsACString &uri, Http2PushedStream *pushedStream);
// Methods HttpBaseChannel didn't implement for us or that we override.
//
// nsIRequest
- NS_IMETHOD Cancel(nsresult status);
- NS_IMETHOD Suspend();
- NS_IMETHOD Resume();
+ NS_IMETHOD Cancel(nsresult status) MOZ_OVERRIDE;
+ NS_IMETHOD Suspend() MOZ_OVERRIDE;
+ NS_IMETHOD Resume() MOZ_OVERRIDE;
// nsIChannel
- NS_IMETHOD GetSecurityInfo(nsISupports **aSecurityInfo);
- NS_IMETHOD AsyncOpen(nsIStreamListener *listener, nsISupports *aContext);
+ NS_IMETHOD GetSecurityInfo(nsISupports **aSecurityInfo) MOZ_OVERRIDE;
+ NS_IMETHOD AsyncOpen(nsIStreamListener *listener, nsISupports *aContext) MOZ_OVERRIDE;
// nsIHttpChannelInternal
- NS_IMETHOD SetupFallbackChannel(const char *aFallbackKey);
+ NS_IMETHOD SetupFallbackChannel(const char *aFallbackKey) MOZ_OVERRIDE;
// nsISupportsPriority
- NS_IMETHOD SetPriority(int32_t value);
+ NS_IMETHOD SetPriority(int32_t value) MOZ_OVERRIDE;
// nsIClassOfService
- NS_IMETHOD SetClassFlags(uint32_t inFlags);
- NS_IMETHOD AddClassFlags(uint32_t inFlags);
- NS_IMETHOD ClearClassFlags(uint32_t inFlags);
+ NS_IMETHOD SetClassFlags(uint32_t inFlags) MOZ_OVERRIDE;
+ NS_IMETHOD AddClassFlags(uint32_t inFlags) MOZ_OVERRIDE;
+ NS_IMETHOD ClearClassFlags(uint32_t inFlags) MOZ_OVERRIDE;
// nsIResumableChannel
- NS_IMETHOD ResumeAt(uint64_t startPos, const nsACString& entityID);
+ NS_IMETHOD ResumeAt(uint64_t startPos, const nsACString& entityID) MOZ_OVERRIDE;
- NS_IMETHOD SetNotificationCallbacks(nsIInterfaceRequestor *aCallbacks);
- NS_IMETHOD SetLoadGroup(nsILoadGroup *aLoadGroup);
+ NS_IMETHOD SetNotificationCallbacks(nsIInterfaceRequestor *aCallbacks) MOZ_OVERRIDE;
+ NS_IMETHOD SetLoadGroup(nsILoadGroup *aLoadGroup) MOZ_OVERRIDE;
// nsITimedChannel
- NS_IMETHOD GetDomainLookupStart(mozilla::TimeStamp *aDomainLookupStart);
- NS_IMETHOD GetDomainLookupEnd(mozilla::TimeStamp *aDomainLookupEnd);
- NS_IMETHOD GetConnectStart(mozilla::TimeStamp *aConnectStart);
- NS_IMETHOD GetConnectEnd(mozilla::TimeStamp *aConnectEnd);
- NS_IMETHOD GetRequestStart(mozilla::TimeStamp *aRequestStart);
- NS_IMETHOD GetResponseStart(mozilla::TimeStamp *aResponseStart);
- NS_IMETHOD GetResponseEnd(mozilla::TimeStamp *aResponseEnd);
+ NS_IMETHOD GetDomainLookupStart(mozilla::TimeStamp *aDomainLookupStart) MOZ_OVERRIDE;
+ NS_IMETHOD GetDomainLookupEnd(mozilla::TimeStamp *aDomainLookupEnd) MOZ_OVERRIDE;
+ NS_IMETHOD GetConnectStart(mozilla::TimeStamp *aConnectStart) MOZ_OVERRIDE;
+ NS_IMETHOD GetConnectEnd(mozilla::TimeStamp *aConnectEnd) MOZ_OVERRIDE;
+ NS_IMETHOD GetRequestStart(mozilla::TimeStamp *aRequestStart) MOZ_OVERRIDE;
+ NS_IMETHOD GetResponseStart(mozilla::TimeStamp *aResponseStart) MOZ_OVERRIDE;
+ NS_IMETHOD GetResponseEnd(mozilla::TimeStamp *aResponseEnd) MOZ_OVERRIDE;
public: /* internal necko use only */
void InternalSetUploadStream(nsIInputStream *uploadStream)
{ mUploadStream = uploadStream; }
void SetUploadStreamHasHeaders(bool hasHeaders)
{ mUploadStreamHasHeaders = hasHeaders; }
@@ -256,17 +256,17 @@ private:
// redirection specific methods
void HandleAsyncRedirect();
void HandleAsyncAPIRedirect();
nsresult ContinueHandleAsyncRedirect(nsresult);
void HandleAsyncNotModified();
void HandleAsyncFallback();
nsresult ContinueHandleAsyncFallback(nsresult);
nsresult PromptTempRedirect();
- virtual nsresult SetupReplacementChannel(nsIURI *, nsIChannel *, bool preserveMethod);
+ virtual nsresult SetupReplacementChannel(nsIURI *, nsIChannel *, bool preserveMethod) MOZ_OVERRIDE;
// proxy specific methods
nsresult ProxyFailover();
nsresult AsyncDoReplaceWithProxy(nsIProxyInfo *);
nsresult ContinueDoReplaceWithProxy(nsresult);
nsresult ResolveProxy();
// cache specific methods
@@ -468,17 +468,17 @@ private:
nsresult WaitForRedirectCallback();
void PushRedirectAsyncFunc(nsContinueRedirectionFunc func);
void PopRedirectAsyncFunc(nsContinueRedirectionFunc func);
nsCString mUsername;
protected:
- virtual void DoNotifyListenerCleanup();
+ virtual void DoNotifyListenerCleanup() MOZ_OVERRIDE;
private: // cache telemetry
bool mDidReval;
};
NS_DEFINE_STATIC_IID_ACCESSOR(nsHttpChannel, NS_HTTPCHANNEL_IID)
} } // namespace mozilla::net
--- a/netwerk/protocol/http/nsHttpPipeline.h
+++ b/netwerk/protocol/http/nsHttpPipeline.h
@@ -52,17 +52,17 @@ private:
{
if (mResponseQ.Length() == 0)
return nullptr;
return mResponseQ[i];
}
// overload of nsAHttpTransaction::QueryPipeline()
- nsHttpPipeline *QueryPipeline();
+ nsHttpPipeline *QueryPipeline() MOZ_OVERRIDE;
nsRefPtr<nsAHttpConnection> mConnection;
nsTArray<nsAHttpTransaction*> mRequestQ; // array of transactions
nsTArray<nsAHttpTransaction*> mResponseQ; // array of transactions
nsresult mStatus;
// these flags indicate whether or not the first request or response
// is partial. a partial request means that Request(0) has been
--- a/netwerk/protocol/http/nsHttpTransaction.h
+++ b/netwerk/protocol/http/nsHttpTransaction.h
@@ -127,17 +127,17 @@ public:
void PrintDiagnostics(nsCString &log);
// Sets mPendingTime to the current time stamp or to a null time stamp (if now is false)
void SetPendingTime(bool now = true) { mPendingTime = now ? TimeStamp::Now() : TimeStamp(); }
const TimeStamp GetPendingTime() { return mPendingTime; }
bool UsesPipelining() const { return mCaps & NS_HTTP_ALLOW_PIPELINING; }
// overload of nsAHttpTransaction::LoadGroupConnectionInfo()
- nsILoadGroupConnectionInfo *LoadGroupConnectionInfo() { return mLoadGroupCI.get(); }
+ nsILoadGroupConnectionInfo *LoadGroupConnectionInfo() MOZ_OVERRIDE { return mLoadGroupCI.get(); }
void SetLoadGroupConnectionInfo(nsILoadGroupConnectionInfo *aLoadGroupCI) { mLoadGroupCI = aLoadGroupCI; }
void DispatchedAsBlocking();
void RemoveDispatchedAsBlocking();
nsHttpTransaction *QueryHttpTransaction() MOZ_OVERRIDE { return this; }
Http2PushedStream *GetPushedStream() { return mPushedStream; }
Http2PushedStream *TakePushedStream()
@@ -367,17 +367,17 @@ public:
// returns true. The function is called repeatedly until it returns true.
bool TryToRunPacedRequest();
// ATokenBucketEvent pure virtual implementation. Called by the token bucket
// when the transaction is ready to run. If this happens asynchrounously to
// token bucket submission the transaction just posts an event that causes
// the pending transaction queue to be rerun (and TryToRunPacedRequest() to
// be run again.
- void OnTokenBucketAdmitted(); // ATokenBucketEvent
+ void OnTokenBucketAdmitted() MOZ_OVERRIDE; // ATokenBucketEvent
// CancelPacing() can be used to tell the token bucket to remove this
// transaction from the list of pending transactions. This is used when a
// transaction is believed to be HTTP/1 (and thus subject to rate pacing)
// but later can be dispatched via spdy (not subject to rate pacing).
void CancelPacing(nsresult reason);
private:
--- a/netwerk/protocol/websocket/BaseWebSocketChannel.h
+++ b/netwerk/protocol/websocket/BaseWebSocketChannel.h
@@ -26,37 +26,37 @@ class BaseWebSocketChannel : public nsIW
public nsIThreadRetargetableRequest
{
public:
BaseWebSocketChannel();
NS_DECL_NSIPROTOCOLHANDLER
NS_DECL_NSITHREADRETARGETABLEREQUEST
- NS_IMETHOD QueryInterface(const nsIID & uuid, void **result) = 0;
- NS_IMETHOD_(MozExternalRefCountType ) AddRef(void) = 0;
- NS_IMETHOD_(MozExternalRefCountType ) Release(void) = 0;
+ NS_IMETHOD QueryInterface(const nsIID & uuid, void **result) MOZ_OVERRIDE = 0;
+ NS_IMETHOD_(MozExternalRefCountType ) AddRef(void) MOZ_OVERRIDE = 0;
+ NS_IMETHOD_(MozExternalRefCountType ) Release(void) MOZ_OVERRIDE = 0;
// Partial implementation of nsIWebSocketChannel
//
- NS_IMETHOD GetOriginalURI(nsIURI **aOriginalURI);
- NS_IMETHOD GetURI(nsIURI **aURI);
- NS_IMETHOD GetNotificationCallbacks(nsIInterfaceRequestor **aNotificationCallbacks);
- NS_IMETHOD SetNotificationCallbacks(nsIInterfaceRequestor *aNotificationCallbacks);
- NS_IMETHOD GetLoadGroup(nsILoadGroup **aLoadGroup);
- NS_IMETHOD SetLoadGroup(nsILoadGroup *aLoadGroup);
- NS_IMETHOD SetLoadInfo(nsILoadInfo *aLoadInfo);
- NS_IMETHOD GetLoadInfo(nsILoadInfo **aLoadInfo);
- NS_IMETHOD GetExtensions(nsACString &aExtensions);
- NS_IMETHOD GetProtocol(nsACString &aProtocol);
- NS_IMETHOD SetProtocol(const nsACString &aProtocol);
- NS_IMETHOD GetPingInterval(uint32_t *aSeconds);
- NS_IMETHOD SetPingInterval(uint32_t aSeconds);
- NS_IMETHOD GetPingTimeout(uint32_t *aSeconds);
- NS_IMETHOD SetPingTimeout(uint32_t aSeconds);
+ NS_IMETHOD GetOriginalURI(nsIURI **aOriginalURI) MOZ_OVERRIDE;
+ NS_IMETHOD GetURI(nsIURI **aURI) MOZ_OVERRIDE;
+ NS_IMETHOD GetNotificationCallbacks(nsIInterfaceRequestor **aNotificationCallbacks) MOZ_OVERRIDE;
+ NS_IMETHOD SetNotificationCallbacks(nsIInterfaceRequestor *aNotificationCallbacks) MOZ_OVERRIDE;
+ NS_IMETHOD GetLoadGroup(nsILoadGroup **aLoadGroup) MOZ_OVERRIDE;
+ NS_IMETHOD SetLoadGroup(nsILoadGroup *aLoadGroup) MOZ_OVERRIDE;
+ NS_IMETHOD SetLoadInfo(nsILoadInfo *aLoadInfo) MOZ_OVERRIDE;
+ NS_IMETHOD GetLoadInfo(nsILoadInfo **aLoadInfo) MOZ_OVERRIDE;
+ NS_IMETHOD GetExtensions(nsACString &aExtensions) MOZ_OVERRIDE;
+ NS_IMETHOD GetProtocol(nsACString &aProtocol) MOZ_OVERRIDE;
+ NS_IMETHOD SetProtocol(const nsACString &aProtocol) MOZ_OVERRIDE;
+ NS_IMETHOD GetPingInterval(uint32_t *aSeconds) MOZ_OVERRIDE;
+ NS_IMETHOD SetPingInterval(uint32_t aSeconds) MOZ_OVERRIDE;
+ NS_IMETHOD GetPingTimeout(uint32_t *aSeconds) MOZ_OVERRIDE;
+ NS_IMETHOD SetPingTimeout(uint32_t aSeconds) MOZ_OVERRIDE;
// Off main thread URI access.
virtual void GetEffectiveURL(nsAString& aEffectiveURL) const = 0;
virtual bool IsEncrypted() const = 0;
protected:
nsCOMPtr<nsIURI> mOriginalURI;
nsCOMPtr<nsIURI> mURI;
--- a/netwerk/protocol/websocket/WebSocketChannel.cpp
+++ b/netwerk/protocol/websocket/WebSocketChannel.cpp
@@ -557,17 +557,17 @@ public:
CallOnMessageAvailable(WebSocketChannel *aChannel,
nsCString &aData,
int32_t aLen)
: mChannel(aChannel),
mData(aData),
mLen(aLen) {}
- NS_IMETHOD Run()
+ NS_IMETHOD Run() MOZ_OVERRIDE
{
MOZ_ASSERT(mChannel->IsOnTargetThread());
if (mLen < 0)
mChannel->mListener->OnMessageAvailable(mChannel->mContext, mData);
else
mChannel->mListener->OnBinaryMessageAvailable(mChannel->mContext, mData);
return NS_OK;
@@ -591,17 +591,17 @@ class CallOnStop MOZ_FINAL : public nsIR
public:
NS_DECL_THREADSAFE_ISUPPORTS
CallOnStop(WebSocketChannel *aChannel,
nsresult aReason)
: mChannel(aChannel),
mReason(aReason) {}
- NS_IMETHOD Run()
+ NS_IMETHOD Run() MOZ_OVERRIDE
{
MOZ_ASSERT(mChannel->IsOnTargetThread());
nsWSAdmissionManager::OnStopSession(mChannel, mReason);
if (mChannel->mListener) {
mChannel->mListener->OnStop(mChannel->mContext, mReason);
mChannel->mListener = nullptr;
@@ -629,17 +629,17 @@ public:
CallOnServerClose(WebSocketChannel *aChannel,
uint16_t aCode,
nsCString &aReason)
: mChannel(aChannel),
mCode(aCode),
mReason(aReason) {}
- NS_IMETHOD Run()
+ NS_IMETHOD Run() MOZ_OVERRIDE
{
MOZ_ASSERT(mChannel->IsOnTargetThread());
mChannel->mListener->OnServerClose(mChannel->mContext, mCode, mReason);
return NS_OK;
}
private:
@@ -692,17 +692,17 @@ public:
nsISocketTransport *aTransport,
nsIAsyncInputStream *aSocketIn,
nsIAsyncOutputStream *aSocketOut)
: mChannel(aChannel),
mTransport(aTransport),
mSocketIn(aSocketIn),
mSocketOut(aSocketOut) {}
- NS_IMETHOD Run()
+ NS_IMETHOD Run() MOZ_OVERRIDE
{
LOG(("WebSocketChannel::CallOnTransportAvailable %p\n", this));
return mChannel->OnTransportAvailable(mTransport, mSocketIn, mSocketOut);
}
private:
~CallOnTransportAvailable() {}
@@ -1056,17 +1056,17 @@ private:
class OutboundEnqueuer MOZ_FINAL : public nsIRunnable
{
public:
NS_DECL_THREADSAFE_ISUPPORTS
OutboundEnqueuer(WebSocketChannel *aChannel, OutboundMessage *aMsg)
: mChannel(aChannel), mMessage(aMsg) {}
- NS_IMETHOD Run()
+ NS_IMETHOD Run() MOZ_OVERRIDE
{
mChannel->EnqueueOutgoingMessage(mChannel->mOutgoingMessages, mMessage);
return NS_OK;
}
private:
~OutboundEnqueuer() {}
--- a/netwerk/protocol/websocket/WebSocketChannel.h
+++ b/netwerk/protocol/websocket/WebSocketChannel.h
@@ -83,22 +83,22 @@ public:
NS_DECL_NSICHANNELEVENTSINK
NS_DECL_NSIOBSERVER
// nsIWebSocketChannel methods BaseWebSocketChannel didn't implement for us
//
NS_IMETHOD AsyncOpen(nsIURI *aURI,
const nsACString &aOrigin,
nsIWebSocketListener *aListener,
- nsISupports *aContext);
- NS_IMETHOD Close(uint16_t aCode, const nsACString & aReason);
- NS_IMETHOD SendMsg(const nsACString &aMsg);
- NS_IMETHOD SendBinaryMsg(const nsACString &aMsg);
- NS_IMETHOD SendBinaryStream(nsIInputStream *aStream, uint32_t length);
- NS_IMETHOD GetSecurityInfo(nsISupports **aSecurityInfo);
+ nsISupports *aContext) MOZ_OVERRIDE;
+ NS_IMETHOD Close(uint16_t aCode, const nsACString & aReason) MOZ_OVERRIDE;
+ NS_IMETHOD SendMsg(const nsACString &aMsg) MOZ_OVERRIDE;
+ NS_IMETHOD SendBinaryMsg(const nsACString &aMsg) MOZ_OVERRIDE;
+ NS_IMETHOD SendBinaryStream(nsIInputStream *aStream, uint32_t length) MOZ_OVERRIDE;
+ NS_IMETHOD GetSecurityInfo(nsISupports **aSecurityInfo) MOZ_OVERRIDE;
WebSocketChannel();
static void Shutdown();
bool IsOnTargetThread();
// Off main thread URI access.
void GetEffectiveURL(nsAString& aEffectiveURL) const MOZ_OVERRIDE;
bool IsEncrypted() const MOZ_OVERRIDE;
--- a/netwerk/protocol/websocket/WebSocketChannelChild.h
+++ b/netwerk/protocol/websocket/WebSocketChannelChild.h
@@ -24,23 +24,23 @@ class WebSocketChannelChild : public Bas
explicit WebSocketChannelChild(bool aSecure);
NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSITHREADRETARGETABLEREQUEST
// nsIWebSocketChannel methods BaseWebSocketChannel didn't implement for us
//
NS_IMETHOD AsyncOpen(nsIURI *aURI, const nsACString &aOrigin,
- nsIWebSocketListener *aListener, nsISupports *aContext);
- NS_IMETHOD Close(uint16_t code, const nsACString & reason);
- NS_IMETHOD SendMsg(const nsACString &aMsg);
- NS_IMETHOD SendBinaryMsg(const nsACString &aMsg);
- NS_IMETHOD SendBinaryStream(nsIInputStream *aStream, uint32_t aLength);
+ nsIWebSocketListener *aListener, nsISupports *aContext) MOZ_OVERRIDE;
+ NS_IMETHOD Close(uint16_t code, const nsACString & reason) MOZ_OVERRIDE;
+ NS_IMETHOD SendMsg(const nsACString &aMsg) MOZ_OVERRIDE;
+ NS_IMETHOD SendBinaryMsg(const nsACString &aMsg) MOZ_OVERRIDE;
+ NS_IMETHOD SendBinaryStream(nsIInputStream *aStream, uint32_t aLength) MOZ_OVERRIDE;
nsresult SendBinaryStream(OptionalInputStreamParams *aStream, uint32_t aLength);
- NS_IMETHOD GetSecurityInfo(nsISupports **aSecurityInfo);
+ NS_IMETHOD GetSecurityInfo(nsISupports **aSecurityInfo) MOZ_OVERRIDE;
void AddIPDLReference();
void ReleaseIPDLReference();
// Off main thread URI access.
void GetEffectiveURL(nsAString& aEffectiveURL) const MOZ_OVERRIDE;
bool IsEncrypted() const MOZ_OVERRIDE;
