Get rid of NULLs in xfa/

xfa/fwl/core/fwl_noteimp.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/fwl/core/fwl_noteimp.h"
 
 #include "core/fxcrt/include/fx_ext.h"
 #include "third_party/base/stl_util.h"
@@ skipping 145 matching lines @@
   }
   IFWL_Widget* pPrev = m_pFocus;
   m_pFocus = pFocus;
   if (pPrev) {
     CFWL_MsgKillFocus ms;
     ms.m_pDstTarget = pPrev;
     ms.m_pSrcTarget = pPrev;
     if (bNotify) {
       ms.m_dwExtend = 1;
     }
-    IFWL_WidgetDelegate* pDelegate = pPrev->SetDelegate(NULL);
+    IFWL_WidgetDelegate* pDelegate = pPrev->SetDelegate(nullptr);
     if (pDelegate) {
       pDelegate->OnProcessMessage(&ms);
     }
   }
   if (pFocus) {
     IFWL_Widget* pWidget =
         CFWL_WidgetMgr::GetInstance()->GetSystemFormWidget(pFocus);
     CFWL_FormImp* pForm =
         pWidget ? static_cast<CFWL_FormImp*>(pWidget->GetImpl()) : nullptr;
     if (pForm) {
       CFWL_WidgetImp* pNewFocus =
           static_cast<CFWL_WidgetImp*>(pFocus->GetImpl());
       pForm->SetSubFocus(pNewFocus);
     }
     CFWL_MsgSetFocus ms;
     ms.m_pDstTarget = pFocus;
     if (bNotify) {
       ms.m_dwExtend = 1;
     }
-    IFWL_WidgetDelegate* pDelegate = pFocus->SetDelegate(NULL);
+    IFWL_WidgetDelegate* pDelegate = pFocus->SetDelegate(nullptr);
     if (pDelegate) {
       pDelegate->OnProcessMessage(&ms);
     }
   }
   return TRUE;
 }
 FWL_Error CFWL_NoteDriver::Run() {
   CFWL_WidgetMgr* pWidgetMgr = CFWL_WidgetMgr::GetInstance();
   if (!pWidgetMgr)
     return FWL_Error::Indefinite;
 
 #if (_FX_OS_ == _FX_LINUX_DESKTOP_ || _FX_OS_ == _FX_WIN32_DESKTOP_ || \
      _FX_OS_ == _FX_WIN64_)
