Introduce "underlying types" to abstract XFA differences.

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 "../include/fpdfxfa/fpdfxfa_app.h"
 #include "../include/fpdfxfa/fpdfxfa_doc.h"
 #include "../include/fpdfxfa/fpdfxfa_page.h"
 #include "../include/fpdfxfa/fpdfxfa_util.h"
 #include "core/include/fpdfapi/fpdf_module.h"
 #include "core/include/fxcodec/fx_codec.h"
 #include "core/include/fxcrt/fx_safe_types.h"
 #include "fpdfsdk/include/fsdk_define.h"
 #include "fpdfsdk/include/fsdk_mgr.h"
 #include "fpdfsdk/include/fsdk_rendercontext.h"
 #include "fpdfsdk/include/javascript/IJavaScript.h"
 #include "public/fpdf_ext.h"
 #include "public/fpdf_formfill.h"
 #include "public/fpdf_progressive.h"
 #include "third_party/base/nonstd_unique_ptr.h"
 #include "third_party/base/numerics/safe_conversions_impl.h"
 
+UnderlyingDocumentType* UnderlyingFromFPDFDocument(FPDF_DOCUMENT doc) {
+  return static_cast<UnderlyingDocumentType*>(doc);
+}
+
+FPDF_DOCUMENT FPDFDocumentFromUnderlying(UnderlyingDocumentType* doc) {
+  return static_cast<FPDF_DOCUMENT>(doc);
+}
+
+UnderlyingPageType* UnderlyingFromFPDFPage(FPDF_PAGE page) {
+  return static_cast<UnderlyingPageType*>(page);
+}
+
 CPDF_Document* CPDFDocumentFromFPDFDocument(FPDF_DOCUMENT doc) {
-  return doc ? static_cast<CPDFXFA_Document*>(doc)->GetPDFDoc() : nullptr;
+  return doc ? UnderlyingFromFPDFDocument(doc)->GetPDFDoc() : nullptr;
 }
 
 FPDF_DOCUMENT FPDFDocumentFromCPDFDocument(CPDF_Document* doc) {
-  return doc ? new CPDFXFA_Document(doc, CPDFXFA_App::GetInstance()) : nullptr;
+  return doc ? FPDFDocumentFromUnderlying(
+                   new CPDFXFA_Document(doc, CPDFXFA_App::GetInstance()))
+             : nullptr;
 }
 
 CPDF_Page* CPDFPageFromFPDFPage(FPDF_PAGE page) {
-  return page ? static_cast<CPDFXFA_Page*>(page)->GetPDFPage() : nullptr;
+  return page ? UnderlyingFromFPDFPage(page)->GetPDFPage() : nullptr;
 }
 
 CFPDF_FileStream::CFPDF_FileStream(FPDF_FILEHANDLER* pFS) {
   m_pFS = pFS;
   m_nCurPos = 0;
 }
 
 IFX_FileStream* CFPDF_FileStream::Retain() {
   return this;
 }
@@ skipping 363 matching lines @@
 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->GetInteger("R") : -1;
 }
 
 DLLEXPORT int STDCALL FPDF_GetPageCount(FPDF_DOCUMENT document) {
-  CPDFXFA_Document* pDoc = static_cast<CPDFXFA_Document*>(document);
+  UnderlyingDocumentType* pDoc = UnderlyingFromFPDFDocument(document);
   return pDoc ? pDoc->GetPageCount() : 0;
 }
 
 DLLEXPORT FPDF_PAGE STDCALL FPDF_LoadPage(FPDF_DOCUMENT document,
                                           int page_index) {
-  if (!document)
+  UnderlyingDocumentType* pDoc = UnderlyingFromFPDFDocument(document);
+  if (!pDoc)
     return nullptr;
-  CPDFXFA_Document* pDoc = static_cast<CPDFXFA_Document*>(document);
   if (page_index < 0 || page_index >= pDoc->GetPageCount())
     return nullptr;
 
   return pDoc->GetPage(page_index);
 }
 
 DLLEXPORT double STDCALL FPDF_GetPageWidth(FPDF_PAGE page) {
-  CPDFXFA_Page* pPage = static_cast<CPDFXFA_Page*>(page);
+  UnderlyingPageType* pPage = UnderlyingFromFPDFPage(page);
   return pPage ? pPage->GetPageWidth() : 0.0;
 }
 
 DLLEXPORT double STDCALL FPDF_GetPageHeight(FPDF_PAGE page) {
-  CPDFXFA_Page* pPage = static_cast<CPDFXFA_Page*>(page);
+  UnderlyingPageType* pPage = UnderlyingFromFPDFPage(page);
   return pPage ? pPage->GetPageHeight() : 0.0;
 }
 
 void DropContext(void* data) {
   delete (CRenderContext*)data;
 }
 
 #if defined(_DEBUG) || defined(DEBUG)
 #define DEBUG_TRACE
 #endif
@@ skipping 220 matching lines @@
                                          int start_y,
                                          int size_x,
                                          int size_y,
                                          int rotate,
                                          int device_x,
                                          int device_y,
                                          double* page_x,
                                          double* page_y) {
   if (page == NULL || page_x == NULL || page_y == NULL)
     return;
-  CPDFXFA_Page* pPage = (CPDFXFA_Page*)page;
-
+  UnderlyingPageType* pPage = UnderlyingFromFPDFPage(page);
   pPage->DeviceToPage(start_x, start_y, size_x, size_y, rotate, device_x,
                       device_y, page_x, page_y);
 }
 
 DLLEXPORT void STDCALL FPDF_PageToDevice(FPDF_PAGE page,
                                          int start_x,
                                          int start_y,
                                          int size_x,
                                          int size_y,
                                          int rotate,
                                          double page_x,
                                          double page_y,
                                          int* device_x,
                                          int* device_y) {
   if (!device_x || !device_y)
     return;
-  CPDFXFA_Page* pPage = (CPDFXFA_Page*)page;
+  UnderlyingPageType* pPage = UnderlyingFromFPDFPage(page);
   if (!pPage)
     return;
   pPage->PageToDevice(start_x, start_y, size_x, size_y, rotate, page_x, page_y,
                       device_x, device_y);
 }
 
 DLLEXPORT FPDF_BITMAP STDCALL FPDFBitmap_Create(int width,
                                                 int height,
                                                 int alpha) {
   nonstd::unique_ptr<CFX_DIBitmap> pBitmap(new CFX_DIBitmap);
@@ skipping 346 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;
 }