Remove FX_DWORD from fpdfsdk/ and testing/

fpdfsdk/fpdfview.cpp

 // 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
 
 #include "public/fpdfview.h"
 
 #include <memory>
 
@@ skipping 135 matching lines @@
   if (!m_pFS || !m_pFS->Flush)
     return TRUE;
 
   return m_pFS->Flush(m_pFS->clientData) == 0;
 }
 #endif  // PDF_ENABLE_XFA
 
 CPDF_CustomAccess::CPDF_CustomAccess(FPDF_FILEACCESS* pFileAccess) {
   m_FileAccess = *pFileAccess;
 #ifdef PDF_ENABLE_XFA
-  m_BufferOffset = (FX_DWORD)-1;
+  m_BufferOffset = (uint32_t)-1;
 #endif  // PDF_ENABLE_XFA
 }
 
 #ifdef PDF_ENABLE_XFA
-FX_BOOL CPDF_CustomAccess::GetByte(FX_DWORD pos, uint8_t& ch) {
+FX_BOOL CPDF_CustomAccess::GetByte(uint32_t pos, uint8_t& ch) {
   if (pos >= m_FileAccess.m_FileLen)
     return FALSE;
-  if (m_BufferOffset == (FX_DWORD)-1 || pos < m_BufferOffset ||
+  if (m_BufferOffset == (uint32_t)-1 || pos < m_BufferOffset ||
       pos >= m_BufferOffset + 512) {
     // Need to read from file access
     m_BufferOffset = pos;
     int size = 512;
     if (pos + 512 > m_FileAccess.m_FileLen)
       size = m_FileAccess.m_FileLen - pos;
     if (!m_FileAccess.m_GetBlock(m_FileAccess.m_Param, m_BufferOffset, m_Buffer,
                                  size))
       return FALSE;
   }
   ch = m_Buffer[pos - m_BufferOffset];
   return TRUE;
 }
 
-FX_BOOL CPDF_CustomAccess::GetBlock(FX_DWORD pos,
+FX_BOOL CPDF_CustomAccess::GetBlock(uint32_t pos,
                                     uint8_t* pBuf,
-                                    FX_DWORD size) {
+                                    uint32_t size) {
   if (pos + size > m_FileAccess.m_FileLen)
     return FALSE;
   return m_FileAccess.m_GetBlock(m_FileAccess.m_Param, pos, pBuf, size);
 }
 #endif  // PDF_ENABLE_XFA
 
 FX_BOOL CPDF_CustomAccess::ReadBlock(void* buffer,
                                      FX_FILESIZE offset,
                                      size_t size) {
   if (offset < 0) {
     return FALSE;
   }
   FX_SAFE_FILESIZE newPos =
       pdfium::base::checked_cast<FX_FILESIZE, size_t>(size);
   newPos += offset;
   if (!newPos.IsValid() || newPos.ValueOrDie() > m_FileAccess.m_FileLen) {
     return FALSE;
   }
   return m_FileAccess.m_GetBlock(m_FileAccess.m_Param, offset, (uint8_t*)buffer,
                                  size);
 }
 
 // 0 bit: FPDF_POLICY_MACHINETIME_ACCESS
-static FX_DWORD foxit_sandbox_policy = 0xFFFFFFFF;
+static uint32_t foxit_sandbox_policy = 0xFFFFFFFF;
 
 void FSDK_SetSandBoxPolicy(FPDF_DWORD policy, FPDF_BOOL enable) {
   switch (policy) {
     case FPDF_POLICY_MACHINETIME_ACCESS: {
       if (enable)
         foxit_sandbox_policy |= 0x01;
       else
         foxit_sandbox_policy &= 0xFFFFFFFE;
     } break;
     default:
@@ skipping 59 matching lines @@
 void SetLastError(int err) {
   g_LastError = err;
 }
 
 int GetLastError() {
   return g_LastError;
 }
 #endif  // _WIN32
 
 void ProcessParseError(CPDF_Parser::Error err) {
-  FX_DWORD err_code = FPDF_ERR_SUCCESS;
+  uint32_t err_code = FPDF_ERR_SUCCESS;
   // Translate FPDFAPI error code to FPDFVIEW error code
   switch (err) {
     case CPDF_Parser::SUCCESS:
       err_code = FPDF_ERR_SUCCESS;
       break;
     case CPDF_Parser::FILE_ERROR:
       err_code = FPDF_ERR_FILE;
       break;
     case CPDF_Parser::FORMAT_ERROR:
       err_code = FPDF_ERR_FORMAT;
@@ skipping 87 matching lines @@
 
   void Release() override { delete this; }
   FX_FILESIZE GetSize() override { return m_size; }
   FX_BOOL ReadBlock(void* buffer, FX_FILESIZE offset, size_t size) override {
     if (offset < 0) {
       return FALSE;
     }
     FX_SAFE_FILESIZE newPos =
         pdfium::base::checked_cast<FX_FILESIZE, size_t>(size);
     newPos += offset;
-    if (!newPos.IsValid() || newPos.ValueOrDie() > (FX_DWORD)m_size) {
+    if (!newPos.IsValid() || newPos.ValueOrDie() > (uint32_t)m_size) {
       return FALSE;
     }
     FXSYS_memcpy(buffer, m_pBuf + offset, size);
     return TRUE;
   }
 
  private:
   ~CMemFile() override {}
 
   uint8_t* const m_pBuf;
@@ skipping 47 matching lines @@
     return FALSE;
 
   CPDF_Parser* pParser = pDoc->GetParser();
   if (!pParser)
     return FALSE;
 
   *fileVersion = pParser->GetFileVersion();
   return TRUE;
 }
 
-// jabdelmalek: changed return type from FX_DWORD to build on Linux (and match
+// jabdelmalek: changed return type from uint32_t to build on Linux (and match
 // header).
 DLLEXPORT unsigned long STDCALL FPDF_GetDocPermissions(FPDF_DOCUMENT document) {
   CPDF_Document* pDoc = CPDFDocumentFromFPDFDocument(document);
   if (!pDoc)
 #ifndef PDF_ENABLE_XFA
     return 0;
 #else   // PDF_ENABLE_XFA
-    return (FX_DWORD)-1;
+    return (uint32_t)-1;
 #endif  // PDF_ENABLE_XFA
 
   CPDF_Dictionary* pDict = pDoc->GetParser()->GetEncryptDict();
-  return pDict ? pDict->GetIntegerBy("P") : (FX_DWORD)-1;
+  return pDict ? pDict->GetIntegerBy("P") : (uint32_t)-1;
 }
 
 DLLEXPORT int STDCALL FPDF_GetSecurityHandlerRevision(FPDF_DOCUMENT document) {
   CPDF_Document* pDoc = CPDFDocumentFromFPDFDocument(document);
   if (!pDoc)
     return -1;
 
   CPDF_Dictionary* pDict = pDoc->GetParser()->GetEncryptDict();
   return pDict ? pDict->GetIntegerBy("R") : -1;
 }
@@ skipping 674 matching lines @@
   if (!buffer) {
     *buflen = len;
   } else if (*buflen >= len) {
     memcpy(buffer, utf16Name.c_str(), len);
     *buflen = len;
   } else {
     *buflen = -1;
   }
   return (FPDF_DEST)pDestObj;
 }