Remove NULL in xfa/

xfa/fxfa/parser/xfa_document_imp.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 "core/fxcrt/include/fx_ext.h"
 #include "xfa/fxfa/app/xfa_ffnotify.h"
 #include "xfa/fxfa/parser/xfa_basic_imp.h"
 #include "xfa/fxfa/parser/xfa_doclayout.h"
@@ skipping 65 matching lines @@
 
 CXFA_FFNotify* CXFA_Document::GetNotify() const {
   return m_pParser->GetNotify();
 }
 
 CXFA_Object* CXFA_Document::GetXFAObject(XFA_HashCode dwNodeNameHash) {
   switch (dwNodeNameHash) {
     case XFA_HASHCODE_Data: {
       CXFA_Node* pDatasetsNode = ToNode(GetXFAObject(XFA_HASHCODE_Datasets));
       if (!pDatasetsNode) {
-        return NULL;
+        return nullptr;
       }
       for (CXFA_Node* pDatasetsChild =
                pDatasetsNode->GetFirstChildByClass(XFA_Element::DataGroup);
            pDatasetsChild;
            pDatasetsChild = pDatasetsChild->GetNextSameClassSibling(
                XFA_Element::DataGroup)) {
         if (pDatasetsChild->GetNameHash() != XFA_HASHCODE_Data) {
           continue;
         }
         CFX_WideString wsNamespaceURI;
         if (!pDatasetsChild->TryNamespace(wsNamespaceURI)) {
           continue;
         }
         CFX_WideString wsDatasetsURI;
         if (!pDatasetsNode->TryNamespace(wsDatasetsURI)) {
           continue;
         }
         if (wsNamespaceURI == wsDatasetsURI) {
           return pDatasetsChild;
         }
       }
+      return nullptr;
     }
-      return NULL;
     case XFA_HASHCODE_Record: {
       CXFA_Node* pData = ToNode(GetXFAObject(XFA_HASHCODE_Data));
-      return pData ? pData->GetFirstChildByClass(XFA_Element::DataGroup) : NULL;
+      return pData ? pData->GetFirstChildByClass(XFA_Element::DataGroup)
+                   : nullptr;
     }
     case XFA_HASHCODE_DataWindow: {
-      if (m_pScriptDataWindow == NULL) {
+      if (!m_pScriptDataWindow)
         m_pScriptDataWindow = new CScript_DataWindow(this);
-      }
       return m_pScriptDataWindow;
     }
     case XFA_HASHCODE_Event: {
-      if (m_pScriptEvent == NULL) {
+      if (!m_pScriptEvent)
         m_pScriptEvent = new CScript_EventPseudoModel(this);
-      }
       return m_pScriptEvent;
     }
     case XFA_HASHCODE_Host: {
-      if (m_pScriptHost == NULL) {
+      if (!m_pScriptHost)
         m_pScriptHost = new CScript_HostPseudoModel(this);
-      }
       return m_pScriptHost;
     }
     case XFA_HASHCODE_Log: {
-      if (m_pScriptLog == NULL) {
+      if (!m_pScriptLog)
         m_pScriptLog = new CScript_LogPseudoModel(this);
-      }
       return m_pScriptLog;
     }
     case XFA_HASHCODE_Signature: {
-      if (m_pScriptSignature == NULL) {
+      if (!m_pScriptSignature)
         m_pScriptSignature = new CScript_SignaturePseudoModel(this);
-      }
       return m_pScriptSignature;
     }
     case XFA_HASHCODE_Layout: {
-      if (m_pScriptLayout == NULL) {
+      if (!m_pScriptLayout)
         m_pScriptLayout = new CScript_LayoutPseudoModel(this);
-      }
       return m_pScriptLayout;
     }
     default:
       return m_pRootNode->GetFirstChildByName(dwNodeNameHash);
   }
 }
 CXFA_Node* CXFA_Document::CreateNode(uint32_t dwPacket, XFA_Element eElement) {
   return CreateNode(XFA_GetPacketByID(dwPacket), eElement);
 }
 
