Add FX_OVERRIDE and use it for virtual functions of FX_FINAL classes.

core/src/fxcrt/extension.h

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #ifndef _FXCRT_EXTENSION_IMP_
 #define _FXCRT_EXTENSION_IMP_
 
 class IFXCRT_FileAccess
@@ skipping 18 matching lines @@
 class CFX_CRTFileStream FX_FINAL : public IFX_FileStream, public CFX_Object
 {
 public:
     CFX_CRTFileStream(IFXCRT_FileAccess* pFA) : m_pFile(pFA), m_dwCount(1), m_bUseRange(FALSE), m_nOffset(0), m_nSize(0) {}
     ~CFX_CRTFileStream()
     {
         if (m_pFile) {
             m_pFile->Release();
         }
     }
-    virtual IFX_FileStream*             Retain()
+    virtual IFX_FileStream*             Retain() FX_OVERRIDE
     {
         m_dwCount ++;
         return this;
     }
-    virtual void                                Release()
+    virtual void                                Release() FX_OVERRIDE
     {
         FX_DWORD nCount = -- m_dwCount;
         if (!nCount) {
             delete this;
         }
     }
-    virtual FX_FILESIZE                 GetSize()
+    virtual FX_FILESIZE                 GetSize() FX_OVERRIDE
     {
         return m_bUseRange ? m_nSize : m_pFile->GetSize();
     }
-    virtual FX_BOOL                             IsEOF()
+    virtual FX_BOOL                             IsEOF() FX_OVERRIDE
     {
         return GetPosition() >= GetSize();
     }
-    virtual FX_FILESIZE                 GetPosition()
+    virtual FX_FILESIZE                 GetPosition() FX_OVERRIDE
     {
         FX_FILESIZE pos = m_pFile->GetPosition();
         if (m_bUseRange) {
             pos -= m_nOffset;
         }
         return pos;
     }
-    virtual FX_BOOL                             SetRange(FX_FILESIZE offset, FX_FILESIZE size)
+    virtual FX_BOOL                             SetRange(FX_FILESIZE offset, FX_FILESIZE size) FX_OVERRIDE
     {
         if (offset < 0 || size < 0) {
             return FALSE;
         }
      
         FX_SAFE_FILESIZE pos = size;
         pos += offset;
 
         if (!pos.IsValid() || pos.ValueOrDie() > m_pFile->GetSize()) {
             return FALSE;
         }
 
         m_nOffset = offset, m_nSize = size;
         m_bUseRange = TRUE;
         m_pFile->SetPosition(m_nOffset);
         return TRUE;
     }
-    virtual void                                ClearRange()
+    virtual void                                ClearRange() FX_OVERRIDE
     {
         m_bUseRange = FALSE;
     }
-    virtual FX_BOOL                             ReadBlock(void* buffer, FX_FILESIZE offset, size_t size)
+    virtual FX_BOOL                             ReadBlock(void* buffer, FX_FILESIZE offset, size_t size) FX_OVERRIDE
     {
         if (m_bUseRange && offset < 0) {
             return FALSE;
         }
         FX_SAFE_FILESIZE pos = offset;
 
         if (m_bUseRange) {
             pos += m_nOffset;
             if (!pos.IsValid() || pos.ValueOrDie() > (size_t)GetSize()) {
                 return FALSE;
             }
         }
         return (FX_BOOL)m_pFile->ReadPos(buffer, size, pos.ValueOrDie());
     }
-    virtual size_t                              ReadBlock(void* buffer, size_t size)
+    virtual size_t                              ReadBlock(void* buffer, size_t size) FX_OVERRIDE
     {
         if (m_bUseRange) {
             FX_FILESIZE availSize = m_nOffset + m_nSize - m_pFile->GetPosition();
             if ((size_t)availSize < size) {
                 size -= size - (size_t)availSize;
             }
         }
         return m_pFile->Read(buffer, size);
     }
-    virtual     FX_BOOL                         WriteBlock(const void* buffer, FX_FILESIZE offset, size_t size)
+    virtual     FX_BOOL                         WriteBlock(const void* buffer, FX_FILESIZE offset, size_t size) FX_OVERRIDE
     {
         if (m_bUseRange) {
             offset += m_nOffset;
         }
         return (FX_BOOL)m_pFile->WritePos(buffer, size, offset);
     }
-    virtual FX_BOOL                             Flush()
+    virtual FX_BOOL                             Flush()  FX_OVERRIDE
     {
         return m_pFile->Flush();
     }
     IFXCRT_FileAccess*  m_pFile;
     FX_DWORD                    m_dwCount;
     FX_BOOL                             m_bUseRange;
     FX_FILESIZE                 m_nOffset;
     FX_FILESIZE                 m_nSize;
 };
 #define FX_MEMSTREAM_BlockSize          (64 * 1024)
