Remove NULL in xfa/

xfa/fxfa/app/xfa_ffdocview.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_ffdocview.h"
 
 #include "core/fxcrt/include/fx_ext.h"
 #include "xfa/fxfa/app/xfa_ffbarcode.h"
@@ skipping 181 matching lines @@
   UnlockUpdate();
 }
 int32_t CXFA_FFDocView::CountPageViews() {
   if (!m_pXFADocLayout) {
     return 0;
   }
   return m_pXFADocLayout->CountPages();
 }
 CXFA_FFPageView* CXFA_FFDocView::GetPageView(int32_t nIndex) {
   if (!m_pXFADocLayout) {
-    return NULL;
+    return nullptr;
   }
   return static_cast<CXFA_FFPageView*>(m_pXFADocLayout->GetPage(nIndex));
 }
 
 CXFA_LayoutProcessor* CXFA_FFDocView::GetXFALayout() const {
   return m_pDoc->GetXFADoc()->GetDocLayout();
 }
 FX_BOOL CXFA_FFDocView::ResetSingleWidgetAccData(CXFA_WidgetAcc* pWidgetAcc) {
   CXFA_Node* pNode = pWidgetAcc->GetNode();
   XFA_Element eType = pNode->GetElementType();
   if (eType != XFA_Element::Field && eType != XFA_Element::ExclGroup) {
     return FALSE;
   }
   pWidgetAcc->ResetData();
   pWidgetAcc->UpdateUIDisplay();
   if (CXFA_Validate validate = pWidgetAcc->GetValidate()) {
     AddValidateWidget(pWidgetAcc);
     validate.GetNode()->SetFlag(XFA_NodeFlag_NeedsInitApp, false);
   }
   return TRUE;
 }
 void CXFA_FFDocView::ResetWidgetData(CXFA_WidgetAcc* pWidgetAcc) {
   m_bLayoutEvent = TRUE;
   FX_BOOL bChanged = FALSE;
-  CXFA_Node* pFormNode = NULL;
+  CXFA_Node* pFormNode = nullptr;
   if (pWidgetAcc) {
     bChanged = ResetSingleWidgetAccData(pWidgetAcc);
     pFormNode = pWidgetAcc->GetNode();
   } else {
     pFormNode = GetRootSubform();
   }
   if (!pFormNode) {
     return;
   }
   if (pFormNode->GetElementType() != XFA_Element::Field &&
@@ skipping 70 matching lines @@
 CXFA_FFWidgetHandler* CXFA_FFDocView::GetWidgetHandler() {
   if (!m_pWidgetHandler) {
     m_pWidgetHandler = new CXFA_FFWidgetHandler(this);
   }
   return m_pWidgetHandler;
 }
 
 CXFA_WidgetAccIterator* CXFA_FFDocView::CreateWidgetAccIterator(
     XFA_WIDGETORDER eOrder) {
   CXFA_Node* pFormRoot = GetRootSubform();
-  if (!pFormRoot) {
-    return NULL;
-  }
-  return new CXFA_WidgetAccIterator(this, pFormRoot);
+  return pFormRoot ? new CXFA_WidgetAccIterator(this, pFormRoot) : nullptr;
 }
 CXFA_FFWidget* CXFA_FFDocView::GetFocusWidget() {
   return m_pFocusWidget;
 }
 void CXFA_FFDocView::KillFocus() {
   if (m_pFocusWidget &&
       (m_pFocusWidget->GetStatus() & XFA_WidgetStatus_Focused)) {
-    (m_pFocusWidget)->OnKillFocus(NULL);
+    (m_pFocusWidget)->OnKillFocus(nullptr);
   }
-  m_pFocusAcc = NULL;
-  m_pFocusWidget = NULL;
-  m_pOldFocusWidget = NULL;
+  m_pFocusAcc = nullptr;
+  m_pFocusWidget = nullptr;
+  m_pOldFocusWidget = nullptr;
 }
 FX_BOOL CXFA_FFDocView::SetFocus(CXFA_FFWidget* hWidget) {
   CXFA_FFWidget* pNewFocus = hWidget;
   if (m_pOldFocusWidget == pNewFocus) {
     return FALSE;
   }
   CXFA_FFWidget* pOldFocus = m_pOldFocusWidget;
   m_pOldFocusWidget = pNewFocus;
   if (pOldFocus) {
     if (m_pFocusWidget != m_pOldFocusWidget &&
         (pOldFocus->GetStatus() & XFA_WidgetStatus_Focused)) {
       m_pFocusWidget = pOldFocus;
       pOldFocus->OnKillFocus(pNewFocus);
     } else if ((pOldFocus->GetStatus() & XFA_WidgetStatus_Visible)) {
       if (!pOldFocus->IsLoaded()) {
         pOldFocus->LoadWidget();
       }
       pOldFocus->OnSetFocus(m_pFocusWidget);
       m_pFocusWidget = pOldFocus;
       pOldFocus->OnKillFocus(pNewFocus);
     }
   }
   if (m_pFocusWidget == m_pOldFocusWidget) {
     return FALSE;
   }
   pNewFocus = m_pOldFocusWidget;
   if (m_pListFocusWidget && pNewFocus == m_pListFocusWidget) {
-    m_pFocusAcc = NULL;
-    m_pFocusWidget = NULL;
-    m_pListFocusWidget = NULL;
-    m_pOldFocusWidget = NULL;
+    m_pFocusAcc = nullptr;
+    m_pFocusWidget = nullptr;
+    m_pListFocusWidget = nullptr;
+    m_pOldFocusWidget = nullptr;
     return FALSE;
   }
   if (pNewFocus && (pNewFocus->GetStatus() & XFA_WidgetStatus_Visible)) {
     if (!pNewFocus->IsLoaded()) {
       pNewFocus->LoadWidget();
     }
     pNewFocus->OnSetFocus(m_pFocusWidget);
   }
-  m_pFocusAcc = pNewFocus ? pNewFocus->GetDataAcc() : NULL;
+  m_pFocusAcc = pNewFocus ? pNewFocus->GetDataAcc() : nullptr;
   m_pFocusWidget = pNewFocus;
   m_pOldFocusWidget = m_pFocusWidget;
   return TRUE;
 }
 CXFA_WidgetAcc* CXFA_FFDocView::GetFocusWidgetAcc() {
   return m_pFocusAcc;
 }
 void CXFA_FFDocView::SetFocusWidgetAcc(CXFA_WidgetAcc* pWidgetAcc) {
   CXFA_FFWidget* pNewFocus =
-      pWidgetAcc ? pWidgetAcc->GetNextWidget(NULL) : NULL;
+      pWidgetAcc ? pWidgetAcc->GetNextWidget(nullptr) : nullptr;
   if (SetFocus(pNewFocus)) {
     m_pFocusAcc = pWidgetAcc;
     if (m_iStatus == XFA_DOCVIEW_LAYOUTSTATUS_End) {
       m_pDoc->GetDocProvider()->SetFocusWidget(m_pDoc, m_pFocusWidget);
     }
   }
 }
 void CXFA_FFDocView::DeleteLayoutItem(CXFA_FFWidget* pWidget) {
   if (m_pFocusAcc == pWidget->GetDataAcc()) {
-    m_pFocusAcc = NULL;
-    m_pFocusWidget = NULL;
-    m_pOldFocusWidget = NULL;
+    m_pFocusAcc = nullptr;
+    m_pFocusWidget = nullptr;
+    m_pOldFocusWidget = nullptr;
   }
 }
 static int32_t XFA_ProcessEvent(CXFA_FFDocView* pDocView,
                                 CXFA_WidgetAcc* pWidgetAcc,
                                 CXFA_EventParam* pParam) {
   if (!pParam || pParam->m_eType == XFA_EVENT_Unknown) {
     return XFA_EVENTERROR_NotExist;
   }
   if (!pWidgetAcc || pWidgetAcc->GetElementType() == XFA_Element::Draw) {
     return XFA_EVENTERROR_NotExist;
@@ skipping 34 matching lines @@
   int32_t iRet = XFA_EVENTERROR_NotExist;
   if (pFormNode == pExclude) {
     return iRet;
   }
   XFA_Element elementType = pFormNode->GetElementType();
   if (elementType == XFA_Element::Field) {
     if (eEventType == XFA_EVENT_IndexChange) {
       return iRet;
     }
     CXFA_WidgetAcc* pWidgetAcc = (CXFA_WidgetAcc*)pFormNode->GetWidgetData();
-    if (pWidgetAcc == NULL) {
+    if (!pWidgetAcc) {
       return iRet;
     }
     CXFA_EventParam eParam;
     eParam.m_eType = eEventType;
     eParam.m_pTarget = pWidgetAcc;
     eParam.m_bIsFormReady = bIsFormReady;
     return XFA_ProcessEvent(this, pWidgetAcc, &eParam);
   }
   if (bRecursive) {
     for (CXFA_Node* pNode = pFormNode->GetNodeItem(
              XFA_NODEITEM_FirstChild, XFA_ObjectType::ContainerNode);
          pNode; pNode = pNode->GetNodeItem(XFA_NODEITEM_NextSibling,
                                            XFA_ObjectType::ContainerNode)) {
       elementType = pNode->GetElementType();
       if (elementType != XFA_Element::Variables &&
           elementType != XFA_Element::Draw) {
         iRet |= ExecEventActivityByDeepFirst(pNode, eEventType, bIsFormReady,
                                              bRecursive, pExclude);
       }
     }
   }
   CXFA_WidgetAcc* pWidgetAcc = (CXFA_WidgetAcc*)pFormNode->GetWidgetData();
-  if (pWidgetAcc == NULL) {
+  if (!pWidgetAcc) {
     return iRet;
   }
   CXFA_EventParam eParam;
   eParam.m_eType = eEventType;
   eParam.m_pTarget = pWidgetAcc;
   eParam.m_bIsFormReady = bIsFormReady;
   iRet |= XFA_ProcessEvent(this, pWidgetAcc, &eParam);
   return iRet;
 }
 
@@ skipping 279 matching lines @@
     for (int32_t j = 0; j < iCount; j++) {
       CXFA_Object* refObj = rs.nodes[j];
       if (!refObj->IsNode()) {
         continue;
       }
       CXFA_Node* refNode = refObj->AsNode();
       if (bValueUseContent) {
         wsValue = refNode->GetContent();
       } else {
         CXFA_Node* nodeValue = refNode->GetFirstChildByName(uValueHash);
-        if (nodeValue == NULL) {
-          wsValue = refNode->GetContent();
-        } else {
-          wsValue = nodeValue->GetContent();
-        }
+        wsValue = nodeValue ? nodeValue->GetContent() : refNode->GetContent();
       }
       if (!bUseValue) {
         if (bLabelUseContent) {
           wsLabel = refNode->GetContent();
         } else {
           CXFA_Node* nodeLabel = refNode->GetFirstChildByName(wsLabelRef);
           if (nodeLabel)
             wsLabel = nodeLabel->GetContent();
         }
       } else {
         wsLabel = wsValue;
       }
       pAcc->InsertItem(wsLabel, wsValue);
     }
   }
   m_BindItems.RemoveAll();
 }
 void CXFA_FFDocView::SetChangeMark() {
   if (m_iStatus < XFA_DOCVIEW_LAYOUTSTATUS_End) {
     return;
   }
   m_pDoc->GetDocProvider()->SetChangeMark(m_pDoc);
 }
 CXFA_Node* CXFA_FFDocView::GetRootSubform() {
   CXFA_Node* pFormPacketNode =
       ToNode(m_pDoc->GetXFADoc()->GetXFAObject(XFA_HASHCODE_Form));
   if (!pFormPacketNode) {
-    return NULL;
+    return nullptr;
   }
   return pFormPacketNode->GetFirstChildByClass(XFA_Element::Subform);
 }
 
 CXFA_WidgetAccIterator::CXFA_WidgetAccIterator(CXFA_FFDocView* pDocView,
                                                CXFA_Node* pTravelRoot)
     : m_ContentIterator(pTravelRoot) {
   m_pDocView = pDocView;
-  m_pCurWidgetAcc = NULL;
+  m_pCurWidgetAcc = nullptr;
 }
 CXFA_WidgetAccIterator::~CXFA_WidgetAccIterator() {}
 void CXFA_WidgetAccIterator::Reset() {
-  m_pCurWidgetAcc = NULL;
+  m_pCurWidgetAcc = nullptr;
   m_ContentIterator.Reset();
 }
 CXFA_WidgetAcc* CXFA_WidgetAccIterator::MoveToFirst() {
-  return NULL;
+  return nullptr;
 }
 CXFA_WidgetAcc* CXFA_WidgetAccIterator::MoveToLast() {
-  return NULL;
+  return nullptr;
 }
 CXFA_WidgetAcc* CXFA_WidgetAccIterator::MoveToNext() {
   CXFA_Node* pItem = m_pCurWidgetAcc ? m_ContentIterator.MoveToNext()
                                      : m_ContentIterator.GetCurrent();
   while (pItem) {
     m_pCurWidgetAcc = static_cast<CXFA_WidgetAcc*>(pItem->GetWidgetData());
     if (m_pCurWidgetAcc)
       return m_pCurWidgetAcc;
     pItem = m_ContentIterator.MoveToNext();
   }
-  return NULL;
+  return nullptr;
 }
 CXFA_WidgetAcc* CXFA_WidgetAccIterator::MoveToPrevious() {
-  return NULL;
+  return nullptr;
 }
 CXFA_WidgetAcc* CXFA_WidgetAccIterator::GetCurrentWidgetAcc() {
-  return NULL;
+  return nullptr;
 }
 FX_BOOL CXFA_WidgetAccIterator::SetCurrentWidgetAcc(CXFA_WidgetAcc* hWidget) {
   return FALSE;
 }
 void CXFA_WidgetAccIterator::SkipTree() {
   m_ContentIterator.SkipChildrenAndMoveToNext();
-  m_pCurWidgetAcc = NULL;
+  m_pCurWidgetAcc = nullptr;
 }