-  CFWL_NoteLoop* pTopLoop = NULL;
+  CFWL_NoteLoop* pTopLoop = nullptr;
   for (;;) {
     pTopLoop = GetTopLoop();
     if (!pTopLoop || !pTopLoop->ContinueModal())
       break;
     if (UnqueueMessage(pTopLoop))
       continue;
   }
 #endif
 
   return FWL_Error::Succeeded;
 }
 
 IFWL_Widget* CFWL_NoteDriver::GetFocus() {
   return m_pFocus;
 }
 IFWL_Widget* CFWL_NoteDriver::GetHover() {
   return m_pHover;
 }
 void CFWL_NoteDriver::SetHover(IFWL_Widget* pHover) {
   m_pHover = pHover;
 }
 void CFWL_NoteDriver::SetGrab(IFWL_Widget* pGrab, FX_BOOL bSet) {
-  m_pGrab = bSet ? pGrab : NULL;
+  m_pGrab = bSet ? pGrab : nullptr;
 }
 void CFWL_NoteDriver::NotifyTargetHide(IFWL_Widget* pNoteTarget) {
   if (m_pFocus == pNoteTarget) {
-    m_pFocus = NULL;
+    m_pFocus = nullptr;
   }
   if (m_pHover == pNoteTarget) {
-    m_pHover = NULL;
+    m_pHover = nullptr;
   }
   if (m_pGrab == pNoteTarget) {
-    m_pGrab = NULL;
+    m_pGrab = nullptr;
   }
 }
 void CFWL_NoteDriver::NotifyTargetDestroy(IFWL_Widget* pNoteTarget) {
   if (m_pFocus == pNoteTarget) {
-    m_pFocus = NULL;
+    m_pFocus = nullptr;
   }
   if (m_pHover == pNoteTarget) {
-    m_pHover = NULL;
+    m_pHover = nullptr;
   }
   if (m_pGrab == pNoteTarget) {
-    m_pGrab = NULL;
+    m_pGrab = nullptr;
   }
   UnregisterEventTarget(pNoteTarget);
   int32_t count = m_forms.GetSize();
   for (int32_t nIndex = 0; nIndex < count; nIndex++) {
     CFWL_FormImp* pForm = static_cast<CFWL_FormImp*>(m_forms[nIndex]);
     if (!pForm) {
       continue;
     }
     CFWL_WidgetImp* pSubFocus = pForm->GetSubFocus();
     if (!pSubFocus)
       return;
     if (pSubFocus && pSubFocus->GetInterface() == pNoteTarget) {
-      pForm->SetSubFocus(NULL);
+      pForm->SetSubFocus(nullptr);
     }
   }
 }
 
 FWL_Error CFWL_NoteDriver::RegisterForm(CFWL_WidgetImp* pForm) {
   if (!pForm)
     return FWL_Error::Indefinite;
   if (m_forms.Find(pForm) >= 0) {
     return FWL_Error::Indefinite;
   }
@@ skipping 113 matching lines @@
       bRet =
           DoDragFiles(static_cast<CFWL_MsgDropFiles*>(pMessage), pMessageForm);
       break;
     }
     default: {
       bRet = TRUE;
       break;
     }
   }
   if (bRet) {
-    IFWL_WidgetDelegate* pDelegate = pMessage->m_pDstTarget->SetDelegate(NULL);
+    IFWL_WidgetDelegate* pDelegate =
+        pMessage->m_pDstTarget->SetDelegate(nullptr);
     if (pDelegate)
       pDelegate->OnProcessMessage(pMessage);
   }
   return bRet;
 }
 
 FX_BOOL CFWL_NoteDriver::DoActivate(CFWL_MsgActivate* pMsg,
                                     IFWL_Widget* pMessageForm) {
   pMsg->m_pDstTarget = pMessageForm;
   return (pMsg->m_pDstTarget)->GetStates() & FWL_WGTSTATE_Deactivated;
@@ skipping 49 matching lines @@
       }
     }
   }
   return FALSE;
 }
 FX_BOOL CFWL_NoteDriver::DoKillFocus(CFWL_MsgKillFocus* pMsg,
                                      IFWL_Widget* pMessageForm) {
   CFWL_WidgetMgr* pWidgetMgr = CFWL_WidgetMgr::GetInstance();
   if (pWidgetMgr->IsFormDisabled()) {
     if (m_pFocus == pMsg->m_pDstTarget) {
-      m_pFocus = NULL;
+      m_pFocus = nullptr;
     }
     return TRUE;
   }
   IFWL_Widget* pWidget = pMsg->m_pDstTarget;
   CFWL_FormImp* pForm =
       pWidget ? static_cast<CFWL_FormImp*>(pWidget->GetImpl()) : nullptr;
   if (pForm) {
     CFWL_WidgetImp* pSubFocus = pForm->GetSubFocus();
     if (pSubFocus && (pSubFocus->GetStates() & FWL_WGTSTATE_Focused)) {
       pMsg->m_pDstTarget = pSubFocus->GetInterface();
       if (m_pFocus == pMsg->m_pDstTarget) {
-        m_pFocus = NULL;
+        m_pFocus = nullptr;
         return TRUE;
       }
     }
   }
   return FALSE;
 }
 FX_BOOL CFWL_NoteDriver::DoKey(CFWL_MsgKey* pMsg, IFWL_Widget* pMessageForm) {
 #if (_FX_OS_ != _FX_MACOSX_)
   if (pMsg->m_dwCmd == FWL_KeyCommand::KeyDown &&
       pMsg->m_dwKeyCode == FWL_VKEY_Tab) {
@@ skipping 32 matching lines @@
     return FALSE;
   }
   pMsg->m_pDstTarget = m_pFocus;
   return TRUE;
 }
 FX_BOOL CFWL_NoteDriver::DoMouse(CFWL_MsgMouse* pMsg,
                                  IFWL_Widget* pMessageForm) {
   if (pMsg->m_dwCmd == FWL_MouseCommand::Leave ||
       pMsg->m_dwCmd == FWL_MouseCommand::Hover ||
       pMsg->m_dwCmd == FWL_MouseCommand::Enter) {
-    return pMsg->m_pDstTarget != NULL;
+    return !!pMsg->m_pDstTarget;
   }
   if (pMsg->m_pDstTarget != pMessageForm) {
     pMsg->m_pDstTarget->TransformTo(pMessageForm, pMsg->m_fx, pMsg->m_fy);
   }
   if (!DoMouseEx(pMsg, pMessageForm)) {
     pMsg->m_pDstTarget = pMessageForm;
   }
   return TRUE;
 }
 FX_BOOL CFWL_NoteDriver::DoWheel(CFWL_MsgMouseWheel* pMsg,
@@ skipping 25 matching lines @@
 }
 FX_BOOL CFWL_NoteDriver::DoDragFiles(CFWL_MsgDropFiles* pMsg,
                                      IFWL_Widget* pMessageForm) {
   return pMsg->m_pDstTarget == pMessageForm;
 }
 FX_BOOL CFWL_NoteDriver::DoMouseEx(CFWL_MsgMouse* pMsg,
                                    IFWL_Widget* pMessageForm) {
   CFWL_WidgetMgr* pWidgetMgr = CFWL_WidgetMgr::GetInstance();
   if (!pWidgetMgr)
     return FALSE;
-  IFWL_Widget* pTarget = NULL;
+  IFWL_Widget* pTarget = nullptr;
   if (m_pGrab)
     pTarget = m_pGrab;
   if (!pTarget) {
     pTarget =
         pWidgetMgr->GetWidgetAtPoint(pMessageForm, pMsg->m_fx, pMsg->m_fy);
   }
   if (pTarget) {
     if (pMessageForm != pTarget) {
       pMessageForm->TransformTo(pTarget, pMsg->m_fx, pMsg->m_fy);
     }
@@ skipping 108 matching lines @@
   wsCaption = m_wsCaption;
   return FWL_Error::Succeeded;
 }
 int32_t CFWL_CoreToolTipDP::GetInitialDelay(IFWL_Widget* pWidget) {
   return m_nInitDelayTime;
 }
 int32_t CFWL_CoreToolTipDP::GetAutoPopDelay(IFWL_Widget* pWidget) {
   return m_nAutoPopDelayTime;
 }
 CFX_DIBitmap* CFWL_CoreToolTipDP::GetToolTipIcon(IFWL_Widget* pWidget) {
-  return NULL;
+  return nullptr;
 }
 CFX_SizeF CFWL_CoreToolTipDP::GetToolTipIconSize(IFWL_Widget* pWidget) {
   return CFX_SizeF();
 }
 CFX_RectF CFWL_CoreToolTipDP::GetAnchor() {
   return m_fAnchor;
 }
 CFWL_EventTarget::~CFWL_EventTarget() {
   m_eventSources.RemoveAll();
 }
 int32_t CFWL_EventTarget::SetEventSource(IFWL_Widget* pSource,
                                          uint32_t dwFilter) {
   if (pSource) {
     m_eventSources.SetAt(pSource, dwFilter);
     return m_eventSources.GetCount();
   }
   return 1;
 }
 
 FX_BOOL CFWL_EventTarget::ProcessEvent(CFWL_Event* pEvent) {
-  IFWL_WidgetDelegate* pDelegate = m_pListener->SetDelegate(NULL);
+  IFWL_WidgetDelegate* pDelegate = m_pListener->SetDelegate(nullptr);
   if (!pDelegate)
     return FALSE;
   if (m_eventSources.GetCount() == 0) {
     pDelegate->OnProcessEvent(pEvent);
     return TRUE;
   }
   FX_POSITION pos = m_eventSources.GetStartPosition();
   while (pos) {
-    IFWL_Widget* pSource = NULL;
+    IFWL_Widget* pSource = nullptr;
     uint32_t dwFilter = 0;
     m_eventSources.GetNextAssoc(pos, (void*&)pSource, dwFilter);
     if (pSource == pEvent->m_pSrcTarget ||
         pEvent->GetClassID() == CFWL_EventType::Idle) {
       if (IsFilterEvent(pEvent, dwFilter)) {
         pDelegate->OnProcessEvent(pEvent);
         return TRUE;
       }
     }
   }
@@ skipping 20 matching lines @@
       return !!(dwFilter & FWL_EVENT_CLOSE_MASK);
     case CFWL_EventType::SizeChanged:
       return !!(dwFilter & FWL_EVENT_SIZECHANGED_MASK);
     case CFWL_EventType::Idle:
       return !!(dwFilter & FWL_EVENT_IDLE_MASK);
     default:
       return !!(dwFilter & FWL_EVENT_CONTROL_MASK);
   }
 }
 
