fgas/ code cleanup.

xfa/fxfa/app/xfa_ffdoc.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 "xfa/fxfa/include/xfa_ffdoc.h"
 
 #include <algorithm>
 
 #include "core/fpdfapi/fpdf_parser/include/cpdf_array.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_document.h"
 #include "core/fpdfdoc/include/fpdf_doc.h"
 #include "core/fxcrt/include/fx_ext.h"
 #include "core/fxcrt/include/fx_memory.h"
 #include "xfa/fde/xml/fde_xml_imp.h"
-#include "xfa/fgas/crt/fgas_algorithm.h"
 #include "xfa/fwl/core/fwl_noteimp.h"
 #include "xfa/fxfa/app/xfa_ffnotify.h"
 #include "xfa/fxfa/include/xfa_checksum.h"
 #include "xfa/fxfa/include/xfa_ffapp.h"
 #include "xfa/fxfa/include/xfa_ffdocview.h"
 #include "xfa/fxfa/include/xfa_ffwidget.h"
 #include "xfa/fxfa/include/xfa_fontmgr.h"
 #include "xfa/fxfa/parser/xfa_document.h"
 #include "xfa/fxfa/parser/xfa_document_serialize.h"
 #include "xfa/fxfa/parser/xfa_parser.h"
 #include "xfa/fxfa/parser/xfa_parser_imp.h"
 #include "xfa/fxfa/parser/xfa_parser_imp.h"
 
