Add ownership to CFX_XMLNode children

This CL sets the CFX_XML tree ownership. The pointers set into the tree
must be unique_ptrs and the CFX_XMLNode children are set to be either
unique_ptrs or UnownedPtrs.

Change-Id: Ib0db495c81471e40f5b4533503f7bbe5a784fd77
Reviewed-on: https://pdfium-review.googlesource.com/30711
Reviewed-by: Henrique Nakashima <hnakashima@chromium.org>
Commit-Queue: dsinclair <dsinclair@chromium.org>

1 files changed, 43 insertions, 34 deletions

diff --git a/core/fxcrt/xml/cfx_xmlnode.cpp b/core/fxcrt/xml/cfx_xmlnode.cpp
index 6303615d01..a8be133171 100644
--- a/core/fxcrt/xml/cfx_xmlnode.cpp
+++ b/core/fxcrt/xml/cfx_xmlnode.cpp
@@ -6,6 +6,7 @@
 
 #include "core/fxcrt/xml/cfx_xmlnode.h"
 
+#include <utility>
 #include <vector>
 
 #include "core/fxcrt/xml/cfx_xmlchardata.h"
@@ -25,81 +26,89 @@ FX_XMLNODETYPE CFX_XMLNode::GetType() const {
 }
 
 void CFX_XMLNode::DeleteChildren() {
-  CFX_XMLNode* pChild = first_child_;
-  first_child_ = nullptr;
+  CFX_XMLNode* child = last_child_.Get();
+  // Clear last child early as it will have been deleted already.
   last_child_ = nullptr;
-
-  while (pChild) {
-    CFX_XMLNode* pNext = pChild->next_sibling_;
-    delete pChild;
-    pChild = pNext;
+  while (child) {
+    child = child->prev_sibling_.Get();
+    if (child)
+      child->next_sibling_ = nullptr;
   }
+  first_child_ = nullptr;
 }
 
-void CFX_XMLNode::AppendChild(CFX_XMLNode* pNode) {
-  InsertChildNode(pNode, -1);
+void CFX_XMLNode::AppendChild(std::unique_ptr<CFX_XMLNode> pNode) {
+  InsertChildNode(std::move(pNode), -1);
 }
 
-void CFX_XMLNode::InsertChildNode(CFX_XMLNode* pNode, int32_t index) {
+void CFX_XMLNode::InsertChildNode(std::unique_ptr<CFX_XMLNode> pNode,
+                                  int32_t index) {
   ASSERT(!pNode->parent_);
 
   pNode->parent_ = this;
+  // No existing children, add node as first child.
   if (!first_child_) {
     ASSERT(!last_child_);
 
-    first_child_ = pNode;
-    last_child_ = pNode;
-    pNode->prev_sibling_ = nullptr;
-    pNode->next_sibling_ = nullptr;
+    first_child_ = std::move(pNode);
+    last_child_ = first_child_.get();
+    first_child_->prev_sibling_ = nullptr;
+    first_child_->next_sibling_ = nullptr;
     return;
   }
 
   if (index == 0) {
-    pNode->next_sibling_ = first_child_;
+    first_child_->prev_sibling_ = pNode.get();
+    pNode->next_sibling_ = std::move(first_child_);
     pNode->prev_sibling_ = nullptr;
-    first_child_->prev_sibling_ = pNode;
-    first_child_ = pNode;
+    first_child_ = std::move(pNode);
     return;
   }
 
   int32_t iCount = 0;
-  CFX_XMLNode* pFind = first_child_;
+  CFX_XMLNode* pFind = first_child_.get();
+  // Note, negative indexes, and indexes after the end of the list will result
+  // in appending to the list.
   while (++iCount != index && pFind->next_sibling_)
-    pFind = pFind->next_sibling_;
+    pFind = pFind->next_sibling_.get();
 
   pNode->prev_sibling_ = pFind;
-  pNode->next_sibling_ = pFind->next_sibling_;
   if (pFind->next_sibling_)
-    pFind->next_sibling_->prev_sibling_ = pNode;
+    pFind->next_sibling_->prev_sibling_ = pNode.get();
+  pNode->next_sibling_ = std::move(pFind->next_sibling_);
 
-  pFind->next_sibling_ = pNode;
-  if (pFind == last_child_)
-    last_child_ = pNode;
+  pFind->next_sibling_ = std::move(pNode);
+  if (pFind == last_child_.Get())
+    last_child_ = pFind->next_sibling_.get();
 }
 
 void CFX_XMLNode::RemoveChildNode(CFX_XMLNode* pNode) {
-  ASSERT(first_child_ && pNode);
-
-  if (first_child_ == pNode)
-    first_child_ = pNode->next_sibling_;
-  else
-    pNode->prev_sibling_->next_sibling_ = pNode->next_sibling_;
+  ASSERT(first_child_);
+  ASSERT(pNode);
+
+  if (first_child_.get() == pNode) {
+    first_child_.release();
+    first_child_ = std::move(pNode->next_sibling_);
+  } else {
+    CFX_XMLNode* prev = pNode->prev_sibling_.Get();
+    prev->next_sibling_.release();  // Release pNode
+    prev->next_sibling_ = std::move(pNode->next_sibling_);
+  }
 
-  if (last_child_ == pNode)
-    last_child_ = pNode->prev_sibling_;
+  if (last_child_.Get() == pNode)
+    last_child_ = pNode->prev_sibling_.Get();
 
   if (pNode->next_sibling_)
     pNode->next_sibling_->prev_sibling_ = pNode->prev_sibling_;
 
   pNode->parent_ = nullptr;
-  pNode->next_sibling_ = nullptr;
   pNode->prev_sibling_ = nullptr;
 }
 
 CFX_XMLNode* CFX_XMLNode::GetRoot() {
   CFX_XMLNode* pParent = this;
   while (pParent->parent_)
-    pParent = pParent->parent_;
+    pParent = pParent->parent_.Get();
 
   return pParent;
 }