War on #defines - part 2

fpdfsdk/src/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 256 matching lines @@
 int g_LastError;
 void SetLastError(int err) {
   g_LastError = err;
 }
 
 int GetLastError() {
   return g_LastError;
 }
 #endif  // _WIN32
 
-void ProcessParseError(FX_DWORD err_code) {
+void ProcessParseError(CPDF_Parser::Error err) {
+  FX_DWORD err_code;
   // Translate FPDFAPI error code to FPDFVIEW error code
-  switch (err_code) {
-    case PDFPARSE_ERROR_FILE:
+  switch (err) {
+    case CPDF_Parser::SUCCESS:
+      err_code = FPDF_ERR_SUCCESS;

[Lei Zhang, 2016/01/26 22:13:44]

This is NOTREACHED(), BTW.

[Tom Sepez, 2016/01/26 22:19:35]

It exists just to satisfy the all enums handled by switch requirement.

[brucedawson, 2016/02/03 19:49:08]

Was clang giving a warning without this case? Arguably a default case would be
better because now VC++'s /analyze warns that err_code is potentially not
initialized. Ah, the joys of trying to write clean code while also keeping
multiple compilers warning clean.

Could also avoid the VC++ warning by initializing err_code to FPDF_ERR_SUCCESS.
Or just ignore.

+      break;
+    case CPDF_Parser::FILE_ERROR:
       err_code = FPDF_ERR_FILE;
       break;
-    case PDFPARSE_ERROR_FORMAT:
+    case CPDF_Parser::FORMAT_ERROR:
       err_code = FPDF_ERR_FORMAT;
       break;
-    case PDFPARSE_ERROR_PASSWORD:
+    case CPDF_Parser::PASSWORD_ERROR:
       err_code = FPDF_ERR_PASSWORD;
       break;
-    case PDFPARSE_ERROR_HANDLER:
+    case CPDF_Parser::HANDLER_ERROR:
       err_code = FPDF_ERR_SECURITY;
       break;
   }
   SetLastError(err_code);
 }
 
 DLLEXPORT void STDCALL FPDF_SetSandBoxPolicy(FPDF_DWORD policy,
                                              FPDF_BOOL enable) {
   return FSDK_SetSandBoxPolicy(policy, enable);
 }
 
 DLLEXPORT FPDF_DOCUMENT STDCALL FPDF_LoadDocument(FPDF_STRING file_path,
                                                   FPDF_BYTESTRING password) {
   // NOTE: the creation of the file needs to be by the embedder on the
   // other side of this API.
   IFX_FileRead* pFileAccess = FX_CreateFileRead((const FX_CHAR*)file_path);
   if (!pFileAccess) {
     return nullptr;
   }
 
   CPDF_Parser* pParser = new CPDF_Parser;
   pParser->SetPassword(password);
 
-  FX_DWORD err_code = pParser->StartParse(pFileAccess);
-  if (err_code) {
+  CPDF_Parser::Error error = pParser->StartParse(pFileAccess);
+  if (error != CPDF_Parser::SUCCESS) {
     delete pParser;
-    ProcessParseError(err_code);
+    ProcessParseError(error);
     return NULL;
   }
 #ifdef PDF_ENABLE_XFA
   CPDF_Document* pPDFDoc = pParser->GetDocument();
   if (!pPDFDoc)
     return NULL;
 
   CPDFXFA_App* pProvider = CPDFXFA_App::GetInstance();
   return new CPDFXFA_Document(pPDFDoc, pProvider);
 #else   // PDF_ENABLE_XFA
@@ skipping 65 matching lines @@
   uint8_t* const m_pBuf;
   const FX_FILESIZE m_size;
 };
 
 DLLEXPORT FPDF_DOCUMENT STDCALL FPDF_LoadMemDocument(const void* data_buf,
                                                      int size,
                                                      FPDF_BYTESTRING password) {
   CPDF_Parser* pParser = new CPDF_Parser;
   pParser->SetPassword(password);
   CMemFile* pMemFile = new CMemFile((uint8_t*)data_buf, size);
-  FX_DWORD err_code = pParser->StartParse(pMemFile);
-  if (err_code) {
+  CPDF_Parser::Error error = pParser->StartParse(pMemFile);
+  if (error != CPDF_Parser::SUCCESS) {
     delete pParser;
-    ProcessParseError(err_code);
+    ProcessParseError(error);
     return NULL;
   }
   CPDF_Document* pDoc = NULL;
   pDoc = pParser ? pParser->GetDocument() : NULL;
-  CheckUnSupportError(pDoc, err_code);
+  CheckUnSupportError(pDoc, error);

[Lei Zhang, 2016/01/26 22:13:44]

BTW, all the CheckUnSupportError() errors pass |error| = SUCCESS.

[Tom Sepez, 2016/01/26 22:19:35]

Thanks.  Next time.

   return FPDFDocumentFromCPDFDocument(pParser->GetDocument());
 }
 
 DLLEXPORT FPDF_DOCUMENT STDCALL
 FPDF_LoadCustomDocument(FPDF_FILEACCESS* pFileAccess,
                         FPDF_BYTESTRING password) {
   CPDF_Parser* pParser = new CPDF_Parser;
   pParser->SetPassword(password);
   CPDF_CustomAccess* pFile = new CPDF_CustomAccess(pFileAccess);
-  FX_DWORD err_code = pParser->StartParse(pFile);
-  if (err_code) {
+  CPDF_Parser::Error error = pParser->StartParse(pFile);
+  if (error != CPDF_Parser::SUCCESS) {
     delete pParser;
-    ProcessParseError(err_code);
+    ProcessParseError(error);
     return NULL;
   }
   CPDF_Document* pDoc = NULL;
   pDoc = pParser ? pParser->GetDocument() : NULL;
-  CheckUnSupportError(pDoc, err_code);
+  CheckUnSupportError(pDoc, error);
   return FPDFDocumentFromCPDFDocument(pParser->GetDocument());
 }
 
 DLLEXPORT FPDF_BOOL STDCALL FPDF_GetFileVersion(FPDF_DOCUMENT doc,
                                                 int* fileVersion) {
   if (!fileVersion)
     return FALSE;
 
   *fileVersion = 0;
   CPDF_Document* pDoc = CPDFDocumentFromFPDFDocument(doc);
@@ skipping 750 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;
 }