+namespace {
+
+struct FX_BASE64DATA {
+  uint32_t data1 : 2;
+  uint32_t data2 : 6;
+  uint32_t data3 : 4;
+  uint32_t data4 : 4;
+  uint32_t data5 : 6;
+  uint32_t data6 : 2;
+  uint32_t data7 : 8;
+};
+
+const uint8_t kStartValuesRemoved = 43;
+const uint8_t kDecoderMapSize = 80;
+const uint8_t g_FXBase64DecoderMap[kDecoderMapSize] = {
+    0x3E, 0xFF, 0xFF, 0xFF, 0x3F, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A,
+    0x3B, 0x3C, 0x3D, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x01,
+    0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,
+    0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,
+    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
+    0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B,
+    0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33,
+};
+
+uint8_t base64DecoderValue(uint8_t val) {

[Tom Sepez, 2016/05/19 21:23:42]

The numbers look right, alternatively you might want to stick to multiples of
16, eg, trim 0..31 and 128..255 only.  Gets you most of the bang without weird
numbers.

[dsinclair, 2016/05/20 01:06:31]

I think it's going to be strange either way. I think the variable names make it
clear what's going on.

+  if (val < kStartValuesRemoved || val >= kStartValuesRemoved + kDecoderMapSize)
+    return 0xFF;
+  return g_FXBase64DecoderMap[val - kStartValuesRemoved];
+}
+
+void Base64DecodePiece(const FX_CHAR src[4],
+                       int32_t iChars,
+                       FX_BASE64DATA& dst,
+                       int32_t& iBytes) {
+  ASSERT(iChars > 0 && iChars < 5);
+  iBytes = 1;
+  dst.data2 = base64DecoderValue(static_cast<uint8_t>(src[0]));
+  if (iChars > 1) {
+    uint8_t b = base64DecoderValue(static_cast<uint8_t>(src[1]));
+    dst.data1 = b >> 4;
+    dst.data4 = b;
+    if (iChars > 2) {
+      iBytes = 2;
+      b = base64DecoderValue(static_cast<uint8_t>(src[2]));
+      dst.data3 = b >> 2;
+      dst.data6 = b;
+      if (iChars > 3) {
+        iBytes = 3;
+        dst.data5 = base64DecoderValue(static_cast<uint8_t>(src[3]));
+      } else {
+        dst.data5 = 0;
+      }
+    } else {
+      dst.data3 = 0;
+    }
+  } else {
+    dst.data1 = 0;
+  }
+}
+
+int32_t Base64DecodeW(const FX_WCHAR* pSrc, int32_t iSrcLen, uint8_t* pDst) {
+  ASSERT(pSrc);
+  if (iSrcLen < 1) {
+    return 0;
+  }
+  while (iSrcLen > 0 && pSrc[iSrcLen - 1] == '=') {
+    iSrcLen--;
+  }
+  if (iSrcLen < 1) {
+    return 0;
+  }
+  if (!pDst) {
+    int32_t iDstLen = iSrcLen / 4 * 3;
+    iSrcLen %= 4;
+    if (iSrcLen == 1) {
+      iDstLen += 1;
+    } else if (iSrcLen == 2) {
+      iDstLen += 1;
+    } else if (iSrcLen == 3) {
+      iDstLen += 2;
+    }
+    return iDstLen;
+  }
+  FX_CHAR srcData[4];
+  FX_BASE64DATA dstData;
+  int32_t iChars = 4, iBytes;
+  uint8_t* pDstEnd = pDst;
+  while (iSrcLen > 0) {
+    if (iSrcLen > 3) {
+      srcData[0] = (FX_CHAR)*pSrc++;
+      srcData[1] = (FX_CHAR)*pSrc++;
+      srcData[2] = (FX_CHAR)*pSrc++;
+      srcData[3] = (FX_CHAR)*pSrc++;
+      iSrcLen -= 4;
+    } else {
+      *((uint32_t*)&dstData) = 0;
+      *((uint32_t*)srcData) = 0;
+      srcData[0] = (FX_CHAR)*pSrc++;
+      if (iSrcLen > 1) {
+        srcData[1] = (FX_CHAR)*pSrc++;
+      }
+      if (iSrcLen > 2) {
+        srcData[2] = (FX_CHAR)*pSrc++;
+      }
+      iChars = iSrcLen;
+      iSrcLen = 0;
+    }
+    Base64DecodePiece(srcData, iChars, dstData, iBytes);
+    *pDstEnd++ = ((uint8_t*)&dstData)[0];
+    if (iBytes > 1) {
+      *pDstEnd++ = ((uint8_t*)&dstData)[1];
+    }
+    if (iBytes > 2) {
+      *pDstEnd++ = ((uint8_t*)&dstData)[2];
+    }
+  }
+  return pDstEnd - pDst;
+}
+
+}  // namespace
+
 CXFA_FFDoc::CXFA_FFDoc(CXFA_FFApp* pApp, IXFA_DocProvider* pDocProvider)
     : m_pDocProvider(pDocProvider),
       m_pDocument(nullptr),
       m_pStream(nullptr),
       m_pApp(pApp),
       m_pNotify(nullptr),
       m_pPDFDoc(nullptr),
       m_dwDocType(XFA_DOCTYPE_Static),
       m_bOwnStream(TRUE) {}
 CXFA_FFDoc::~CXFA_FFDoc() {
   CloseDoc();
 }
 uint32_t CXFA_FFDoc::GetDocType() {
   return m_dwDocType;
 }
 int32_t CXFA_FFDoc::StartLoad() {
   m_pNotify = new CXFA_FFNotify(this);
   CXFA_DocumentParser* pDocParser = new CXFA_DocumentParser(m_pNotify);
   int32_t iStatus = pDocParser->StartParse(m_pStream);
   m_pDocument = pDocParser->GetDocument();
   return iStatus;
 }
 FX_BOOL XFA_GetPDFContentsFromPDFXML(CFDE_XMLNode* pPDFElement,
                                      uint8_t*& pByteBuffer,
                                      int32_t& iBufferSize) {
-  CFDE_XMLElement* pDocumentElement = NULL;
+  CFDE_XMLElement* pDocumentElement = nullptr;
   for (CFDE_XMLNode* pXMLNode =
            pPDFElement->GetNodeItem(CFDE_XMLNode::FirstChild);
        pXMLNode; pXMLNode = pXMLNode->GetNodeItem(CFDE_XMLNode::NextSibling)) {
     if (pXMLNode->GetType() == FDE_XMLNODE_Element) {
       CFX_WideString wsTagName;
       CFDE_XMLElement* pXMLElement = static_cast<CFDE_XMLElement*>(pXMLNode);
       pXMLElement->GetTagName(wsTagName);
       if (wsTagName == FX_WSTRC(L"document")) {
         pDocumentElement = pXMLElement;
         break;
       }
     }
   }
   if (!pDocumentElement) {
     return FALSE;
   }
-  CFDE_XMLElement* pChunkElement = NULL;
+  CFDE_XMLElement* pChunkElement = nullptr;
   for (CFDE_XMLNode* pXMLNode =
            pDocumentElement->GetNodeItem(CFDE_XMLNode::FirstChild);
        pXMLNode; pXMLNode = pXMLNode->GetNodeItem(CFDE_XMLNode::NextSibling)) {
     if (pXMLNode->GetType() == FDE_XMLNODE_Element) {
       CFX_WideString wsTagName;
       CFDE_XMLElement* pXMLElement = static_cast<CFDE_XMLElement*>(pXMLNode);
       pXMLElement->GetTagName(wsTagName);
       if (wsTagName == FX_WSTRC(L"chunk")) {
         pChunkElement = pXMLElement;
         break;
       }
     }
   }
   if (!pChunkElement) {
     return FALSE;
   }
   CFX_WideString wsPDFContent;
   pChunkElement->GetTextData(wsPDFContent);
   iBufferSize =
-      FX_Base64DecodeW(wsPDFContent.c_str(), wsPDFContent.GetLength(), NULL);
+      Base64DecodeW(wsPDFContent.c_str(), wsPDFContent.GetLength(), nullptr);
   pByteBuffer = FX_Alloc(uint8_t, iBufferSize + 1);
   pByteBuffer[iBufferSize] = '0';  // FIXME: I bet this is wrong.
-  FX_Base64DecodeW(wsPDFContent.c_str(), wsPDFContent.GetLength(), pByteBuffer);
+  Base64DecodeW(wsPDFContent.c_str(), wsPDFContent.GetLength(), pByteBuffer);
   return TRUE;
 }
 void XFA_XPDPacket_MergeRootNode(CXFA_Node* pOriginRoot, CXFA_Node* pNewRoot) {
   CXFA_Node* pChildNode = pNewRoot->GetNodeItem(XFA_NODEITEM_FirstChild);
   while (pChildNode) {
     CXFA_Node* pOriginChild =
         pOriginRoot->GetFirstChildByName(pChildNode->GetNameHash());
     if (pOriginChild) {
       pChildNode = pChildNode->GetNodeItem(XFA_NODEITEM_NextSibling);
     } else {
       CXFA_Node* pNextSibling =
           pChildNode->GetNodeItem(XFA_NODEITEM_NextSibling);
       pNewRoot->RemoveChild(pChildNode);
       pOriginRoot->InsertChild(pChildNode);
       pChildNode = pNextSibling;
-      pNextSibling = NULL;
+      pNextSibling = nullptr;
     }
   }
 }
 int32_t CXFA_FFDoc::DoLoad(IFX_Pause* pPause) {
   int32_t iStatus = m_pDocument->GetParser()->DoParse(pPause);
   if (iStatus == XFA_PARSESTATUS_Done && !m_pPDFDoc) {
     CXFA_Node* pPDFNode = ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Pdf));
     if (!pPDFNode) {
       return XFA_PARSESTATUS_SyntaxErr;
     }
     CFDE_XMLNode* pPDFXML = pPDFNode->GetXMLMappingNode();
     if (pPDFXML->GetType() != FDE_XMLNODE_Element) {
       return XFA_PARSESTATUS_SyntaxErr;
     }
     int32_t iBufferSize = 0;