@@ skipping 25 matching lines @@
     }
     ~CFX_MemoryStream()
     {
         if (m_dwFlags & FX_MEMSTREAM_TakeOver) {
             for (FX_INT32 i = 0; i < m_Blocks.GetSize(); i++) {
                 FX_Free((FX_LPBYTE)m_Blocks[i]);
             }
         }
         m_Blocks.RemoveAll();
     }
-    virtual IFX_FileStream*             Retain()
+    virtual IFX_FileStream*             Retain()  FX_OVERRIDE
     {
         m_dwCount ++;
         return this;
     }
-    virtual void                                Release()
+    virtual void                                Release()  FX_OVERRIDE
     {
         FX_DWORD nCount = -- m_dwCount;
         if (nCount) {
             return;
         }
         delete this;
     }
-    virtual FX_FILESIZE                 GetSize()
+    virtual FX_FILESIZE                 GetSize()  FX_OVERRIDE
     {
         return m_bUseRange ? (FX_FILESIZE) m_nSize : (FX_FILESIZE)m_nCurSize;
     }
-    virtual FX_BOOL                             IsEOF()
+    virtual FX_BOOL                             IsEOF()  FX_OVERRIDE
     {
         return m_nCurPos >= (size_t)GetSize();
     }
-    virtual FX_FILESIZE                 GetPosition()
+    virtual FX_FILESIZE                 GetPosition()  FX_OVERRIDE
     {
         FX_FILESIZE pos = (FX_FILESIZE)m_nCurPos;
         if (m_bUseRange) {
             pos -= (FX_FILESIZE)m_nOffset;
         }
         return pos;
     }
-    virtual FX_BOOL                             SetRange(FX_FILESIZE offset, FX_FILESIZE size)
+    virtual FX_BOOL                             SetRange(FX_FILESIZE offset, FX_FILESIZE size)  FX_OVERRIDE
     {
         if (offset < 0 || size < 0) {
             return FALSE;
         }
         FX_SAFE_FILESIZE range = size;
         range += offset;
         if (!range.IsValid() || range.ValueOrDie() > m_nCurSize) {
             return FALSE;
         }
         
         m_nOffset = (size_t)offset, m_nSize = (size_t)size;
         m_bUseRange = TRUE;
         m_nCurPos = m_nOffset;
         return TRUE;
     }
-    virtual void                                ClearRange()
+    virtual void                                ClearRange()  FX_OVERRIDE
     {
         m_bUseRange = FALSE;
     }
-    virtual FX_BOOL                             ReadBlock(void* buffer, FX_FILESIZE offset, size_t size)
+    virtual FX_BOOL                             ReadBlock(void* buffer, FX_FILESIZE offset, size_t size)  FX_OVERRIDE
     {
         if (!buffer || !size) {
             return FALSE;
         }
 
         FX_SAFE_FILESIZE safeOffset = offset;
         if (m_bUseRange) {
             safeOffset += m_nOffset;
         }
          
@@ skipping 22 matching lines @@
                 nRead = size;
             }
             FXSYS_memcpy32(buffer, (FX_LPBYTE)m_Blocks[(int)nStartBlock] + (size_t)offset, nRead);
             buffer = ((FX_LPBYTE)buffer) + nRead;
             size -= nRead;
             nStartBlock ++;
             offset = 0;
         }
         return TRUE;
     }
-    virtual size_t                              ReadBlock(void* buffer, size_t size)
+    virtual size_t                              ReadBlock(void* buffer, size_t size)  FX_OVERRIDE
     {
         if (m_nCurPos >= m_nCurSize) {
             return 0;
         }
         if (m_bUseRange) {
             size_t availSize = m_nOffset + m_nSize - m_nCurPos;
             if (availSize < size) {
                 size -= size - (size_t)availSize;
             }
         }
         size_t nRead = FX_MIN(size, m_nCurSize - m_nCurPos);
         if (!ReadBlock(buffer, (FX_INT32)m_nCurPos, nRead)) {
             return 0;
         }
         return nRead;
     }
