Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 867 insertions, 0 deletions

diff --git a/comm/mailnews/base/src/nsSubscribableServer.cpp b/comm/mailnews/base/src/nsSubscribableServer.cpp
new file mode 100644
index 0000000000..043ef2e4d3
--- /dev/null
+++ b/comm/mailnews/base/src/nsSubscribableServer.cpp
@@ -0,0 +1,867 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsSubscribableServer.h"
+#include "nsIMsgIncomingServer.h"
+#include "nsIServiceManager.h"
+#include "nsMsgI18N.h"
+#include "nsMsgUtils.h"
+#include "nsServiceManagerUtils.h"
+#include "nsTreeColumns.h"
+#include "mozilla/dom/DataTransfer.h"
+
+/**
+ * The basic structure for the tree of the implementation.
+ *
+ * These elements are stored in reverse alphabetical order.
+ * Each node owns its children and subsequent siblings.
+ */
+struct SubscribeTreeNode {
+  nsCString name;
+  nsCString path;
+  bool isSubscribed;
+  SubscribeTreeNode* prevSibling;
+  SubscribeTreeNode* nextSibling;
+  SubscribeTreeNode* firstChild;
+  SubscribeTreeNode* lastChild;
+  SubscribeTreeNode* parent;
+  // Stores the child considered most likely to be next searched for - usually
+  // the most recently-added child. If names match the search can early-out.
+  SubscribeTreeNode* cachedChild;
+  bool isSubscribable;
+  bool isOpen;
+};
+
+nsSubscribableServer::nsSubscribableServer(void) {
+  mDelimiter = '.';
+  mShowFullName = true;
+  mTreeRoot = nullptr;
+  mStopped = false;
+}
+
+nsresult nsSubscribableServer::Init() { return NS_OK; }
+
+nsSubscribableServer::~nsSubscribableServer(void) {
+  FreeRows();
+  if (mTreeRoot) {
+    FreeSubtree(mTreeRoot);
+  }
+}
+
+NS_IMPL_ISUPPORTS(nsSubscribableServer, nsISubscribableServer, nsITreeView)
+
+NS_IMETHODIMP
+nsSubscribableServer::SetIncomingServer(nsIMsgIncomingServer* aServer) {
+  if (!aServer) {
+    mIncomingServerUri.AssignLiteral("");
+    mServerType.Truncate();
+    return NS_OK;
+  }
+  aServer->GetType(mServerType);
+
+  // We intentionally do not store a pointer to the aServer here
+  // as it would create reference loops, because nsIImapIncomingServer
+  // and nsINntpIncomingServer keep a reference to an internal
+  // nsISubscribableServer object.
+  // We only need the URI of the server anyway.
+  return aServer->GetServerURI(mIncomingServerUri);
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::GetDelimiter(char* aDelimiter) {
+  NS_ENSURE_ARG_POINTER(aDelimiter);
+  *aDelimiter = mDelimiter;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::SetDelimiter(char aDelimiter) {
+  mDelimiter = aDelimiter;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::SetAsSubscribed(const nsACString& path) {
+  nsresult rv = NS_OK;
+
+  SubscribeTreeNode* node = nullptr;
+  rv = FindAndCreateNode(path, &node);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  NS_ASSERTION(node, "didn't find the node");
+  if (!node) return NS_ERROR_FAILURE;
+  node->isSubscribable = true;
+  node->isSubscribed = true;
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::AddTo(const nsACString& aName, bool aAddAsSubscribed,
+                            bool aSubscribable, bool aChangeIfExists) {
+  nsresult rv = NS_OK;
+
+  if (mStopped) {
+    return NS_ERROR_FAILURE;
+  }
+
+  SubscribeTreeNode* node = nullptr;
+
+  // todo, shouldn't we pass in aAddAsSubscribed, for the
+  // default value if we create it?
+  rv = FindAndCreateNode(aName, &node);
+  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ASSERTION(node, "didn't find the node");
+  if (!node) return NS_ERROR_FAILURE;
+
+  if (aChangeIfExists) {
+    node->isSubscribed = aAddAsSubscribed;
+  }
+
+  node->isSubscribable = aSubscribable;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::SetState(const nsACString& aPath, bool aState,
+                               bool* aStateChanged) {
+  nsresult rv = NS_OK;
+  NS_ASSERTION(!aPath.IsEmpty() && aStateChanged, "no path or stateChanged");
+  if (aPath.IsEmpty() || !aStateChanged) return NS_ERROR_NULL_POINTER;
+
+  NS_ASSERTION(mozilla::IsUtf8(aPath), "aPath is not in UTF-8");
+
+  *aStateChanged = false;
+
+  SubscribeTreeNode* node = nullptr;
+  rv = FindAndCreateNode(aPath, &node);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  NS_ASSERTION(node, "didn't find the node");
+  if (!node) return NS_ERROR_FAILURE;
+
+  NS_ASSERTION(node->isSubscribable, "fix this");
+  if (!node->isSubscribable) {
+    return NS_OK;
+  }
+
+  if (node->isSubscribed == aState) {
+    return NS_OK;
+  } else {
+    node->isSubscribed = aState;
+    *aStateChanged = true;
+
+    // Repaint the tree row to show/clear the check mark.
+    if (mTree) {
+      bool dummy;
+      int32_t index = GetRow(node, &dummy);
+      if (index >= 0) mTree->InvalidateRow(index);
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::SetSubscribeListener(nsISubscribeListener* aListener) {
+  mSubscribeListener = aListener;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::GetSubscribeListener(nsISubscribeListener** aListener) {
+  NS_ENSURE_ARG_POINTER(aListener);
+  NS_IF_ADDREF(*aListener = mSubscribeListener);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::SubscribeCleanup() {
+  NS_ASSERTION(false, "override this.");
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::StartPopulatingWithUri(nsIMsgWindow* aMsgWindow,
+                                             bool aForceToServer,
+                                             const nsACString& uri) {
+  mStopped = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::StartPopulating(nsIMsgWindow* aMsgWindow,
+                                      bool aForceToServer,
+                                      bool aGetOnlyNew /*ignored*/) {
+  mStopped = false;
+
+  FreeRows();
+  if (mTreeRoot) {
+    FreeSubtree(mTreeRoot);
+    mTreeRoot = nullptr;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::StopPopulating(nsIMsgWindow* aMsgWindow) {
+  mStopped = true;
+
+  FreeRows();
+
+  if (mTreeRoot) {
+    SubscribeTreeNode* node = mTreeRoot->lastChild;
+    // Add top level items as closed.
+    while (node) {
+      node->isOpen = false;
+      mRowMap.AppendElement(node);
+      node = node->prevSibling;
+    }
+
+    // Invalidate the whole thing.
+    if (mTree) mTree->RowCountChanged(0, mRowMap.Length());
+
+    // Open all the top level items if they are containers.
+    uint32_t topRows = mRowMap.Length();
+    for (int32_t i = topRows - 1; i >= 0; i--) {
+      bool isContainer = false;
+      IsContainer(i, &isContainer);
+      if (isContainer) ToggleOpenState(i);
+    }
+  }
+
+  if (mSubscribeListener) mSubscribeListener->OnDonePopulating();
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::UpdateSubscribed() {
+  NS_ASSERTION(false, "override this.");
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::Subscribe(const char16_t* aName) {
+  NS_ASSERTION(false, "override this.");
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::Unsubscribe(const char16_t* aName) {
+  NS_ASSERTION(false, "override this.");
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::SetShowFullName(bool showFullName) {
+  mShowFullName = showFullName;
+  return NS_OK;
+}
+
+void nsSubscribableServer::FreeSubtree(SubscribeTreeNode* node) {
+  // NOTE: this doesn't cleanly detach each node, but that's not an issue
+  // here. This is a nuking, not a surgical removal.
+
+  // recursively free the children
+  if (node->firstChild) {
+    // will free node->firstChild
+    FreeSubtree(node->firstChild);
+    node->firstChild = nullptr;
+  }
+
+  // recursively free the siblings
+  if (node->nextSibling) {
+    FreeSubtree(node->nextSibling);
+    node->nextSibling = nullptr;
+  }
+
+  delete node;
+}
+
+void nsSubscribableServer::FreeRows() {
+  int32_t rowCount = mRowMap.Length();
+  mRowMap.Clear();
+  if (mTree) mTree->RowCountChanged(0, -rowCount);
+}
+
+SubscribeTreeNode* nsSubscribableServer::CreateNode(SubscribeTreeNode* parent,
+                                                    nsACString const& name,
+                                                    nsACString const& path) {
+  SubscribeTreeNode* node = new SubscribeTreeNode();
+
+  node->name.Assign(name);
+  node->path.Assign(path);
+  node->parent = parent;
+  node->prevSibling = nullptr;
+  node->nextSibling = nullptr;
+  node->firstChild = nullptr;
+  node->lastChild = nullptr;
+  node->isSubscribed = false;
+  node->isSubscribable = false;
+  node->isOpen = true;
+  node->cachedChild = nullptr;
+  if (parent) {
+    parent->cachedChild = node;
+  }
+  return node;
+}
+
+nsresult nsSubscribableServer::AddChildNode(SubscribeTreeNode* parent,
+                                            nsACString const& name,
+                                            const nsACString& path,
+                                            SubscribeTreeNode** child) {
+  nsresult rv = NS_OK;
+  NS_ASSERTION(parent && child && !name.IsEmpty() && !path.IsEmpty(),
+               "parent, child or name is null");
+  if (!parent || !child || name.IsEmpty() || path.IsEmpty())
+    return NS_ERROR_NULL_POINTER;
+
+  // Adding to a node with no children?
+  if (!parent->firstChild) {
+    // CreateNode will set the parent->cachedChild
+    *child = CreateNode(parent, name, path);
+    parent->firstChild = *child;
+    parent->lastChild = *child;
+    return NS_OK;
+  }
+
+  // Did we just add a child of this name?
+  if (parent->cachedChild) {
+    if (parent->cachedChild->name.Equals(name)) {
+      *child = parent->cachedChild;
+      return NS_OK;
+    }
+  }
+
+  SubscribeTreeNode* current = parent->firstChild;
+
+  /*
+   * Insert in reverse alphabetical order.
+   * This will reduce the # of strcmps since this is faster assuming:
+   *  1) the hostinfo.dat feeds us the groups in alphabetical order
+   *     since we control the hostinfo.dat file, we can guarantee this.
+   *  2) the server gives us the groups in alphabetical order
+   *     we can't guarantee this, but it seems to be a common thing.
+   *
+   * Because we have firstChild, lastChild, nextSibling, prevSibling,
+   * we can efficiently reverse the order when dumping to hostinfo.dat
+   * or to GetTargets().
+   */
+  int32_t compare = Compare(current->name, name);
+
+  while (current && (compare != 0)) {
+    if (compare < 0) {
+      // CreateNode will set the parent->cachedChild
+      *child = CreateNode(parent, name, path);
+      NS_ENSURE_SUCCESS(rv, rv);
+
+      (*child)->nextSibling = current;
+      (*child)->prevSibling = current->prevSibling;
+      current->prevSibling = (*child);
+      if (!(*child)->prevSibling) {
+        parent->firstChild = (*child);
+      } else {
+        (*child)->prevSibling->nextSibling = (*child);
+      }
+
+      return NS_OK;
+    }
+    current = current->nextSibling;
+    if (current) {
+      NS_ASSERTION(!current->name.IsEmpty(), "no name!");
+      compare = Compare(current->name, name);
+    } else {
+      compare = -1;  // anything but 0, since that would be a match
+    }
+  }
+
+  if (compare == 0) {
+    // already exists;
+    *child = current;
+    parent->cachedChild = *child;
+    return NS_OK;
+  }
+
+  // CreateNode will set the parent->cachedChild
+  *child = CreateNode(parent, name, path);
+
+  (*child)->prevSibling = parent->lastChild;
+  (*child)->nextSibling = nullptr;
+  parent->lastChild->nextSibling = *child;
+  parent->lastChild = *child;
+
+  return NS_OK;
+}
+
+nsresult nsSubscribableServer::FindAndCreateNode(const nsACString& aPath,
+                                                 SubscribeTreeNode** aResult) {
+  nsresult rv = NS_OK;
+  NS_ASSERTION(aResult, "no result");
+  NS_ENSURE_ARG_POINTER(aResult);
+
+  if (!mTreeRoot) {
+    // the root has no parent, and its name is server uri
+    mTreeRoot = CreateNode(nullptr, mIncomingServerUri, EmptyCString());
+  }
+
+  if (aPath.IsEmpty()) {
+    *aResult = mTreeRoot;
+    return NS_OK;
+  }
+
+  *aResult = nullptr;
+
+  SubscribeTreeNode* parent = mTreeRoot;
+  SubscribeTreeNode* child = nullptr;
+
+  uint32_t tokenStart = 0;
+  // Special case paths that start with the hierarchy delimiter.
+  // We want to include that delimiter in the first token name.
+  // So start from position 1.
+  int32_t tokenEnd = aPath.FindChar(mDelimiter, tokenStart + 1);
+  while (true) {
+    if (tokenEnd == kNotFound) {
+      if (tokenStart >= aPath.Length()) break;
+      tokenEnd = aPath.Length();
+    }
+    nsCString token(Substring(aPath, tokenStart, tokenEnd - tokenStart));
+    rv = AddChildNode(parent, token, Substring(aPath, 0, tokenEnd), &child);
+    if (NS_FAILED(rv)) return rv;
+    tokenStart = tokenEnd + 1;
+    tokenEnd = aPath.FindChar(mDelimiter, tokenStart);
+    parent = child;
+  }
+
+  // the last child we add is the result
+  *aResult = child;
+  return rv;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::HasChildren(const nsACString& aPath, bool* aHasChildren) {
+  NS_ASSERTION(aHasChildren, "no hasChildren");
+  NS_ENSURE_ARG_POINTER(aHasChildren);
+
+  *aHasChildren = false;
+
+  SubscribeTreeNode* node = nullptr;
+  nsresult rv = FindAndCreateNode(aPath, &node);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  NS_ASSERTION(node, "didn't find the node");
+  if (!node) return NS_ERROR_FAILURE;
+
+  *aHasChildren = (node->firstChild != nullptr);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::IsSubscribed(const nsACString& aPath,
+                                   bool* aIsSubscribed) {
+  NS_ENSURE_ARG_POINTER(aIsSubscribed);
+
+  *aIsSubscribed = false;
+
+  SubscribeTreeNode* node = nullptr;
+  nsresult rv = FindAndCreateNode(aPath, &node);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  NS_ASSERTION(node, "didn't find the node");
+  if (!node) return NS_ERROR_FAILURE;
+
+  *aIsSubscribed = node->isSubscribed;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::IsSubscribable(const nsACString& aPath,
+                                     bool* aIsSubscribable) {
+  NS_ENSURE_ARG_POINTER(aIsSubscribable);
+
+  *aIsSubscribable = false;
+
+  SubscribeTreeNode* node = nullptr;
+  nsresult rv = FindAndCreateNode(aPath, &node);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  NS_ASSERTION(node, "didn't find the node");
+  if (!node) return NS_ERROR_FAILURE;
+
+  *aIsSubscribable = node->isSubscribable;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::GetLeafName(const nsACString& aPath,
+                                  nsAString& aLeafName) {
+  SubscribeTreeNode* node = nullptr;
+  nsresult rv = FindAndCreateNode(aPath, &node);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  NS_ASSERTION(node, "didn't find the node");
+  if (!node) return NS_ERROR_FAILURE;
+
+  // XXX TODO FIXME
+  // I'm assuming that mShowFullName is true for NNTP, false for IMAP.
+  // For imap, the node name is in MUTF-7; for news, the path is escaped UTF-8.
+  // When we switch to using the tree, this hack will go away.
+  if (mShowFullName) {
+    return NS_MsgDecodeUnescapeURLPath(aPath, aLeafName);
+  }
+
+  return CopyFolderNameToUTF16(node->name, aLeafName);
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::GetFirstChildURI(const nsACString& aPath,
+                                       nsACString& aResult) {
+  aResult.Truncate();
+
+  SubscribeTreeNode* node = nullptr;
+  nsresult rv = FindAndCreateNode(aPath, &node);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  NS_ASSERTION(node, "didn't find the node");
+  if (!node) return NS_ERROR_FAILURE;
+
+  // no children
+  if (!node->firstChild) return NS_ERROR_FAILURE;
+
+  aResult.Assign(node->firstChild->path);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::GetChildURIs(const nsACString& aPath,
+                                   nsTArray<nsCString>& aResult) {
+  aResult.Clear();
+  SubscribeTreeNode* node = nullptr;
+  nsresult rv = FindAndCreateNode(aPath, &node);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  NS_ASSERTION(node, "didn't find the node");
+  if (!node) return NS_ERROR_FAILURE;
+
+  NS_ASSERTION(mTreeRoot, "no tree root!");
+  if (!mTreeRoot) return NS_ERROR_UNEXPECTED;
+
+  // We inserted them in reverse alphabetical order.
+  // So pull them out in reverse to get the right order
+  // in the subscribe dialog.
+  SubscribeTreeNode* current = node->lastChild;
+  // return failure if there are no children.
+  if (!current) return NS_ERROR_FAILURE;
+
+  while (current) {
+    NS_ASSERTION(!current->name.IsEmpty(), "no name");
+    if (current->name.IsEmpty()) {
+      return NS_ERROR_FAILURE;
+    }
+    aResult.AppendElement(current->path);
+    current = current->prevSibling;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::CommitSubscribeChanges() {
+  NS_ASSERTION(false, "override this.");
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::SetSearchValue(const nsAString& aSearchValue) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::GetSupportsSubscribeSearch(bool* retVal) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::GetFolderView(nsITreeView** aView) {
+  NS_ENSURE_ARG_POINTER(aView);
+  return this->QueryInterface(NS_GET_IID(nsITreeView), (void**)aView);
+}
+
+int32_t nsSubscribableServer::GetRow(SubscribeTreeNode* node, bool* open) {
+  int32_t parentRow = -1;
+  if (node->parent) parentRow = GetRow(node->parent, open);
+
+  // If the parent wasn't opened, we're not in the row map
+  if (open && *open == false) return -1;
+
+  if (open) *open = node->isOpen;
+
+  for (uint32_t row = parentRow + 1; row < mRowMap.Length(); row++) {
+    if (mRowMap[row] == node) return row;
+  }
+
+  // Apparently, we're not in the map
+  return -1;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::GetSelection(nsITreeSelection** selection) {
+  NS_IF_ADDREF(*selection = mSelection);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::SetSelection(nsITreeSelection* selection) {
+  mSelection = selection;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::GetRowCount(int32_t* rowCount) {
+  *rowCount = mRowMap.Length();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::SetTree(mozilla::dom::XULTreeElement* aTree) {
+  mTree = aTree;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::IsContainer(int32_t aIndex, bool* retval) {
+  *retval = !!mRowMap[aIndex]->firstChild;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::IsContainerEmpty(int32_t aIndex, bool* retval) {
+  *retval = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::IsContainerOpen(int32_t aIndex, bool* retval) {
+  *retval = mRowMap[aIndex]->isOpen;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::GetParentIndex(int32_t aIndex, int32_t* retval) {
+  SubscribeTreeNode* parent = mRowMap[aIndex]->parent;
+  if (!parent) {
+    *retval = -1;
+    return NS_OK;
+  }
+
+  int32_t index;
+  for (index = aIndex - 1; index >= 0; index--) {
+    if (mRowMap[index] == parent) {
+      *retval = index;
+      return NS_OK;
+    }
+  }
+  *retval = -1;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::HasNextSibling(int32_t aRowIndex, int32_t aAfterIndex,
+                                     bool* retval) {
+  // This looks odd, but is correct. Using ->nextSibling gives a bad tree.
+  *retval = !!mRowMap[aRowIndex]->prevSibling;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::GetLevel(int32_t aIndex, int32_t* retval) {
+  // When starting with -2, we increase twice and return 0 for a top level node.
+  int32_t level = -2;
+  SubscribeTreeNode* node = mRowMap[aIndex];
+  while (node) {
+    node = node->parent;
+    level++;
+  }
+
+  *retval = level;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::ToggleOpenState(int32_t aIndex) {
+  SubscribeTreeNode* node = mRowMap[aIndex];
+  if (node->isOpen) {
+    node->isOpen = false;
+
+    // Remove subtree by deleting elements from array up to next sibling.
+    int32_t count = 0;
+    do {
+      // Find next sibling or the beginning of the next subtree.
+      if (node->prevSibling) {
+        count = mRowMap.IndexOf(node->prevSibling, aIndex) - aIndex - 1;
+      } else {
+        node = node->parent;
+        // When node reaches the root, delete the rest of the array.
+        if (!node->parent) {
+          count = mRowMap.Length() - aIndex - 1;
+        }
+      }
+    } while (!count && node->parent);
+    mRowMap.RemoveElementsAt(aIndex + 1, count);
+    if (mTree) {
+      mTree->RowCountChanged(aIndex + 1, -count);
+      mTree->InvalidateRow(aIndex);
+    }
+  } else {
+    // Recursively add the children nodes (i.e., remember open)
+    node->isOpen = true;
+    int32_t total = 0;
+    node = node->lastChild;
+    while (node) {
+      total += AddSubtree(node, aIndex + 1 + total);
+      node = node->prevSibling;
+    }
+    if (mTree) {
+      mTree->RowCountChanged(aIndex + 1, total);
+      mTree->InvalidateRow(aIndex);
+    }
+  }
+  return NS_OK;
+}
+
+int32_t nsSubscribableServer::AddSubtree(SubscribeTreeNode* node,
+                                         int32_t index) {
+  mRowMap.InsertElementAt(index, node);
+  int32_t total = 1;
+  if (node->isOpen) {
+    node = node->lastChild;
+    while (node) {
+      total += AddSubtree(node, index + total);
+      node = node->prevSibling;
+    }
+  }
+  return total;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::GetCellText(int32_t aRow, nsTreeColumn* aCol,
+                                  nsAString& retval) {
+  nsString colId;
+  aCol->GetId(colId);
+  if (colId.EqualsLiteral("nameColumn")) {
+    nsCString path(mRowMap[aRow]->path);
+    GetLeafName(path, retval);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::GetCellValue(int32_t aRow, nsTreeColumn* aCol,
+                                   nsAString& retval) {
+  nsString colId;
+  aCol->GetId(colId);
+  if (colId.EqualsLiteral("nameColumn"))
+    retval = NS_ConvertUTF8toUTF16(mRowMap[aRow]->path);
+  if (colId.EqualsLiteral("subscribedColumn")) {
+    retval = mRowMap[aRow]->isSubscribed ? u"true"_ns : u"false"_ns;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::SetCellText(int32_t aRow, nsTreeColumn* aCol,
+                                  const nsAString& aText) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::SetCellValue(int32_t aRow, nsTreeColumn* aCol,
+                                   const nsAString& aText) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::GetCellProperties(int32_t aRow, nsTreeColumn* aCol,
+                                        nsAString& aProps) {
+  SubscribeTreeNode* node = mRowMap[aRow];
+  if (node->isSubscribable)
+    aProps.AssignLiteral("subscribable-true");
+  else
+    aProps.AssignLiteral("subscribable-false");
+
+  nsString colId;
+  aCol->GetId(colId);
+  if (colId.EqualsLiteral("subscribedColumn")) {
+    if (node->isSubscribed)
+      aProps.AppendLiteral(" subscribed-true");
+    else
+      aProps.AppendLiteral(" subscribed-false");
+  } else if (colId.EqualsLiteral("nameColumn")) {
+    aProps.AppendLiteral(" serverType-");
+    aProps.Append(NS_ConvertUTF8toUTF16(mServerType));
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::GetRowProperties(int32_t aRow, nsAString& aProps) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::GetColumnProperties(nsTreeColumn* aCol,
+                                          nsAString& aProps) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::IsEditable(int32_t aRow, nsTreeColumn* aCol,
+                                 bool* retval) {
+  *retval = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::IsSeparator(int32_t aRowIndex, bool* retval) {
+  *retval = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::IsSorted(bool* retval) {
+  *retval = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::CanDrop(int32_t aIndex, int32_t aOrientation,
+                              mozilla::dom::DataTransfer* aData, bool* retval) {
+  *retval = false;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::Drop(int32_t aRow, int32_t aOrientation,
+                           mozilla::dom::DataTransfer* aData) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::GetImageSrc(int32_t aRow, nsTreeColumn* aCol,
+                                  nsAString& retval) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSubscribableServer::CycleHeader(nsTreeColumn* aCol) { return NS_OK; }
+
+NS_IMETHODIMP
+nsSubscribableServer::SelectionChangedXPCOM() { return NS_OK; }
+
+NS_IMETHODIMP
+nsSubscribableServer::CycleCell(int32_t aRow, nsTreeColumn* aCol) {
+  return NS_OK;
+}