Add more overrides.

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 CORE_SRC_FXCRT_EXTENSION_H_
 #define CORE_SRC_FXCRT_EXTENSION_H_
 
 #include "core/include/fxcrt/fx_basic.h"
@@ skipping 86 matching lines @@
         FX_MEMSTREAM_Consecutive | (bTakeOver ? FX_MEMSTREAM_TakeOver : 0);
   }
   ~CFX_MemoryStream() override {
     if (m_dwFlags & FX_MEMSTREAM_TakeOver) {
       for (int32_t i = 0; i < m_Blocks.GetSize(); i++) {
         FX_Free((uint8_t*)m_Blocks[i]);
       }
     }
     m_Blocks.RemoveAll();
   }
-  virtual IFX_FileStream* Retain() override {
+
+  // IFX_MemoryStream:
+  IFX_FileStream* Retain() override {
     m_dwCount++;
     return this;
   }
-  virtual void Release() override {
+  void Release() override {
     FX_DWORD nCount = --m_dwCount;
     if (nCount) {
       return;
     }
     delete this;
   }
-  virtual FX_FILESIZE GetSize() override { return (FX_FILESIZE)m_nCurSize; }
-  virtual FX_BOOL IsEOF() override { return m_nCurPos >= (size_t)GetSize(); }
-  virtual FX_FILESIZE GetPosition() override { return (FX_FILESIZE)m_nCurPos; }
-  virtual FX_BOOL ReadBlock(void* buffer,
-                            FX_FILESIZE offset,
-                            size_t size) override {
+  FX_FILESIZE GetSize() override { return (FX_FILESIZE)m_nCurSize; }
+  FX_BOOL IsEOF() override { return m_nCurPos >= (size_t)GetSize(); }
+  FX_FILESIZE GetPosition() override { return (FX_FILESIZE)m_nCurPos; }
+  FX_BOOL ReadBlock(void* buffer, FX_FILESIZE offset, size_t size) override {
     if (!buffer || !size) {
       return FALSE;
     }
 
     FX_SAFE_SIZE_T newPos = size;
     newPos += offset;
     if (!newPos.IsValid() || newPos.ValueOrDefault(0) == 0 ||
         newPos.ValueOrDie() > m_nCurSize) {
       return FALSE;
     }
@@ skipping 12 matching lines @@
       }
       FXSYS_memcpy(
           buffer, (uint8_t*)m_Blocks[(int)nStartBlock] + (size_t)offset, nRead);
       buffer = ((uint8_t*)buffer) + nRead;
       size -= nRead;
       nStartBlock++;
       offset = 0;
     }
     return TRUE;
   }
-  virtual size_t ReadBlock(void* buffer, size_t size) override {
+  size_t ReadBlock(void* buffer, size_t size) override {
     if (m_nCurPos >= m_nCurSize) {
       return 0;
     }
     size_t nRead = FX_MIN(size, m_nCurSize - m_nCurPos);
     if (!ReadBlock(buffer, (int32_t)m_nCurPos, nRead)) {
       return 0;
     }
     return nRead;
   }
-  virtual FX_BOOL WriteBlock(const void* buffer,
-                             FX_FILESIZE offset,
-                             size_t size) override {
+  FX_BOOL WriteBlock(const void* buffer,
+                     FX_FILESIZE offset,
+                     size_t size) override {
     if (!buffer || !size) {
       return FALSE;
     }
     if (m_dwFlags & FX_MEMSTREAM_Consecutive) {
       FX_SAFE_SIZE_T newPos = size;
       newPos += offset;
       if (!newPos.IsValid())
         return FALSE;
 
       m_nCurPos = newPos.ValueOrDie();
@@ skipping 37 matching lines @@
       }
       FXSYS_memcpy((uint8_t*)m_Blocks[(int)nStartBlock] + (size_t)offset,
                    buffer, nWrite);
       buffer = ((uint8_t*)buffer) + nWrite;
       size -= nWrite;
       nStartBlock++;
       offset = 0;
     }
     return TRUE;
   }
-  virtual FX_BOOL Flush() override { return TRUE; }
-  virtual FX_BOOL IsConsecutive() const override {
+  FX_BOOL Flush() override { return TRUE; }
+  FX_BOOL IsConsecutive() const override {
     return m_dwFlags & FX_MEMSTREAM_Consecutive;
   }
-  virtual void EstimateSize(size_t nInitSize, size_t nGrowSize) override {
+  void EstimateSize(size_t nInitSize, size_t nGrowSize) override {
     if (m_dwFlags & FX_MEMSTREAM_Consecutive) {
       if (m_Blocks.GetSize() < 1) {
         uint8_t* pBlock = FX_Alloc(uint8_t, FX_MAX(nInitSize, 4096));
         m_Blocks.Add(pBlock);
       }
       m_nGrowSize = FX_MAX(nGrowSize, 4096);
     } else if (m_Blocks.GetSize() < 1) {
       m_nGrowSize = FX_MAX(nGrowSize, 4096);
     }
   }
-  virtual uint8_t* GetBuffer() const override {
+  uint8_t* GetBuffer() const override {
     return m_Blocks.GetSize() ? (uint8_t*)m_Blocks[0] : NULL;
   }
-  virtual void AttachBuffer(uint8_t* pBuffer,
-                            size_t nSize,
-                            FX_BOOL bTakeOver = FALSE) override {
+  void AttachBuffer(uint8_t* pBuffer,
+                    size_t nSize,
+                    FX_BOOL bTakeOver = FALSE) 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);
   }
-  virtual void DetachBuffer() override {
+  void DetachBuffer() override {
     if (!(m_dwFlags & FX_MEMSTREAM_Consecutive)) {
       return;
     }
     m_Blocks.RemoveAll();
     m_nTotalSize = m_nCurSize = m_nCurPos = 0;
     m_dwFlags = FX_MEMSTREAM_TakeOver;
   }
 
  protected:
   CFX_PtrArray m_Blocks;
@@ skipping 41 matching lines @@
 } FX_MTRANDOMCONTEXT, *FX_LPMTRANDOMCONTEXT;
 typedef FX_MTRANDOMCONTEXT const* FX_LPCMTRANDOMCONTEXT;
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
 FX_BOOL FX_GenerateCryptoRandom(FX_DWORD* pBuffer, int32_t iCount);
 #endif
 #ifdef __cplusplus
 }
 #endif
 
 #endif  // CORE_SRC_FXCRT_EXTENSION_H_