-    uint8_t* pByteBuffer = NULL;
-    IFX_FileRead* pXFAReader = NULL;
+    uint8_t* pByteBuffer = nullptr;
+    IFX_FileRead* pXFAReader = nullptr;
     if (XFA_GetPDFContentsFromPDFXML(pPDFXML, pByteBuffer, iBufferSize)) {
       pXFAReader = FX_CreateMemoryStream(pByteBuffer, iBufferSize, TRUE);
     } else {
       CFX_WideString wsHref;
       static_cast<CFDE_XMLElement*>(pPDFXML)->GetString(L"href", wsHref);
       if (!wsHref.IsEmpty()) {
         pXFAReader = GetDocProvider()->OpenLinkedFile(this, wsHref);
       }
     }
     if (!pXFAReader) {
       return XFA_PARSESTATUS_SyntaxErr;
     }
     CPDF_Document* pPDFDocument =
         GetDocProvider()->OpenPDF(this, pXFAReader, TRUE);
     ASSERT(!m_pPDFDoc);
     if (!OpenDoc(pPDFDocument)) {
       return XFA_PARSESTATUS_SyntaxErr;
     }
     IXFA_Parser* pParser = IXFA_Parser::Create(m_pDocument, TRUE);
     if (!pParser) {
       return XFA_PARSESTATUS_SyntaxErr;
     }
