Remove CFX_ArrayTemplate, use unique_ptr in fpdfsdk/pdfwindow

fpdfsdk/pdfwindow/PWL_Wnd.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 <map>
 
 #include "fpdfsdk/pdfwindow/PWL_ScrollBar.h"
 #include "fpdfsdk/pdfwindow/PWL_Utils.h"
@@ skipping 252 matching lines @@
     m_sPrivateParam.pFocusHandler = nullptr;
 }
 
 void CPWL_Wnd::InvalidateProvider(IPWL_Provider* provider) {
   if (m_sPrivateParam.pProvider == provider)
     m_sPrivateParam.pProvider = nullptr;
 }
 
 void CPWL_Wnd::Destroy() {
   KillFocus();
-
   OnDestroy();
-
   if (m_bCreated) {
-    for (int32_t i = m_aChildren.GetSize() - 1; i >= 0; i--) {
-      if (CPWL_Wnd* pChild = m_aChildren[i]) {
+    for (auto it = m_Children.rbegin(); it != m_Children.rend(); ++it) {
+      if (CPWL_Wnd* pChild = *it) {
+        *it = nullptr;

[dsinclair, 2017/01/02 17:58:17]

Why do we need to set the thing the iterator points to to a nullptr?

[Tom Sepez, 2017/01/03 22:11:28]

Because we're not actually removing the element from m_Childern, so I want to
keep it consistent at least until the clear below in case OnNotify somehow
enters one of these methods.

         pChild->Destroy();
         delete pChild;
-        pChild = nullptr;
       }
     }
-
     if (m_sPrivateParam.pParentWnd)
       m_sPrivateParam.pParentWnd->OnNotify(this, PNM_REMOVECHILD);
+
     m_bCreated = false;
   }
-
   DestroyMsgControl();
-
   FXSYS_memset(&m_sPrivateParam, 0, sizeof(PWL_CREATEPARAM));
-  m_aChildren.RemoveAll();
+  m_Children.clear();
   m_pVScrollBar = nullptr;
 }
 
 void CPWL_Wnd::Move(const CFX_FloatRect& rcNew, bool bReset, bool bRefresh) {
   if (IsValid()) {
     CFX_FloatRect rcOld = GetWindowRect();
 
     m_rcWindow = rcNew;
     m_rcWindow.Normalize();
 
@@ skipping 41 matching lines @@
           GetBorderLeftTopColor(GetBorderStyle()),
           GetBorderRightBottomColor(GetBorderStyle()), GetBorderStyle(),
           GetBorderDash());
     }
 
     sAppStream << sThis;
   }
 }
 
 void CPWL_Wnd::GetChildAppearanceStream(CFX_ByteTextBuf& sAppStream) {
-  for (int32_t i = 0, sz = m_aChildren.GetSize(); i < sz; i++) {
-    if (CPWL_Wnd* pChild = m_aChildren.GetAt(i)) {
+  for (CPWL_Wnd* pChild : m_Children) {
+    if (pChild)
       pChild->GetAppearanceStream(sAppStream);
-    }
   }
 }
 
 void CPWL_Wnd::DrawAppearance(CFX_RenderDevice* pDevice,
                               CFX_Matrix* pUser2Device) {
   if (IsValid() && IsVisible()) {
     DrawThisAppearance(pDevice, pUser2Device);
     DrawChildAppearance(pDevice, pUser2Device);
   }
 }
@@ skipping 13 matching lines @@
       CPWL_Utils::DrawBorder(pDevice, pUser2Device, rectWnd,
                              (FX_FLOAT)GetBorderWidth(), GetBorderColor(),
                              GetBorderLeftTopColor(GetBorderStyle()),
                              GetBorderRightBottomColor(GetBorderStyle()),
                              GetBorderStyle(), GetTransparency());
   }
 }
 
 void CPWL_Wnd::DrawChildAppearance(CFX_RenderDevice* pDevice,
                                    CFX_Matrix* pUser2Device) {
-  for (int32_t i = 0, sz = m_aChildren.GetSize(); i < sz; i++) {
-    if (CPWL_Wnd* pChild = m_aChildren.GetAt(i)) {
-      CFX_Matrix mt = pChild->GetChildMatrix();
-      if (mt.IsIdentity()) {
-        pChild->DrawAppearance(pDevice, pUser2Device);
-      } else {
-        mt.Concat(*pUser2Device);
-        pChild->DrawAppearance(pDevice, &mt);
-      }
+  for (CPWL_Wnd* pChild : m_Children) {
+    if (!pChild)
+      continue;
+
+    CFX_Matrix mt = pChild->GetChildMatrix();
+    if (mt.IsIdentity()) {
+      pChild->DrawAppearance(pDevice, pUser2Device);
+    } else {
+      mt.Concat(*pUser2Device);
+      pChild->DrawAppearance(pDevice, &mt);
     }
   }
 }
 
 void CPWL_Wnd::InvalidateRect(CFX_FloatRect* pRect) {
   if (IsValid()) {
     CFX_FloatRect rcRefresh = pRect ? *pRect : GetWindowRect();
 
     if (!HasFlag(PWS_NOREFRESHCLIP)) {
       CFX_FloatRect rcClip = GetClipRect();
       if (!rcClip.IsEmpty()) {
         rcRefresh.Intersect(rcClip);
       }
     }
 
     FX_RECT rcWin = PWLtoWnd(rcRefresh);
     rcWin.left -= PWL_INVALIDATE_INFLATE;
     rcWin.top -= PWL_INVALIDATE_INFLATE;
     rcWin.right += PWL_INVALIDATE_INFLATE;
     rcWin.bottom += PWL_INVALIDATE_INFLATE;
 
     if (CFX_SystemHandler* pSH = GetSystemHandler()) {
       if (CPDFSDK_Widget* widget = m_sPrivateParam.pAttachedWidget)
         pSH->InvalidateRect(widget, rcWin);
     }
   }
 }
 
-#define PWL_IMPLEMENT_KEY_METHOD(key_method_name)                      \
-  bool CPWL_Wnd::key_method_name(uint16_t nChar, uint32_t nFlag) {     \
-    if (IsValid() && IsVisible() && IsEnabled()) {                     \
-      if (IsWndCaptureKeyboard(this)) {                                \
-        for (int32_t i = 0, sz = m_aChildren.GetSize(); i < sz; i++) { \
-          if (CPWL_Wnd* pChild = m_aChildren.GetAt(i)) {               \
-            if (IsWndCaptureKeyboard(pChild)) {                        \
-              return pChild->key_method_name(nChar, nFlag);            \
-            }                                                          \
-          }                                                            \
-        }                                                              \
-      }                                                                \
-    }                                                                  \
-    return false;                                                      \
-  }
-
-#define PWL_IMPLEMENT_MOUSE_METHOD(mouse_method_name)                        \
-  bool CPWL_Wnd::mouse_method_name(const CFX_FloatPoint& point,              \
-                                   uint32_t nFlag) {                         \
-    if (IsValid() && IsVisible() && IsEnabled()) {                           \
-      if (IsWndCaptureMouse(this)) {                                         \
-        for (int32_t i = 0, sz = m_aChildren.GetSize(); i < sz; i++) {       \
-          if (CPWL_Wnd* pChild = m_aChildren.GetAt(i)) {                     \
-            if (IsWndCaptureMouse(pChild)) {                                 \
-              return pChild->mouse_method_name(pChild->ParentToChild(point), \
-                                               nFlag);                       \
-            }                                                                \
-          }                                                                  \
-        }                                                                    \
-        SetCursor();                                                         \
-      } else {                                                               \
-        for (int32_t i = 0, sz = m_aChildren.GetSize(); i < sz; i++) {       \
-          if (CPWL_Wnd* pChild = m_aChildren.GetAt(i)) {                     \
-            if (pChild->WndHitTest(pChild->ParentToChild(point))) {          \
-              return pChild->mouse_method_name(pChild->ParentToChild(point), \
-                                               nFlag);                       \
-            }                                                                \
-          }                                                                  \
-        }                                                                    \
-        if (WndHitTest(point))                                               \
-          SetCursor();                                                       \
-      }                                                                      \
-    }                                                                        \
-    return false;                                                            \
+#define PWL_IMPLEMENT_KEY_METHOD(key_method_name)                  \
+  bool CPWL_Wnd::key_method_name(uint16_t nChar, uint32_t nFlag) { \
+    if (!IsValid() || !IsVisible() || !IsEnabled())                \
+      return false;                                                \
+    if (!IsWndCaptureKeyboard(this))                               \
+      return false;                                                \
+    for (const auto& pChild : m_Children) {                        \
+      if (pChild && IsWndCaptureKeyboard(pChild))                  \
+        return pChild->key_method_name(nChar, nFlag);              \
+    }                                                              \
+    return false;                                                  \
   }
 
 PWL_IMPLEMENT_KEY_METHOD(OnKeyDown)
 PWL_IMPLEMENT_KEY_METHOD(OnKeyUp)
 PWL_IMPLEMENT_KEY_METHOD(OnChar)
+#undef PWL_IMPLEMENT_KEY_METHOD
+
+#define PWL_IMPLEMENT_MOUSE_METHOD(mouse_method_name)                          \
+  bool CPWL_Wnd::mouse_method_name(const CFX_FloatPoint& point,                \
+                                   uint32_t nFlag) {                           \
+    if (!IsValid() || !IsVisible() || !IsEnabled())                            \
+      return false;                                                            \
+    if (IsWndCaptureMouse(this)) {                                             \
+      for (const auto& pChild : m_Children) {                                  \
+        if (pChild && IsWndCaptureMouse(pChild)) {                             \
+          return pChild->mouse_method_name(pChild->ParentToChild(point),       \
+                                           nFlag);                             \
+        }                                                                      \
+      }                                                                        \
+      SetCursor();                                                             \
+      return false;                                                            \
+    }                                                                          \
+    for (const auto& pChild : m_Children) {                                    \
+      if (pChild && pChild->WndHitTest(pChild->ParentToChild(point))) {        \
+        return pChild->mouse_method_name(pChild->ParentToChild(point), nFlag); \
+      }                                                                        \
+    }                                                                          \
+    if (WndHitTest(point))                                                     \
+      SetCursor();                                                             \
+    return false;                                                              \
+  }
 
 PWL_IMPLEMENT_MOUSE_METHOD(OnLButtonDblClk)
 PWL_IMPLEMENT_MOUSE_METHOD(OnLButtonDown)
 PWL_IMPLEMENT_MOUSE_METHOD(OnLButtonUp)
 PWL_IMPLEMENT_MOUSE_METHOD(OnMButtonDblClk)
 PWL_IMPLEMENT_MOUSE_METHOD(OnMButtonDown)
 PWL_IMPLEMENT_MOUSE_METHOD(OnMButtonUp)
 PWL_IMPLEMENT_MOUSE_METHOD(OnRButtonDown)
 PWL_IMPLEMENT_MOUSE_METHOD(OnRButtonUp)
 PWL_IMPLEMENT_MOUSE_METHOD(OnMouseMove)
+#undef PWL_IMPLEMENT_MOUSE_METHOD
 
 bool CPWL_Wnd::OnMouseWheel(short zDelta,
                             const CFX_FloatPoint& point,
                             uint32_t nFlag) {
-  if (IsValid() && IsVisible() && IsEnabled()) {
-    SetCursor();
-    if (IsWndCaptureKeyboard(this)) {
-      for (int32_t i = 0, sz = m_aChildren.GetSize(); i < sz; i++) {
-        if (CPWL_Wnd* pChild = m_aChildren.GetAt(i)) {
-          if (IsWndCaptureKeyboard(pChild)) {
-            return pChild->OnMouseWheel(zDelta, pChild->ParentToChild(point),
-                                        nFlag);
-          }
-        }
-      }
-    }
+  if (!IsValid() || !IsVisible() || !IsEnabled())
+    return false;
+
+  SetCursor();
+  if (!IsWndCaptureKeyboard(this))
+    return false;
+
+  for (const auto& pChild : m_Children) {
+    if (pChild && IsWndCaptureKeyboard(pChild))
+      return pChild->OnMouseWheel(zDelta, pChild->ParentToChild(point), nFlag);
   }
   return false;
 }
 
 void CPWL_Wnd::AddChild(CPWL_Wnd* pWnd) {
-  m_aChildren.Add(pWnd);
+  m_Children.push_back(pWnd);
 }
 
 void CPWL_Wnd::RemoveChild(CPWL_Wnd* pWnd) {
-  for (int32_t i = m_aChildren.GetSize() - 1; i >= 0; i--) {
-    if (CPWL_Wnd* pChild = m_aChildren.GetAt(i)) {
-      if (pChild == pWnd) {
-        m_aChildren.RemoveAt(i);
-        break;
-      }
+  for (auto it = m_Children.rbegin(); it != m_Children.rend(); ++it) {
+    if (*it && *it == pWnd) {
+      m_Children.erase(std::next(it).base());

[dsinclair, 2017/01/02 17:58:17]

Why do we need std::next here? Don't we want to remove it?

+      break;
     }
   }
 }
 
 void CPWL_Wnd::OnNotify(CPWL_Wnd* pWnd,
                         uint32_t msg,
                         intptr_t wParam,
                         intptr_t lParam) {
   switch (msg) {
     case PNM_ADDCHILD:
@@ skipping 139 matching lines @@
     m_pVScrollBar->Create(scp);
   }
 }
 
 void CPWL_Wnd::SetCapture() {
   if (CPWL_MsgControl* pMsgCtrl = GetMsgControl())
     pMsgCtrl->SetCapture(this);
 }
 
 void CPWL_Wnd::ReleaseCapture() {
-  for (int32_t i = 0, sz = m_aChildren.GetSize(); i < sz; i++)
-    if (CPWL_Wnd* pChild = m_aChildren.GetAt(i))
+  for (const auto& pChild : m_Children) {
+    if (pChild)
       pChild->ReleaseCapture();
-
+  }
   if (CPWL_MsgControl* pMsgCtrl = GetMsgControl())
     pMsgCtrl->ReleaseCapture();
 }
 
 void CPWL_Wnd::SetFocus() {
   if (CPWL_MsgControl* pMsgCtrl = GetMsgControl()) {
     if (!pMsgCtrl->IsMainCaptureKeyboard(this))
       pMsgCtrl->KillFocus();
     pMsgCtrl->SetFocus(this);
   }
@@ skipping 19 matching lines @@
 }
 
 const CPWL_Wnd* CPWL_Wnd::GetRootWnd() const {
   if (m_sPrivateParam.pParentWnd)
     return m_sPrivateParam.pParentWnd->GetRootWnd();
 
   return this;
 }
 
 void CPWL_Wnd::SetVisible(bool bVisible) {
-  if (IsValid()) {
-    for (int32_t i = 0, sz = m_aChildren.GetSize(); i < sz; i++) {
-      if (CPWL_Wnd* pChild = m_aChildren.GetAt(i)) {
-        pChild->SetVisible(bVisible);
-      }
-    }
+  if (!IsValid())
+    return;
 
-    if (bVisible != m_bVisible) {
-      m_bVisible = bVisible;
-      RePosChildWnd();
-      InvalidateRect();
-    }
+  for (const auto& pChild : m_Children) {
+    if (pChild)
+      pChild->SetVisible(bVisible);
+  }
+  if (bVisible != m_bVisible) {
+    m_bVisible = bVisible;
+    RePosChildWnd();
+    InvalidateRect();
   }
 }
 
 void CPWL_Wnd::SetClipRect(const CFX_FloatRect& rect) {
   m_rcClip = rect;
   m_rcClip.Normalize();
 }
 
 const CFX_FloatRect& CPWL_Wnd::GetClipRect() const {
   return m_rcClip;
@@ skipping 116 matching lines @@
     default:
       return CPWL_Color();
   }
 }
 
 int32_t CPWL_Wnd::GetTransparency() {
   return m_sPrivateParam.nTransparency;
 }
 
 void CPWL_Wnd::SetTransparency(int32_t nTransparency) {
-  for (int32_t i = 0, sz = m_aChildren.GetSize(); i < sz; i++) {
-    if (CPWL_Wnd* pChild = m_aChildren.GetAt(i)) {
+  for (const auto& pChild : m_Children) {
+    if (pChild)
       pChild->SetTransparency(nTransparency);
-    }
   }
-
   m_sPrivateParam.nTransparency = nTransparency;
 }
 
 CFX_Matrix CPWL_Wnd::GetWindowMatrix() const {
   CFX_Matrix mt = GetChildToRoot();
-
-  if (IPWL_Provider* pProvider = GetProvider()) {
+  if (IPWL_Provider* pProvider = GetProvider())
     mt.Concat(pProvider->GetWindowMatrix(GetAttachedData()));
-    return mt;
-  }
 
   return mt;
 }
 
 void CPWL_Wnd::PWLtoWnd(const CFX_FloatPoint& point,
                         int32_t& x,
                         int32_t& y) const {
   CFX_Matrix mt = GetWindowMatrix();
   CFX_FloatPoint pt = point;
   mt.Transform(pt.x, pt.y);
@@ skipping 80 matching lines @@
     return m_sPrivateParam.mtChild;
 
   return CFX_Matrix(1, 0, 0, 1, 0, 0);
 }
 
 void CPWL_Wnd::SetChildMatrix(const CFX_Matrix& mt) {
   m_sPrivateParam.mtChild = mt;
 }
 
 const CPWL_Wnd* CPWL_Wnd::GetFocused() const {
-  if (CPWL_MsgControl* pMsgCtrl = GetMsgControl()) {
-    return pMsgCtrl->m_pMainKeyboardWnd;
-  }
-
-  return nullptr;
+  CPWL_MsgControl* pMsgCtrl = GetMsgControl();
+  return pMsgCtrl ? pMsgCtrl->m_pMainKeyboardWnd : nullptr;
 }
 
 void CPWL_Wnd::EnableWindow(bool bEnable) {
-  if (m_bEnabled != bEnable) {
-    for (int32_t i = 0, sz = m_aChildren.GetSize(); i < sz; i++) {
-      if (CPWL_Wnd* pChild = m_aChildren.GetAt(i)) {
-        pChild->EnableWindow(bEnable);
-      }
-    }
+  if (m_bEnabled == bEnable)
+    return;
 
-    m_bEnabled = bEnable;
-
-    if (bEnable)
-      OnEnabled();
-    else
-      OnDisabled();
+  for (const auto& pChild : m_Children) {
+    if (pChild)
+      pChild->EnableWindow(bEnable);
   }
+  m_bEnabled = bEnable;
+  if (bEnable)
+    OnEnabled();
+  else
+    OnDisabled();
 }
 
 bool CPWL_Wnd::IsEnabled() {
   return m_bEnabled;
 }
 
 void CPWL_Wnd::OnEnabled() {}
 
 void CPWL_Wnd::OnDisabled() {}
 
@@ skipping 13 matching lines @@
   return false;
 }
 
 bool CPWL_Wnd::IsALTpressed(uint32_t nFlag) const {
   if (CFX_SystemHandler* pSystemHandler = GetSystemHandler()) {
     return pSystemHandler->IsALTKeyDown(nFlag);
   }
 
   return false;
 }