-    virtual     FX_BOOL                         WriteBlock(const void* buffer, FX_FILESIZE offset, size_t size)
+    virtual     FX_BOOL                         WriteBlock(const void* buffer, FX_FILESIZE offset, size_t size)  FX_OVERRIDE
     {
         if (!buffer || !size) {
             return FALSE;
         }
         if (m_bUseRange) {
             offset += (FX_FILESIZE)m_nOffset;
         }
         if (m_dwFlags & FX_MEMSTREAM_Consecutive) {
             FX_SAFE_SIZE_T newPos = size; 
             newPos += offset;
@@ skipping 39 matching lines @@
                 nWrite = size;
             }
             FXSYS_memcpy32((FX_LPBYTE)m_Blocks[(int)nStartBlock] + (size_t)offset, buffer, nWrite);
             buffer = ((FX_LPBYTE)buffer) + nWrite;
             size -= nWrite;
             nStartBlock ++;
             offset = 0;
         }
         return TRUE;
     }
-    virtual FX_BOOL                             Flush()
+    virtual FX_BOOL                             Flush()  FX_OVERRIDE
     {
         return TRUE;
     }
-    virtual FX_BOOL                             IsConsecutive() const
+    virtual FX_BOOL                             IsConsecutive() const  FX_OVERRIDE
     {
         return m_dwFlags & FX_MEMSTREAM_Consecutive;
     }
-    virtual void                                EstimateSize(size_t nInitSize, size_t nGrowSize)
+    virtual void                                EstimateSize(size_t nInitSize, size_t nGrowSize)  FX_OVERRIDE
     {
         if (m_dwFlags & FX_MEMSTREAM_Consecutive) {
             if (m_Blocks.GetSize() < 1) {
                 FX_LPBYTE pBlock = FX_Alloc(FX_BYTE, FX_MAX(nInitSize, 4096));
                 if (pBlock) {
                     m_Blocks.Add(pBlock);
                 }
             }
             m_nGrowSize = FX_MAX(nGrowSize, 4096);
         } else if (m_Blocks.GetSize() < 1) {
             m_nGrowSize = FX_MAX(nGrowSize, 4096);
         }
     }
-    virtual FX_LPBYTE                   GetBuffer() const
+    virtual FX_LPBYTE                   GetBuffer() const  FX_OVERRIDE
     {
         return m_Blocks.GetSize() ? (FX_LPBYTE)m_Blocks[0] : NULL;
     }
-    virtual void                                AttachBuffer(FX_LPBYTE pBuffer, size_t nSize, FX_BOOL bTakeOver = FALSE)
+    virtual void                                AttachBuffer(FX_LPBYTE pBuffer, size_t nSize, FX_BOOL bTakeOver = FALSE)  FX_OVERRIDE
     {
         if (!(m_dwFlags & FX_MEMSTREAM_Consecutive)) {
             return;
         }
         m_Blocks.RemoveAll();
         m_Blocks.Add(pBuffer);
         m_nTotalSize = m_nCurSize = nSize;
         m_nCurPos = 0;
         m_dwFlags = FX_MEMSTREAM_Consecutive | (bTakeOver ? FX_MEMSTREAM_TakeOver : 0);
         ClearRange();
     }
-    virtual void                                DetachBuffer()
+    virtual void                                DetachBuffer()  FX_OVERRIDE
     {
         if (!(m_dwFlags & FX_MEMSTREAM_Consecutive)) {
             return;
         }
         m_Blocks.RemoveAll();
         m_nTotalSize = m_nCurSize = m_nCurPos = 0;
         m_dwFlags = FX_MEMSTREAM_TakeOver;
         ClearRange();
     }
 protected:
@@ skipping 48 matching lines @@
     FX_DWORD mt[MT_N];
 } FX_MTRANDOMCONTEXT, * FX_LPMTRANDOMCONTEXT;
 typedef FX_MTRANDOMCONTEXT const * FX_LPCMTRANDOMCONTEXT;
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
 FX_BOOL FX_GenerateCryptoRandom(FX_LPDWORD pBuffer, FX_INT32 iCount);
 #endif
 #ifdef __cplusplus
 }
 #endif
 #endif