Bug 1117042 - Mark virtual overridden functions as MOZ_OVERRIDE in netwerk; r=mcmanus
authorEhsan Akhgari <ehsan@mozilla.com>
Fri, 02 Jan 2015 01:24:13 -0500
changeset 221847 616160513dea78322030f3b1250adc6ee9e24c94
parent 221846 47134f7bf549b5d079b239fb3c58886e5403069a
child 221848 60f061396cad20d99bfea1410fe92eb93ec9a2b8
push id53435
push usereakhgari@mozilla.com
push dateFri, 02 Jan 2015 14:05:34 +0000
treeherdermozilla-inbound@616160513dea [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmcmanus
bugs1117042
milestone37.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1117042 - Mark virtual overridden functions as MOZ_OVERRIDE in netwerk; r=mcmanus
netwerk/base/src/BackgroundFileSaver.h
netwerk/base/src/ProxyAutoConfig.cpp
netwerk/base/src/nsAsyncStreamCopier.h
netwerk/base/src/nsBufferedStreams.h
netwerk/base/src/nsFileStreams.h
netwerk/base/src/nsIOService.h
netwerk/base/src/nsInputStreamChannel.h
netwerk/base/src/nsProtocolProxyService.cpp
netwerk/base/src/nsServerSocket.h
netwerk/base/src/nsSimpleNestedURI.h
netwerk/base/src/nsSimpleURI.h
netwerk/base/src/nsSocketTransport2.h
netwerk/base/src/nsStandardURL.h
netwerk/base/src/nsUDPSocket.h
netwerk/base/src/nsURLParsers.h
netwerk/cache/nsApplicationCacheService.cpp
netwerk/cache/nsCacheEntryDescriptor.h
netwerk/cache/nsCacheService.cpp
netwerk/cache/nsDiskCacheDeviceSQL.h
netwerk/cache2/CacheEntry.h
netwerk/cache2/CacheFile.cpp
netwerk/cache2/CacheFile.h
netwerk/cache2/CacheFileChunk.h
netwerk/cache2/CacheFileInputStream.h
netwerk/cache2/CacheFileMetadata.h
netwerk/cache2/CacheFileOutputStream.h
netwerk/cache2/CacheIndex.cpp
netwerk/cache2/CacheIndex.h
netwerk/cache2/CacheStorageService.cpp
netwerk/cache2/OldWrappers.h
netwerk/cookie/nsCookieService.cpp
netwerk/dns/DNSRequestParent.h
netwerk/dns/nsDNSService2.cpp
netwerk/ipc/NeckoParent.h
netwerk/protocol/app/AppProtocolHandler.cpp
netwerk/protocol/device/nsDeviceChannel.h
netwerk/protocol/file/nsFileChannel.cpp
netwerk/protocol/file/nsFileChannel.h
netwerk/protocol/ftp/FTPChannelChild.h
netwerk/protocol/ftp/nsFTPChannel.h
netwerk/protocol/ftp/nsFtpConnectionThread.h
netwerk/protocol/http/Http2Push.h
netwerk/protocol/http/Http2Session.h
netwerk/protocol/http/HttpBaseChannel.h
netwerk/protocol/http/HttpChannelChild.h
netwerk/protocol/http/SpdySession31.h
netwerk/protocol/http/SpdyZlibReporter.h
netwerk/protocol/http/TunnelUtils.cpp
netwerk/protocol/http/TunnelUtils.h
netwerk/protocol/http/nsAHttpConnection.h
netwerk/protocol/http/nsAHttpTransaction.h
netwerk/protocol/http/nsHttpChannel.cpp
netwerk/protocol/http/nsHttpChannel.h
netwerk/protocol/http/nsHttpPipeline.h
netwerk/protocol/http/nsHttpTransaction.h
netwerk/protocol/websocket/BaseWebSocketChannel.h
netwerk/protocol/websocket/WebSocketChannel.cpp
netwerk/protocol/websocket/WebSocketChannel.h
netwerk/protocol/websocket/WebSocketChannelChild.h
--- 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;