@@ skipping 103 matching lines @@
   XFA_VERSION eVersion = (XFA_VERSION)((int32_t)iMajor * 100 + iMinor);
   if (eVersion < XFA_VERSION_MIN || eVersion > XFA_VERSION_MAX) {
     return XFA_VERSION_UNKNOWN;
   }
   m_eCurVersionMode = eVersion;
   return eVersion;
 }
 CXFA_Node* CXFA_Document::GetNodeByID(CXFA_Node* pRoot,
                                       const CFX_WideStringC& wsID) {
   if (!pRoot || wsID.IsEmpty()) {
-    return NULL;
+    return nullptr;
   }
   CXFA_NodeIterator sIterator(pRoot);
   for (CXFA_Node* pNode = sIterator.GetCurrent(); pNode;
        pNode = sIterator.MoveToNext()) {
     CFX_WideStringC wsIDVal;
     if (pNode->TryCData(XFA_ATTRIBUTE_Id, wsIDVal) && !wsIDVal.IsEmpty()) {
       if (wsIDVal == wsID) {
         return pNode;
       }
     }
   }
-  return NULL;
+  return nullptr;
 }
 static void XFA_ProtoMerge_MergeNodeRecurse(CXFA_Document* pDocument,
                                             CXFA_Node* pDestNodeParent,
                                             CXFA_Node* pProtoNode) {
-  CXFA_Node* pExistingNode = NULL;
+  CXFA_Node* pExistingNode = nullptr;
   for (CXFA_Node* pFormChild =
            pDestNodeParent->GetNodeItem(XFA_NODEITEM_FirstChild);
        pFormChild;
        pFormChild = pFormChild->GetNodeItem(XFA_NODEITEM_NextSibling)) {
     if (pFormChild->GetElementType() == pProtoNode->GetElementType() &&
         pFormChild->GetNameHash() == pProtoNode->GetNameHash() &&
         pFormChild->IsUnusedNode()) {
       pFormChild->ClearFlag(XFA_NodeFlag_UnusedNode);
       pExistingNode = pFormChild;
       break;
     }
   }
   if (pExistingNode) {
     pExistingNode->SetTemplateNode(pProtoNode);
     for (CXFA_Node* pTemplateChild =
              pProtoNode->GetNodeItem(XFA_NODEITEM_FirstChild);
          pTemplateChild; pTemplateChild = pTemplateChild->GetNodeItem(
                              XFA_NODEITEM_NextSibling)) {
       XFA_ProtoMerge_MergeNodeRecurse(pDocument, pExistingNode, pTemplateChild);
     }
     return;
   }
   CXFA_Node* pNewNode = pProtoNode->Clone(TRUE);
   pNewNode->SetTemplateNode(pProtoNode);
-  pDestNodeParent->InsertChild(pNewNode, NULL);
+  pDestNodeParent->InsertChild(pNewNode, nullptr);
 }
 static void XFA_ProtoMerge_MergeNode(CXFA_Document* pDocument,
                                      CXFA_Node* pDestNode,
                                      CXFA_Node* pProtoNode) {
   {
     CXFA_NodeIterator sIterator(pDestNode);
     for (CXFA_Node* pNode = sIterator.GetCurrent(); pNode;
          pNode = sIterator.MoveToNext()) {
       pNode->SetFlag(XFA_NodeFlag_UnusedNode, true);
     }
@@ skipping 61 matching lines @@
                !wsUseVal.IsEmpty()) {
       if (wsUseVal[0] == '#') {
         wsID = CFX_WideStringC(wsUseVal.c_str() + 1, wsUseVal.GetLength() - 1);
       } else {
         wsSOM = CFX_WideStringC(wsUseVal.c_str(), wsUseVal.GetLength());
       }
     }
     if (!wsURI.IsEmpty() && wsURI != FX_WSTRC(L".")) {
       continue;
     }
-    CXFA_Node* pProtoNode = NULL;
+    CXFA_Node* pProtoNode = nullptr;
     if (!wsSOM.IsEmpty()) {
       uint32_t dwFlag = XFA_RESOLVENODE_Children | XFA_RESOLVENODE_Attributes |
                         XFA_RESOLVENODE_Properties | XFA_RESOLVENODE_Parent |
                         XFA_RESOLVENODE_Siblings;
       XFA_RESOLVENODE_RS resoveNodeRS;
       int32_t iRet = m_pScriptContext->ResolveObjects(pUseHrefNode, wsSOM,
                                                       resoveNodeRS, dwFlag);
       if (iRet > 0 && resoveNodeRS.nodes[0]->IsNode()) {
         pProtoNode = resoveNodeRS.nodes[0]->AsNode();
       }
     } else if (!wsID.IsEmpty()) {
       if (!mIDMap.Lookup(FX_HashCode_GetW(wsID, false), pProtoNode)) {
         continue;
       }
     }
     if (!pProtoNode) {
       continue;
     }
     XFA_ProtoMerge_MergeNode(this, pUseHrefNode, pProtoNode);
   }
 }