-CFWL_ToolTipContainer* CFWL_ToolTipContainer::s_pInstance = NULL;
+CFWL_ToolTipContainer* CFWL_ToolTipContainer::s_pInstance = nullptr;
 
 CFWL_ToolTipContainer::CFWL_ToolTipContainer()
-    : pCurTarget(NULL), m_pToolTipImp(NULL) {
+    : pCurTarget(nullptr), m_pToolTipImp(nullptr) {
   m_ToolTipDp = new CFWL_CoreToolTipDP;
   m_ToolTipDp->m_nInitDelayTime = 0;
   m_ToolTipDp->m_nAutoPopDelayTime = 2000;
 }
 CFWL_ToolTipContainer::~CFWL_ToolTipContainer() {
   if (m_pToolTipImp) {
     IFWL_ToolTip* pToolTip =
         static_cast<IFWL_ToolTip*>(m_pToolTipImp->GetInterface());
     pToolTip->Finalize();
     delete pToolTip;
   }
   delete m_ToolTipDp;
 }
 
 // static
 CFWL_ToolTipContainer* CFWL_ToolTipContainer::getInstance() {
   if (!s_pInstance)
     s_pInstance = new CFWL_ToolTipContainer;
   return s_pInstance;
 }
 
 // static
 void CFWL_ToolTipContainer::DeleteInstance() {
   delete s_pInstance;
-  s_pInstance = NULL;
+  s_pInstance = nullptr;
 }
 
 FWL_Error CFWL_ToolTipContainer::AddToolTipTarget(IFWL_ToolTipTarget* pTarget) {
   if (m_arrWidget.Find(pTarget) < 0) {
     m_arrWidget.Add(pTarget);
     return FWL_Error::Succeeded;
   }
   return FWL_Error::Indefinite;
 }
 FWL_Error CFWL_ToolTipContainer::RemoveToolTipTarget(
@@ skipping 12 matching lines @@
     if (p->GetWidget() == pWedget) {
       pCurTarget = p;
       return TRUE;
     }
   }
   return FALSE;
 }
 FX_BOOL CFWL_ToolTipContainer::ProcessEnter(CFWL_EvtMouse* pEvt,
                                             IFWL_Widget* pOwner) {
   if (HasToolTip(pEvt->m_pDstTarget)) {
-    if (NULL == m_pToolTipImp) {
+    if (!m_pToolTipImp) {
       CFWL_WidgetImpProperties prop;
       prop.m_pDataProvider = m_ToolTipDp;
       prop.m_pOwner = pOwner;
       CFX_RectF rtTooltip;
       rtTooltip.Set(150, 150, 100, 50);
       prop.m_rtWidget = rtTooltip;
       IFWL_ToolTip* pToolTip = IFWL_ToolTip::Create(prop, nullptr);
       pToolTip->Initialize();
       m_pToolTipImp = static_cast<CFWL_ToolTipImp*>(pToolTip->GetImpl());
       m_pToolTipImp->ModifyStylesEx(FWL_STYLEEXT_TTP_Multiline, 0);
@@ skipping 18 matching lines @@
         rt.height = r.height;
       }
       CFX_PointF pt(pEvt->m_fx, pEvt->m_fy);
       if (pCurTarget->GetToolTipPos(pt) == FWL_Error::Succeeded) {
         rt.left = pt.x;
         rt.top = pt.y;
         m_pToolTipImp->ModifyStylesEx(FWL_STYLEEXT_TTP_NoAnchor, 0);
       } else {
         CFX_RectF rtAnchor;
         pCurTarget->GetWidget()->GetClientRect(rtAnchor);
-        pCurTarget->GetWidget()->TransformTo(NULL, rtAnchor.left, rtAnchor.top);
+        pCurTarget->GetWidget()->TransformTo(nullptr, rtAnchor.left,
+                                             rtAnchor.top);
         m_pToolTipImp->SetAnchor(rtAnchor);
         m_pToolTipImp->ModifyStylesEx(0, FWL_STYLEEXT_TTP_NoAnchor);
       }
       m_pToolTipImp->SetWidgetRect(rt);
       m_pToolTipImp->Update();
       m_pToolTipImp->Show();
     }
     return TRUE;
   }
   return FALSE;
 }
 FX_BOOL CFWL_ToolTipContainer::ProcessLeave(CFWL_EvtMouse* pEvt) {
-  if (HasToolTip(pEvt->m_pDstTarget) && NULL != m_pToolTipImp) {
+  if (HasToolTip(pEvt->m_pDstTarget) && m_pToolTipImp) {
     m_pToolTipImp->Hide();
-    pCurTarget = NULL;
+    pCurTarget = nullptr;
     return TRUE;
   }
   return FALSE;
 }
 IFWL_ToolTipTarget* CFWL_ToolTipContainer::GetCurrentToolTipTarget() {
   return pCurTarget;
 }