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 235135 616160513dea78322030f3b1250adc6ee9e24c94
parent 235134 47134f7bf549b5d079b239fb3c58886e5403069a
child 235136 60f061396cad20d99bfea1410fe92eb93ec9a2b8
push id4489
push userraliiev@mozilla.com
push dateMon, 23 Feb 2015 15:17:55 +0000
treeherdermozilla-esr52@fd7c3dc24146 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmcmanus
bugs1117042
milestone37.0a1
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;