Get rid of most uses of CFX_PtrArray.

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 81 matching lines @@
         m_nCurSize(nSize),
         m_nCurPos(0),
         m_nGrowSize(FX_MEMSTREAM_BlockSize) {
     m_Blocks.Add(pBuffer);
     m_dwFlags =
         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]);
+        FX_Free(m_Blocks[i]);
       }
     }
     m_Blocks.RemoveAll();
   }
 
   // IFX_MemoryStream:
   IFX_FileStream* Retain() override {
     m_dwCount++;
     return this;
   }
@@ skipping 14 matching lines @@
 
     FX_SAFE_SIZE_T newPos = size;
     newPos += offset;
     if (!newPos.IsValid() || newPos.ValueOrDefault(0) == 0 ||
         newPos.ValueOrDie() > m_nCurSize) {
       return FALSE;
     }
 
     m_nCurPos = newPos.ValueOrDie();
     if (m_dwFlags & FX_MEMSTREAM_Consecutive) {
-      FXSYS_memcpy(buffer, (uint8_t*)m_Blocks[0] + (size_t)offset, size);
+      FXSYS_memcpy(buffer, m_Blocks[0] + (size_t)offset, size);
       return TRUE;
     }
     size_t nStartBlock = (size_t)offset / m_nGrowSize;
     offset -= (FX_FILESIZE)(nStartBlock * m_nGrowSize);
     while (size) {
       size_t nRead = m_nGrowSize - (size_t)offset;
       if (nRead > size) {
         nRead = size;
       }
-      FXSYS_memcpy(
-          buffer, (uint8_t*)m_Blocks[(int)nStartBlock] + (size_t)offset, nRead);
+      FXSYS_memcpy(buffer, m_Blocks[(int)nStartBlock] + (size_t)offset, nRead);
       buffer = ((uint8_t*)buffer) + nRead;
       size -= nRead;
       nStartBlock++;
       offset = 0;
     }
     return TRUE;
   }
   size_t ReadBlock(void* buffer, size_t size) override {
     if (m_nCurPos >= m_nCurSize) {
       return 0;
@@ skipping 14 matching lines @@
       FX_SAFE_SIZE_T newPos = size;
       newPos += offset;
       if (!newPos.IsValid())
         return FALSE;
 
       m_nCurPos = newPos.ValueOrDie();
       if (m_nCurPos > m_nTotalSize) {
         m_nTotalSize =
             (m_nCurPos + m_nGrowSize - 1) / m_nGrowSize * m_nGrowSize;
         if (m_Blocks.GetSize() < 1) {
-          void* block = FX_Alloc(uint8_t, m_nTotalSize);
+          uint8_t* block = FX_Alloc(uint8_t, m_nTotalSize);
           m_Blocks.Add(block);
         } else {
           m_Blocks[0] = FX_Realloc(uint8_t, m_Blocks[0], m_nTotalSize);
         }
         if (!m_Blocks[0]) {
           m_Blocks.RemoveAll();
           return FALSE;
         }
       }
-      FXSYS_memcpy((uint8_t*)m_Blocks[0] + (size_t)offset, buffer, size);
+      FXSYS_memcpy(m_Blocks[0] + (size_t)offset, buffer, size);
       if (m_nCurSize < m_nCurPos) {
         m_nCurSize = m_nCurPos;
       }
       return TRUE;
     }
 
     FX_SAFE_SIZE_T newPos = size;
     newPos += offset;
     if (!newPos.IsValid()) {
       return FALSE;
     }
 
     if (!ExpandBlocks(newPos.ValueOrDie())) {
       return FALSE;
     }
     m_nCurPos = newPos.ValueOrDie();
     size_t nStartBlock = (size_t)offset / m_nGrowSize;
     offset -= (FX_FILESIZE)(nStartBlock * m_nGrowSize);
     while (size) {
       size_t nWrite = m_nGrowSize - (size_t)offset;
       if (nWrite > size) {
         nWrite = size;
       }
-      FXSYS_memcpy((uint8_t*)m_Blocks[(int)nStartBlock] + (size_t)offset,
-                   buffer, nWrite);
+      FXSYS_memcpy(m_Blocks[(int)nStartBlock] + (size_t)offset, buffer, nWrite);
       buffer = ((uint8_t*)buffer) + nWrite;
       size -= nWrite;
       nStartBlock++;
       offset = 0;
     }
     return TRUE;
   }
   FX_BOOL Flush() override { return TRUE; }
   FX_BOOL IsConsecutive() const override {
     return m_dwFlags & FX_MEMSTREAM_Consecutive;
   }
   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);
     }
   }
   uint8_t* GetBuffer() const override {
-    return m_Blocks.GetSize() ? (uint8_t*)m_Blocks[0] : NULL;
+    return m_Blocks.GetSize() ? m_Blocks[0] : nullptr;
   }
   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);
   }
   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;
+  CFX_ArrayTemplate<uint8_t*> m_Blocks;
   FX_DWORD m_dwCount;
   size_t m_nTotalSize;
   size_t m_nCurSize;
   size_t m_nCurPos;
   size_t m_nGrowSize;
   FX_DWORD m_dwFlags;
   FX_BOOL ExpandBlocks(size_t size) {
     if (m_nCurSize < size) {
       m_nCurSize = size;
     }
@@ skipping 31 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_