Made CFieldTree::Node a class.

core/fpdfdoc/cpdf_interform.cpp

 // Copyright 2016 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 <vector>
 
 #include "core/fpdfapi/fpdf_font/include/cpdf_font.h"
 #include "core/fpdfapi/fpdf_font/include/cpdf_fontencoding.h"
@@ skipping 519 matching lines @@
     strcpy(lf.lfFaceName, pcsFontName);
   }
   return RetrieveSpecificFont(lf);
 }
 #endif  // _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
 
 }  // namespace
 
 class CFieldTree {
  public:
-  struct Node {
-    Node* parent;
-    CFX_ArrayTemplate<Node*> children;
-    CFX_WideString short_name;
-    CPDF_FormField* field_ptr;
-    int CountFields(int nLevel = 0) {
-      if (nLevel > nMaxRecursion)
-        return 0;
-      if (field_ptr)
-        return 1;
+  class Node {
+   public:
+    Node() : m_pField(nullptr) {}
+    Node(const CFX_WideString& short_name, CPDF_FormField* pField)
+        : m_ShortName(short_name), m_pField(pField) {}
+    ~Node() {}
 
-      int count = 0;
-      for (int i = 0; i < children.GetSize(); i++)
-        count += children.GetAt(i)->CountFields(nLevel + 1);
-      return count;
+    void AddChildNode(Node* pNode) { m_Children.push_back(pNode); }
+
+    size_t GetChildrenCount() const { return m_Children.size(); }
+
+    Node* GetChildAt(size_t i) { return m_Children[i]; }
+    const Node* GetChildAt(size_t i) const { return m_Children[i]; }
+
+    CPDF_FormField* GetFieldAtIndex(int index) {
+      int nFieldsToGo = index;
+      return GetFieldInternal(&nFieldsToGo);
     }
 
-    CPDF_FormField* GetField(int* fields_to_go) {
-      if (field_ptr) {
-        if (*fields_to_go == 0)
-          return field_ptr;
+    int CountFields() const { return CountFieldsInternal(0); }
 
-        --*fields_to_go;
+    void SetField(CPDF_FormField* pField) { m_pField = pField; }
+
+    CPDF_FormField* GetField() { return m_pField; }
+    const CPDF_FormField* GetField() const { return m_pField; }
+
+    const CFX_WideString& GetShortName() const { return m_ShortName; }
+
+   private:
+    CPDF_FormField* GetFieldInternal(int* pFieldsToGo) {
+      if (m_pField) {
+        if (*pFieldsToGo == 0)
+          return m_pField;
+
+        --*pFieldsToGo;
         return nullptr;
       }
-      for (int i = 0; i < children.GetSize(); i++) {
-        if (CPDF_FormField* pField = children.GetAt(i)->GetField(fields_to_go))
+      for (size_t i = 0; i < GetChildrenCount(); ++i) {
+        CPDF_FormField* pField = GetChildAt(i)->GetFieldInternal(pFieldsToGo);
+        if (pField)
           return pField;
       }
       return nullptr;
     }
 
-    CPDF_FormField* GetField(int index) {
-      int fields_to_go = index;
-      return GetField(&fields_to_go);
+    int CountFieldsInternal(int nLevel) const {
+      if (nLevel > nMaxRecursion)
+        return 0;
+      if (m_pField)
+        return 1;
+
+      int count = 0;
+      for (size_t i = 0; i < GetChildrenCount(); ++i)
+        count += GetChildAt(i)->CountFieldsInternal(nLevel + 1);
+      return count;
     }
+
+    std::vector<Node*> m_Children;
+    CFX_WideString m_ShortName;
+    CPDF_FormField* m_pField;
   };
 
   CFieldTree();
   ~CFieldTree();
 
-  void SetField(const CFX_WideString& full_name, CPDF_FormField* field_ptr);
+  void SetField(const CFX_WideString& full_name, CPDF_FormField* pField);
   CPDF_FormField* GetField(const CFX_WideString& full_name);
-  CPDF_FormField* RemoveField(const CFX_WideString& full_name);
   void RemoveAll();
 
   Node* FindNode(const CFX_WideString& full_name);
   Node* AddChild(Node* pParent,
                  const CFX_WideString& short_name,
-                 CPDF_FormField* field_ptr);
+                 CPDF_FormField* pField);
   void RemoveNode(Node* pNode, int nLevel = 0);
 
   Node* Lookup(Node* pParent, const CFX_WideString& short_name);
 
   Node m_Root;
 };
 
-CFieldTree::CFieldTree() {
-  m_Root.parent = nullptr;
-  m_Root.field_ptr = nullptr;
-}
+CFieldTree::CFieldTree() {}
 
 CFieldTree::~CFieldTree() {
   RemoveAll();
 }
 
 CFieldTree::Node* CFieldTree::AddChild(Node* pParent,
                                        const CFX_WideString& short_name,
-                                       CPDF_FormField* field_ptr) {
+                                       CPDF_FormField* pField) {
   if (!pParent)
     return nullptr;
 
-  Node* pNode = new Node;
-  pNode->parent = pParent;
-  pNode->short_name = short_name;
-  pNode->field_ptr = field_ptr;
-  pParent->children.Add(pNode);
+  Node* pNode = new Node(short_name, pField);
+  pParent->AddChildNode(pNode);
   return pNode;
 }
 
 void CFieldTree::RemoveNode(Node* pNode, int nLevel) {
   if (!pNode)
     return;
+
   if (nLevel <= nMaxRecursion) {
-    for (int i = 0; i < pNode->children.GetSize(); i++)
-      RemoveNode(pNode->children[i], nLevel + 1);
+    for (size_t i = 0; i < pNode->GetChildrenCount(); ++i)
+      RemoveNode(pNode->GetChildAt(i), nLevel + 1);
   }
   delete pNode;
 }
 
 CFieldTree::Node* CFieldTree::Lookup(Node* pParent,
                                      const CFX_WideString& short_name) {
   if (!pParent)
     return nullptr;
 
-  for (int i = 0; i < pParent->children.GetSize(); i++) {
-    Node* pNode = pParent->children[i];
-    if (pNode->short_name == short_name)
+  for (size_t i = 0; i < pParent->GetChildrenCount(); ++i) {
+    Node* pNode = pParent->GetChildAt(i);
+    if (pNode->GetShortName() == short_name)
       return pNode;
   }
   return nullptr;
 }
 
 void CFieldTree::RemoveAll() {
-  for (int i = 0; i < m_Root.children.GetSize(); i++)
-    RemoveNode(m_Root.children[i]);
+  for (size_t i = 0; i < m_Root.GetChildrenCount(); ++i)
+    RemoveNode(m_Root.GetChildAt(i));
 }
 
 void CFieldTree::SetField(const CFX_WideString& full_name,
-                          CPDF_FormField* field_ptr) {
-  if (full_name == L"")
+                          CPDF_FormField* pField) {
+  if (full_name.IsEmpty())
     return;
 
   CFieldNameExtractor name_extractor(full_name);
   const FX_WCHAR* pName;
   FX_STRSIZE nLength;
   name_extractor.GetNext(pName, nLength);
   Node* pNode = &m_Root;
   Node* pLast = nullptr;
   while (nLength > 0) {
     pLast = pNode;
     CFX_WideString name = CFX_WideString(pName, nLength);
     pNode = Lookup(pLast, name);
     if (!pNode)
       pNode = AddChild(pLast, name, nullptr);
 
     name_extractor.GetNext(pName, nLength);
   }
   if (pNode != &m_Root)
-    pNode->field_ptr = field_ptr;
+    pNode->SetField(pField);
 }
 
 CPDF_FormField* CFieldTree::GetField(const CFX_WideString& full_name) {
-  if (full_name == L"")
+  if (full_name.IsEmpty())
     return nullptr;
 
   CFieldNameExtractor name_extractor(full_name);
-  const FX_WCHAR* pName;
-  FX_STRSIZE nLength;
-  name_extractor.GetNext(pName, nLength);
-  Node* pNode = &m_Root;
-  Node* pLast = nullptr;
-  while (nLength > 0 && pNode) {
-    pLast = pNode;
-    CFX_WideString name = CFX_WideString(pName, nLength);
-    pNode = Lookup(pLast, name);
-    name_extractor.GetNext(pName, nLength);
-  }
-  return pNode ? pNode->field_ptr : nullptr;
-}
-
-CPDF_FormField* CFieldTree::RemoveField(const CFX_WideString& full_name) {
-  if (full_name == L"")
-    return nullptr;
-
-  CFieldNameExtractor name_extractor(full_name);
   const FX_WCHAR* pName;
   FX_STRSIZE nLength;
   name_extractor.GetNext(pName, nLength);
   Node* pNode = &m_Root;
   Node* pLast = nullptr;
   while (nLength > 0 && pNode) {
     pLast = pNode;
     CFX_WideString name = CFX_WideString(pName, nLength);
     pNode = Lookup(pLast, name);
     name_extractor.GetNext(pName, nLength);
   }
-
-  if (pNode && pNode != &m_Root) {
-    for (int i = 0; i < pLast->children.GetSize(); i++) {
-      if (pNode == pLast->children[i]) {
-        pLast->children.RemoveAt(i);
-        break;
-      }
-    }
-    CPDF_FormField* pField = pNode->field_ptr;
-    RemoveNode(pNode);
-    return pField;
-  }
-  return nullptr;
+  return pNode ? pNode->GetField() : nullptr;
 }
 
 CFieldTree::Node* CFieldTree::FindNode(const CFX_WideString& full_name) {
-  if (full_name == L"")
+  if (full_name.IsEmpty())
     return nullptr;
 
   CFieldNameExtractor name_extractor(full_name);
   const FX_WCHAR* pName;
   FX_STRSIZE nLength;
   name_extractor.GetNext(pName, nLength);
   Node* pNode = &m_Root;
   Node* pLast = nullptr;
   while (nLength > 0 && pNode) {
     pLast = pNode;
@@ skipping 92 matching lines @@
   for (size_t i = 0; i < pFields->GetCount(); i++)
     LoadField(pFields->GetDictAt(i));
 }
 
 CPDF_InterForm::~CPDF_InterForm() {
   for (auto it : m_ControlMap)
     delete it.second;
 
   int nCount = m_pFieldTree->m_Root.CountFields();
   for (int i = 0; i < nCount; ++i)
-    delete m_pFieldTree->m_Root.GetField(i);
+    delete m_pFieldTree->m_Root.GetFieldAtIndex(i);
 }
 
 FX_BOOL CPDF_InterForm::s_bUpdateAP = TRUE;
 
 FX_BOOL CPDF_InterForm::IsUpdateAPEnabled() {
   return s_bUpdateAP;
 }
 
 void CPDF_InterForm::SetUpdateAP(FX_BOOL bUpdateAP) {
   s_bUpdateAP = bUpdateAP;
@@ skipping 157 matching lines @@
     while (iPos < iLength && csNewFieldName[iPos] != L'.')
       csSub += csNewFieldName[iPos++];
     for (int i = csSub.GetLength() - 1; i > -1; i--) {
       if (csSub[i] == L' ' || csSub[i] == L'.')
         csSub.SetAt(i, L'\0');
       else
         break;
     }
     uint32_t dwCount = m_pFieldTree->m_Root.CountFields();
     for (uint32_t m = 0; m < dwCount; m++) {
-      CPDF_FormField* pField = m_pFieldTree->m_Root.GetField(m);
+      CPDF_FormField* pField = m_pFieldTree->m_Root.GetFieldAtIndex(m);
       if (!pField)
         continue;
       if (pField == pExcludedField) {
         if (pExcludedControl) {
           if (pField->CountControls() < 2)
             continue;
         } else {
           continue;
         }
       }
@@ skipping 79 matching lines @@
 uint32_t CPDF_InterForm::CountFields(const CFX_WideString& csFieldName) {
   if (csFieldName.IsEmpty())
     return (uint32_t)m_pFieldTree->m_Root.CountFields();
 
   CFieldTree::Node* pNode = m_pFieldTree->FindNode(csFieldName);
   return pNode ? pNode->CountFields() : 0;
 }
 
 CPDF_FormField* CPDF_InterForm::GetField(uint32_t index,
                                          const CFX_WideString& csFieldName) {
-  if (csFieldName == L"")
-    return m_pFieldTree->m_Root.GetField(index);
+  if (csFieldName.IsEmpty())
+    return m_pFieldTree->m_Root.GetFieldAtIndex(index);
 
   CFieldTree::Node* pNode = m_pFieldTree->FindNode(csFieldName);
-  return pNode ? pNode->GetField(index) : nullptr;
+  return pNode ? pNode->GetFieldAtIndex(index) : nullptr;
 }
 
 CPDF_FormField* CPDF_InterForm::GetFieldByDict(
     CPDF_Dictionary* pFieldDict) const {
   if (!pFieldDict)
     return nullptr;
 
   CFX_WideString csWName = FPDF_GetFullName(pFieldDict);
   return m_pFieldTree->GetField(csWName);
 }
@@ skipping 149 matching lines @@
 }
 
 bool CPDF_InterForm::ResetForm(const std::vector<CPDF_FormField*>& fields,
                                bool bIncludeOrExclude,
                                bool bNotify) {
   if (bNotify && m_pFormNotify && m_pFormNotify->BeforeFormReset(this) < 0)
     return false;
 
   int nCount = m_pFieldTree->m_Root.CountFields();
   for (int i = 0; i < nCount; ++i) {
-    CPDF_FormField* pField = m_pFieldTree->m_Root.GetField(i);
+    CPDF_FormField* pField = m_pFieldTree->m_Root.GetFieldAtIndex(i);
     if (!pField)
       continue;
 
     if (bIncludeOrExclude == pdfium::ContainsValue(fields, pField))
       pField->ResetField(bNotify);
   }
   if (bNotify && m_pFormNotify)
     m_pFormNotify->AfterFormReset(this);
   return true;
 }
 
 bool CPDF_InterForm::ResetForm(bool bNotify) {
   if (bNotify && m_pFormNotify && m_pFormNotify->BeforeFormReset(this) < 0)
     return false;
 
   int nCount = m_pFieldTree->m_Root.CountFields();
   for (int i = 0; i < nCount; ++i) {
-    CPDF_FormField* pField = m_pFieldTree->m_Root.GetField(i);
+    CPDF_FormField* pField = m_pFieldTree->m_Root.GetFieldAtIndex(i);
     if (!pField)
       continue;
 
     pField->ResetField(bNotify);
   }
   if (bNotify && m_pFormNotify)
     m_pFormNotify->AfterFormReset(this);
   return true;
 }
 
@@ skipping 87 matching lines @@
       CPDF_Object* pClone = pTObj->CloneDirectObject();
       if (pClone)
         pDict->SetFor("T", pClone);
       else
         pDict->SetNameFor("T", "");
     }
     m_pFieldTree->SetField(csWName, pField);
   }
 
   CPDF_Array* pKids = pFieldDict->GetArrayFor("Kids");
-  if (!pKids) {
-    if (pFieldDict->GetStringFor("Subtype") == "Widget")
-      AddControl(pField, pFieldDict);
-  } else {
+  if (pKids) {
     for (size_t i = 0; i < pKids->GetCount(); i++) {
       CPDF_Dictionary* pKid = pKids->GetDictAt(i);
       if (!pKid)
         continue;
       if (pKid->GetStringFor("Subtype") != "Widget")
         continue;
 
       AddControl(pField, pKid);
     }
+  } else {
+    if (pFieldDict->GetStringFor("Subtype") == "Widget")
+      AddControl(pField, pFieldDict);
   }
   return pField;
 }
 
 CPDF_FormControl* CPDF_InterForm::AddControl(CPDF_FormField* pField,
                                              CPDF_Dictionary* pWidgetDict) {
   const auto it = m_ControlMap.find(pWidgetDict);
   if (it != m_ControlMap.end())
     return it->second;
 
   CPDF_FormControl* pControl = new CPDF_FormControl(pField, pWidgetDict);
   m_ControlMap[pWidgetDict] = pControl;
   pField->m_ControlList.Add(pControl);
   return pControl;
 }
 
 CPDF_FormField* CPDF_InterForm::CheckRequiredFields(
     const std::vector<CPDF_FormField*>* fields,
     bool bIncludeOrExclude) const {
   int nCount = m_pFieldTree->m_Root.CountFields();
   for (int i = 0; i < nCount; ++i) {
-    CPDF_FormField* pField = m_pFieldTree->m_Root.GetField(i);
+    CPDF_FormField* pField = m_pFieldTree->m_Root.GetFieldAtIndex(i);
     if (!pField)
       continue;
 
     int32_t iType = pField->GetType();
     if (iType == CPDF_FormField::PushButton ||
         iType == CPDF_FormField::CheckBox || iType == CPDF_FormField::ListBox) {
       continue;
     }
     uint32_t dwFlags = pField->GetFieldFlags();
     // TODO(thestig): Look up these magic numbers and add constants for them.
@@ skipping 10 matching lines @@
     }
   }
   return nullptr;
 }
 
 CFDF_Document* CPDF_InterForm::ExportToFDF(const CFX_WideStringC& pdf_path,
                                            bool bSimpleFileSpec) const {
   std::vector<CPDF_FormField*> fields;
   int nCount = m_pFieldTree->m_Root.CountFields();
   for (int i = 0; i < nCount; ++i)
-    fields.push_back(m_pFieldTree->m_Root.GetField(i));
+    fields.push_back(m_pFieldTree->m_Root.GetFieldAtIndex(i));
   return ExportToFDF(pdf_path, fields, true, bSimpleFileSpec);
 }
 
 CFDF_Document* CPDF_InterForm::ExportToFDF(
     const CFX_WideStringC& pdf_path,
     const std::vector<CPDF_FormField*>& fields,
     bool bIncludeOrExclude,
     bool bSimpleFileSpec) const {
   CFDF_Document* pDoc = CFDF_Document::CreateNewDoc();
   if (!pDoc)
     return nullptr;
 
   CPDF_Dictionary* pMainDict = pDoc->GetRoot()->GetDictFor("FDF");
   if (!pdf_path.IsEmpty()) {
     if (bSimpleFileSpec) {
       CFX_WideString wsFilePath = CPDF_FileSpec::EncodeFileName(pdf_path);
       pMainDict->SetStringFor("F", CFX_ByteString::FromUnicode(wsFilePath));
       pMainDict->SetStringFor("UF", PDF_EncodeText(wsFilePath));
     } else {
       CPDF_FileSpec filespec;
       filespec.SetFileName(pdf_path);
       pMainDict->SetFor("F", filespec.GetObj());
     }
   }
 
   CPDF_Array* pFields = new CPDF_Array;
   pMainDict->SetFor("Fields", pFields);
   int nCount = m_pFieldTree->m_Root.CountFields();
   for (int i = 0; i < nCount; i++) {
-    CPDF_FormField* pField = m_pFieldTree->m_Root.GetField(i);
+    CPDF_FormField* pField = m_pFieldTree->m_Root.GetFieldAtIndex(i);
     if (!pField || pField->GetType() == CPDF_FormField::PushButton)
       continue;
 
     uint32_t dwFlags = pField->GetFieldFlags();
     if (dwFlags & 0x04)
       continue;
 
     if (bIncludeOrExclude == pdfium::ContainsValue(fields, pField)) {
       if ((dwFlags & 0x02) != 0 && pField->m_pDict->GetStringFor("V").IsEmpty())
         continue;
@@ skipping 104 matching lines @@
     FDF_ImportField(pField, L"", bNotify);
   }
   if (bNotify && m_pFormNotify)
     m_pFormNotify->AfterFormImportData(this);
   return TRUE;
 }
 
 void CPDF_InterForm::SetFormNotify(IPDF_FormNotify* pNotify) {
   m_pFormNotify = pNotify;
 }