-    CXFA_Node* pRootNode = NULL;
+    CXFA_Node* pRootNode = nullptr;
     if (pParser->StartParse(m_pStream) == XFA_PARSESTATUS_Ready &&
-        pParser->DoParse(NULL) == XFA_PARSESTATUS_Done) {
+        pParser->DoParse(nullptr) == XFA_PARSESTATUS_Done) {
       pRootNode = pParser->GetRootNode();
     }
     if (pRootNode && m_pDocument->GetRoot()) {
       XFA_XPDPacket_MergeRootNode(m_pDocument->GetRoot(), pRootNode);
       iStatus = XFA_PARSESTATUS_Done;
     } else {
       iStatus = XFA_PARSESTATUS_StatusErr;
     }
     pParser->Release();
-    pParser = NULL;
+    pParser = nullptr;
   }
   return iStatus;
 }
 void CXFA_FFDoc::StopLoad() {
   m_pApp->GetXFAFontMgr()->LoadDocFonts(this);
   m_dwDocType = XFA_DOCTYPE_Static;
   CXFA_Node* pConfig = ToNode(m_pDocument->GetXFAObject(XFA_HASHCODE_Config));
   if (!pConfig) {
     return;
   }
@@ skipping 35 matching lines @@
   auto it = m_TypeToDocViewMap.begin();
   return it != m_TypeToDocViewMap.end() ? it->second.get() : nullptr;
 }
 
 FX_BOOL CXFA_FFDoc::OpenDoc(IFX_FileRead* pStream, FX_BOOL bTakeOverFile) {
   m_bOwnStream = bTakeOverFile;
   m_pStream = pStream;
   return TRUE;
 }
 FX_BOOL CXFA_FFDoc::OpenDoc(CPDF_Document* pPDFDoc) {
-  if (pPDFDoc == NULL) {
+  if (!pPDFDoc)
     return FALSE;
-  }
+
   CPDF_Dictionary* pRoot = pPDFDoc->GetRoot();
-  if (pRoot == NULL) {
+  if (!pRoot)
     return FALSE;
-  }
+
   CPDF_Dictionary* pAcroForm = pRoot->GetDictBy("AcroForm");
-  if (pAcroForm == NULL) {
+  if (!pAcroForm)
     return FALSE;
-  }
+
   CPDF_Object* pElementXFA = pAcroForm->GetDirectObjectBy("XFA");
-  if (pElementXFA == NULL) {
+  if (!pElementXFA)
     return FALSE;
-  }
+
   CFX_ArrayTemplate<CPDF_Stream*> xfaStreams;
   if (pElementXFA->IsArray()) {
     CPDF_Array* pXFAArray = (CPDF_Array*)pElementXFA;
     for (size_t i = 0; i < pXFAArray->GetCount() / 2; i++) {
       if (CPDF_Stream* pStream = pXFAArray->GetStreamAt(i * 2 + 1))
         xfaStreams.Add(pStream);
     }
   } else if (pElementXFA->IsStream()) {
     xfaStreams.Add((CPDF_Stream*)pElementXFA);
   }
   if (xfaStreams.GetSize() < 1) {
     return FALSE;
   }
   IFX_FileRead* pFileRead = new CXFA_FileRead(xfaStreams);
   m_pPDFDoc = pPDFDoc;
   if (m_pStream) {
     m_pStream->Release();
-    m_pStream = NULL;
+    m_pStream = nullptr;
   }
   m_pStream = pFileRead;
   m_bOwnStream = TRUE;
   return TRUE;
 }
 FX_BOOL CXFA_FFDoc::CloseDoc() {
   for (const auto& pair : m_TypeToDocViewMap)
     pair.second->RunDocClose();
 
   if (m_pDocument)
@@ skipping 105 matching lines @@
 
   return !!pExport->Export(
       pFile, pNode, 0, bsChecksum.GetLength() ? bsChecksum.c_str() : nullptr);
 }
 
 FX_BOOL CXFA_FFDoc::ImportData(IFX_FileRead* pStream, FX_BOOL bXDP) {
   std::unique_ptr<CXFA_DataImporter> importer(
       new CXFA_DataImporter(m_pDocument));
   return importer->ImportData(pStream);
 }