The Tor Browser: layout/inspector/inDOMView.cpp@6474c204b198 (annotated)

layout/inspector/inDOMView.cpp@6474c204b198 (annotated)

layout/inspector/inDOMView.cpp

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- 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 "inDOMView.h"
 #include "inIDOMUtils.h"
 #include "inLayoutUtils.h"
 #include "nsString.h"
 #include "nsReadableUtils.h"
 #include "nsIDOMNode.h"
 #include "nsIDOMNodeFilter.h"
 #include "nsIDOMNodeList.h"
 #include "nsIDOMCharacterData.h"
 #include "nsIDOMAttr.h"
 #include "nsIDOMMozNamedAttrMap.h"
 #include "nsIDOMMutationEvent.h"
 #include "nsBindingManager.h"
 #include "nsNameSpaceManager.h"
 #include "nsIDocument.h"
 #include "nsIServiceManager.h"
 #include "nsITreeColumns.h"
 #include "nsITreeBoxObject.h"
 #include "mozilla/dom/Element.h"
 #include "mozilla/Services.h"
 #ifdef ACCESSIBILITY
 #include "nsIAccessible.h"
 #include "nsIAccessibilityService.h"
 #endif
 using namespace mozilla;
 ////////////////////////////////////////////////////////////////////////
 // inDOMViewNode
 class inDOMViewNode
 {
 public:
   inDOMViewNode() {}
   inDOMViewNode(nsIDOMNode* aNode);
   ~inDOMViewNode();
   nsCOMPtr<nsIDOMNode> node;
   inDOMViewNode* parent;
   inDOMViewNode* next;
   inDOMViewNode* previous;
   int32_t level;
   bool isOpen;
   bool isContainer;
   bool hasAnonymous;
   bool hasSubDocument;
 };
 inDOMViewNode::inDOMViewNode(nsIDOMNode* aNode) :
   node(aNode),
   parent(nullptr),
   next(nullptr),
   previous(nullptr),
   level(0),
   isOpen(false),
   isContainer(false),
   hasAnonymous(false),
   hasSubDocument(false)
 {
 }
 inDOMViewNode::~inDOMViewNode()
 {
 }
 ////////////////////////////////////////////////////////////////////////
 inDOMView::inDOMView() :
   mShowAnonymous(false),
   mShowSubDocuments(false),
   mShowWhitespaceNodes(true),
   mShowAccessibleNodes(false),
   mWhatToShow(nsIDOMNodeFilter::SHOW_ALL)
 {
 }
 inDOMView::~inDOMView()
 {
   SetRootNode(nullptr);
 }
 ////////////////////////////////////////////////////////////////////////
 // nsISupports
 NS_IMPL_ISUPPORTS(inDOMView,
                   inIDOMView,
                   nsITreeView,
                   nsIMutationObserver)
 ////////////////////////////////////////////////////////////////////////
 // inIDOMView
 NS_IMETHODIMP
 inDOMView::GetRootNode(nsIDOMNode** aNode)
 {
   *aNode = mRootNode;
   NS_IF_ADDREF(*aNode);
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::SetRootNode(nsIDOMNode* aNode)
 {
   if (mTree)
     mTree->BeginUpdateBatch();
   if (mRootDocument) {
     // remove previous document observer
     nsCOMPtr<nsINode> doc(do_QueryInterface(mRootDocument));
     if (doc)
       doc->RemoveMutationObserver(this);
   }
   RemoveAllNodes();
   mRootNode = aNode;
   if (aNode) {
     // If we are able to show element nodes, then start with the root node
     // as the first node in the buffer
     if (mWhatToShow & nsIDOMNodeFilter::SHOW_ELEMENT) {
       // allocate new node array
       AppendNode(CreateNode(aNode, nullptr));
     } else {
       // place only the children of the root node in the buffer
       ExpandNode(-1);
     }
     // store an owning reference to document so that it isn't
     // destroyed before we are
     mRootDocument = do_QueryInterface(aNode);
     if (!mRootDocument) {
       aNode->GetOwnerDocument(getter_AddRefs(mRootDocument));
     }
     // add document observer
     nsCOMPtr<nsINode> doc(do_QueryInterface(mRootDocument));
     if (doc)
       doc->AddMutationObserver(this);
   } else {
     mRootDocument = nullptr;
   }
   if (mTree)
     mTree->EndUpdateBatch();
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::GetNodeFromRowIndex(int32_t rowIndex, nsIDOMNode **_retval)
 {
   inDOMViewNode* viewNode = nullptr;
   RowToNode(rowIndex, &viewNode);
   if (!viewNode) return NS_ERROR_FAILURE;
   *_retval = viewNode->node;
   NS_IF_ADDREF(*_retval);
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::GetRowIndexFromNode(nsIDOMNode *node, int32_t *_retval)
 {
   NodeToRow(node, _retval);
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::GetShowAnonymousContent(bool *aShowAnonymousContent)
 {
   *aShowAnonymousContent = mShowAnonymous;
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::SetShowAnonymousContent(bool aShowAnonymousContent)
 {
   mShowAnonymous = aShowAnonymousContent;
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::GetShowSubDocuments(bool *aShowSubDocuments)
 {
   *aShowSubDocuments = mShowSubDocuments;
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::SetShowSubDocuments(bool aShowSubDocuments)
 {
   mShowSubDocuments = aShowSubDocuments;
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::GetShowWhitespaceNodes(bool *aShowWhitespaceNodes)
 {
   *aShowWhitespaceNodes = mShowWhitespaceNodes;
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::SetShowWhitespaceNodes(bool aShowWhitespaceNodes)
 {
   mShowWhitespaceNodes = aShowWhitespaceNodes;
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::GetShowAccessibleNodes(bool *aShowAccessibleNodes)
 {
   *aShowAccessibleNodes = mShowAccessibleNodes;
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::SetShowAccessibleNodes(bool aShowAccessibleNodes)
 {
   mShowAccessibleNodes = aShowAccessibleNodes;
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::GetWhatToShow(uint32_t *aWhatToShow)
 {
   *aWhatToShow = mWhatToShow;
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::SetWhatToShow(uint32_t aWhatToShow)
 {
   mWhatToShow = aWhatToShow;
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::Rebuild()
 {
   nsCOMPtr<nsIDOMNode> root;
   GetRootNode(getter_AddRefs(root));
   SetRootNode(root);
   return NS_OK;
 }
 ////////////////////////////////////////////////////////////////////////
 // nsITreeView
 NS_IMETHODIMP
 inDOMView::GetRowCount(int32_t *aRowCount)
 {
   *aRowCount = GetRowCount();
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::GetRowProperties(int32_t index, nsAString& aProps)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::GetCellProperties(int32_t row, nsITreeColumn* col,
                              nsAString& aProps)
 {
   inDOMViewNode* node = nullptr;
   RowToNode(row, &node);
   if (!node) return NS_ERROR_FAILURE;
   nsCOMPtr<nsIContent> content = do_QueryInterface(node->node);
   if (content && content->IsInAnonymousSubtree()) {
     aProps.AppendLiteral("anonymous ");
   }
   uint16_t nodeType;
   node->node->GetNodeType(&nodeType);
   switch (nodeType) {
     case nsIDOMNode::ELEMENT_NODE:
       aProps.AppendLiteral("ELEMENT_NODE");
       break;
     case nsIDOMNode::ATTRIBUTE_NODE:
       aProps.AppendLiteral("ATTRIBUTE_NODE");
       break;
     case nsIDOMNode::TEXT_NODE:
       aProps.AppendLiteral("TEXT_NODE");
       break;
     case nsIDOMNode::CDATA_SECTION_NODE:
       aProps.AppendLiteral("CDATA_SECTION_NODE");
       break;
     case nsIDOMNode::ENTITY_REFERENCE_NODE:
       aProps.AppendLiteral("ENTITY_REFERENCE_NODE");
       break;
     case nsIDOMNode::ENTITY_NODE:
       aProps.AppendLiteral("ENTITY_NODE");
       break;
     case nsIDOMNode::PROCESSING_INSTRUCTION_NODE:
       aProps.AppendLiteral("PROCESSING_INSTRUCTION_NODE");
       break;
     case nsIDOMNode::COMMENT_NODE:
       aProps.AppendLiteral("COMMENT_NODE");
       break;
     case nsIDOMNode::DOCUMENT_NODE:
       aProps.AppendLiteral("DOCUMENT_NODE");
       break;
     case nsIDOMNode::DOCUMENT_TYPE_NODE:
       aProps.AppendLiteral("DOCUMENT_TYPE_NODE");
       break;
     case nsIDOMNode::DOCUMENT_FRAGMENT_NODE:
       aProps.AppendLiteral("DOCUMENT_FRAGMENT_NODE");
       break;
     case nsIDOMNode::NOTATION_NODE:
       aProps.AppendLiteral("NOTATION_NODE");
       break;
   }
 #ifdef ACCESSIBILITY
   if (mShowAccessibleNodes) {
     nsCOMPtr<nsIAccessibilityService> accService(
       do_GetService("@mozilla.org/accessibilityService;1"));
     NS_ENSURE_TRUE(accService, NS_ERROR_FAILURE);
     nsCOMPtr<nsIAccessible> accessible;
     nsresult rv =
       accService->GetAccessibleFor(node->node, getter_AddRefs(accessible));
     if (NS_SUCCEEDED(rv) && accessible)
       aProps.AppendLiteral(" ACCESSIBLE_NODE");
   }
 #endif
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::GetColumnProperties(nsITreeColumn* col, nsAString& aProps)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::GetImageSrc(int32_t row, nsITreeColumn* col, nsAString& _retval)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::GetProgressMode(int32_t row, nsITreeColumn* col, int32_t* _retval)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::GetCellValue(int32_t row, nsITreeColumn* col, nsAString& _retval)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::GetCellText(int32_t row, nsITreeColumn* col, nsAString& _retval)
 {
   inDOMViewNode* node = nullptr;
   RowToNode(row, &node);
   if (!node) return NS_ERROR_FAILURE;
   nsIDOMNode* domNode = node->node;
   nsAutoString colID;
   col->GetId(colID);
   if (colID.EqualsLiteral("colNodeName"))
     domNode->GetNodeName(_retval);
   else if (colID.EqualsLiteral("colLocalName"))
     domNode->GetLocalName(_retval);
   else if (colID.EqualsLiteral("colPrefix"))
     domNode->GetPrefix(_retval);
   else if (colID.EqualsLiteral("colNamespaceURI"))
     domNode->GetNamespaceURI(_retval);
   else if (colID.EqualsLiteral("colNodeType")) {
     uint16_t nodeType;
     domNode->GetNodeType(&nodeType);
     nsAutoString temp;
     temp.AppendInt(int32_t(nodeType));
     _retval = temp;
   } else if (colID.EqualsLiteral("colNodeValue"))
     domNode->GetNodeValue(_retval);
   else {
     if (StringBeginsWith(colID, NS_LITERAL_STRING("col@"))) {
       nsCOMPtr<nsIDOMElement> el = do_QueryInterface(node->node);
       if (el) {
         nsAutoString attr;
         colID.Right(attr, colID.Length()-4); // have to use this because Substring is crashing on me!
         el->GetAttribute(attr, _retval);
       }
     }
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::IsContainer(int32_t index, bool *_retval)
 {
   inDOMViewNode* node = nullptr;
   RowToNode(index, &node);
   if (!node) return NS_ERROR_FAILURE;
   *_retval = node->isContainer;
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::IsContainerOpen(int32_t index, bool *_retval)
 {
   inDOMViewNode* node = nullptr;
   RowToNode(index, &node);
   if (!node) return NS_ERROR_FAILURE;
   *_retval = node->isOpen;
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::IsContainerEmpty(int32_t index, bool *_retval)
 {
   inDOMViewNode* node = nullptr;
   RowToNode(index, &node);
   if (!node) return NS_ERROR_FAILURE;
   *_retval = node->isContainer ? false : true;
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::GetLevel(int32_t index, int32_t *_retval)
 {
   inDOMViewNode* node = nullptr;
   RowToNode(index, &node);
   if (!node) return NS_ERROR_FAILURE;
   *_retval = node->level;
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::GetParentIndex(int32_t rowIndex, int32_t *_retval)
 {
   inDOMViewNode* node = nullptr;
   RowToNode(rowIndex, &node);
   if (!node) return NS_ERROR_FAILURE;
   // GetParentIndex returns -1 if there is no parent
   *_retval = -1;
   inDOMViewNode* checkNode = nullptr;
   int32_t i = rowIndex - 1;
   do {
     nsresult rv = RowToNode(i, &checkNode);
     if (NS_FAILED(rv)) {
       // No parent. Just break out.
       break;
     }
     if (checkNode == node->parent) {
       *_retval = i;
       return NS_OK;
     }
     --i;
   } while (checkNode);
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::HasNextSibling(int32_t rowIndex, int32_t afterIndex, bool *_retval)
 {
   inDOMViewNode* node = nullptr;
   RowToNode(rowIndex, &node);
   if (!node) return NS_ERROR_FAILURE;
   *_retval = node->next != nullptr;
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::ToggleOpenState(int32_t index)
 {
   inDOMViewNode* node = nullptr;
   RowToNode(index, &node);
   if (!node) return NS_ERROR_FAILURE;
   int32_t oldCount = GetRowCount();
   if (node->isOpen)
     CollapseNode(index);
   else
     ExpandNode(index);
   // Update the twisty.
   mTree->InvalidateRow(index);
   mTree->RowCountChanged(index+1, GetRowCount() - oldCount);
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::SetTree(nsITreeBoxObject *tree)
 {
   mTree = tree;
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::GetSelection(nsITreeSelection * *aSelection)
 {
   *aSelection = mSelection;
   NS_IF_ADDREF(*aSelection);
   return NS_OK;
 }
 NS_IMETHODIMP inDOMView::SetSelection(nsITreeSelection * aSelection)
 {
   mSelection = aSelection;
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::SelectionChanged()
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::SetCellValue(int32_t row, nsITreeColumn* col, const nsAString& value)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::SetCellText(int32_t row, nsITreeColumn* col, const nsAString& value)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::CycleHeader(nsITreeColumn* col)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::CycleCell(int32_t row, nsITreeColumn* col)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::IsEditable(int32_t row, nsITreeColumn* col, bool *_retval)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::IsSelectable(int32_t row, nsITreeColumn* col, bool *_retval)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::IsSeparator(int32_t index, bool *_retval)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::IsSorted(bool *_retval)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::CanDrop(int32_t index, int32_t orientation,
                    nsIDOMDataTransfer* aDataTransfer, bool *_retval)
 {
   *_retval = false;
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::Drop(int32_t row, int32_t orientation, nsIDOMDataTransfer* aDataTransfer)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::PerformAction(const char16_t *action)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::PerformActionOnRow(const char16_t *action, int32_t row)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 inDOMView::PerformActionOnCell(const char16_t* action, int32_t row, nsITreeColumn* col)
 {
   return NS_OK;
 }
 ///////////////////////////////////////////////////////////////////////
 // nsIMutationObserver
 void
 inDOMView::NodeWillBeDestroyed(const nsINode* aNode)
 {
   NS_NOTREACHED("Document destroyed while we're holding a strong ref to it");
 }
 void
 inDOMView::AttributeChanged(nsIDocument* aDocument, dom::Element* aElement,
                             int32_t aNameSpaceID, nsIAtom* aAttribute,
                             int32_t aModType)
 {
   if (!mTree) {
     return;
   }
   if (!(mWhatToShow & nsIDOMNodeFilter::SHOW_ATTRIBUTE)) {
     return;
   }
   nsCOMPtr<nsIMutationObserver> kungFuDeathGrip(this);
   // get the dom attribute node, if there is any
   nsCOMPtr<nsIDOMElement> el(do_QueryInterface(aElement));
   nsCOMPtr<nsIDOMAttr> domAttr;
   nsDependentAtomString attrStr(aAttribute);
   if (aNameSpaceID) {
     nsNameSpaceManager* nsm = nsNameSpaceManager::GetInstance();
     if (!nsm) {
       // we can't find out which attribute we want :(
       return;
     }
     nsString attrNS;
     nsresult rv = nsm->GetNameSpaceURI(aNameSpaceID, attrNS);
     if (NS_FAILED(rv)) {
       return;
     }
     (void)el->GetAttributeNodeNS(attrNS, attrStr, getter_AddRefs(domAttr));
   } else {
     (void)el->GetAttributeNode(attrStr, getter_AddRefs(domAttr));
   }
   if (aModType == nsIDOMMutationEvent::MODIFICATION) {
     // No fancy stuff here, just invalidate the changed row
     if (!domAttr) {
       return;
     }
     int32_t row = 0;
     NodeToRow(domAttr, &row);
     mTree->InvalidateRange(row, row);
   } else if (aModType == nsIDOMMutationEvent::ADDITION) {
     if (!domAttr) {
       return;
     }
     // get the number of attributes on this content node
     nsCOMPtr<nsIDOMMozNamedAttrMap> attrs;
     el->GetAttributes(getter_AddRefs(attrs));
     uint32_t attrCount;
     attrs->GetLength(&attrCount);
     inDOMViewNode* contentNode = nullptr;
     int32_t contentRow;
     int32_t attrRow;
     if (mRootNode == el &&
         !(mWhatToShow & nsIDOMNodeFilter::SHOW_ELEMENT)) {
       // if this view has a root node but is not displaying it,
       // it is ok to act as if the changed attribute is on the root.
       attrRow = attrCount - 1;
     } else {
       if (NS_FAILED(NodeToRow(el, &contentRow))) {
         return;
       }
       RowToNode(contentRow, &contentNode);
       if (!contentNode->isOpen) {
         return;
       }
       attrRow = contentRow + attrCount;
     }
     inDOMViewNode* newNode = CreateNode(domAttr, contentNode);
     inDOMViewNode* insertNode = nullptr;
     RowToNode(attrRow, &insertNode);
     if (insertNode) {
       if (contentNode &&
           insertNode->level <= contentNode->level) {
         RowToNode(attrRow-1, &insertNode);
         InsertLinkAfter(newNode, insertNode);
       } else
         InsertLinkBefore(newNode, insertNode);
     }
     InsertNode(newNode, attrRow);
     mTree->RowCountChanged(attrRow, 1);
   } else if (aModType == nsIDOMMutationEvent::REMOVAL) {
     // At this point, the attribute is already gone from the DOM, but is still represented
     // in our mRows array.  Search through the content node's children for the corresponding
     // node and remove it.
     // get the row of the content node
     inDOMViewNode* contentNode = nullptr;
     int32_t contentRow;
     int32_t baseLevel;
     if (NS_SUCCEEDED(NodeToRow(el, &contentRow))) {
       RowToNode(contentRow, &contentNode);
       baseLevel = contentNode->level;
     } else {
       if (mRootNode == el) {
         contentRow = -1;
         baseLevel = -1;
       } else
         return;
     }
     // search for the attribute node that was removed
     inDOMViewNode* checkNode = nullptr;
     int32_t row = 0;
     for (row = contentRow+1; row < GetRowCount(); ++row) {
       checkNode = GetNodeAt(row);
       if (checkNode->level == baseLevel+1) {
         domAttr = do_QueryInterface(checkNode->node);
         if (domAttr) {
           nsAutoString attrName;
           domAttr->GetNodeName(attrName);
           if (attrName.Equals(attrStr)) {
             // we have found the row for the attribute that was removed
             RemoveLink(checkNode);
             RemoveNode(row);
             mTree->RowCountChanged(row, -1);
             break;
           }
         }
       }
       if (checkNode->level <= baseLevel)
         break;
     }
  }
 }
 void
 inDOMView::ContentAppended(nsIDocument *aDocument,
                            nsIContent* aContainer,
                            nsIContent* aFirstNewContent,
                            int32_t /* unused */)
 {
   if (!mTree) {
     return;
   }
   for (nsIContent* cur = aFirstNewContent; cur; cur = cur->GetNextSibling()) {
     // Our ContentInserted impl doesn't use the index
     ContentInserted(aDocument, aContainer, cur, 0);
   }
 }
 void
 inDOMView::ContentInserted(nsIDocument *aDocument, nsIContent* aContainer,
                            nsIContent* aChild, int32_t /* unused */)
 {
   if (!mTree)
     return;
   nsresult rv;
   nsCOMPtr<nsIDOMNode> childDOMNode(do_QueryInterface(aChild));
   nsCOMPtr<nsIDOMNode> parent;
   if (!mDOMUtils) {
     mDOMUtils = services::GetInDOMUtils();
     if (!mDOMUtils) {
       return;
     }
   }
   mDOMUtils->GetParentForNode(childDOMNode, mShowAnonymous,
                               getter_AddRefs(parent));
   // find the inDOMViewNode for the parent of the inserted content
   int32_t parentRow = 0;
   if (NS_FAILED(rv = NodeToRow(parent, &parentRow)))
     return;
   inDOMViewNode* parentNode = nullptr;
   if (NS_FAILED(rv = RowToNode(parentRow, &parentNode)))
     return;
   nsCOMPtr<nsIMutationObserver> kungFuDeathGrip(this);
   if (!parentNode->isOpen) {
     // Parent is not open, so don't bother creating tree rows for the
     // kids.  But do indicate that it's now a container, if needed.
     if (!parentNode->isContainer) {
       parentNode->isContainer = true;
       mTree->InvalidateRow(parentRow);
     }
     return;
   }
   // get the previous sibling of the inserted content
   nsCOMPtr<nsIDOMNode> previous;
   GetRealPreviousSibling(childDOMNode, parent, getter_AddRefs(previous));
   inDOMViewNode* previousNode = nullptr;
   int32_t row = 0;
   if (previous) {
     // find the inDOMViewNode for the previous sibling of the inserted content
     int32_t previousRow = 0;
     if (NS_FAILED(rv = NodeToRow(previous, &previousRow)))
       return;
     if (NS_FAILED(rv = RowToNode(previousRow, &previousNode)))
       return;
     // get the last descendant of the previous row, which is the row
     // after which to insert this new row
     GetLastDescendantOf(previousNode, previousRow, &row);
     ++row;
   } else {
     // there is no previous sibling, so the new row will be inserted after the parent
     row = parentRow+1;
   }
   inDOMViewNode* newNode = CreateNode(childDOMNode, parentNode);
   if (previous) {
     InsertLinkAfter(newNode, previousNode);
   } else {
     int32_t firstChildRow;
     if (NS_SUCCEEDED(GetFirstDescendantOf(parentNode, parentRow, &firstChildRow))) {
       inDOMViewNode* firstChild;
       RowToNode(firstChildRow, &firstChild);
       InsertLinkBefore(newNode, firstChild);
     }
   }
   // insert new node
   InsertNode(newNode, row);
   mTree->RowCountChanged(row, 1);
 }
 void
 inDOMView::ContentRemoved(nsIDocument *aDocument, nsIContent* aContainer,
                           nsIContent* aChild, int32_t aIndexInContainer,
                           nsIContent* aPreviousSibling)
 {
   if (!mTree)
     return;
   nsresult rv;
   // find the inDOMViewNode for the old child
   nsCOMPtr<nsIDOMNode> oldDOMNode(do_QueryInterface(aChild));
   int32_t row = 0;
   if (NS_FAILED(rv = NodeToRow(oldDOMNode, &row)))
     return;
   inDOMViewNode* oldNode;
   if (NS_FAILED(rv = RowToNode(row, &oldNode)))
     return;
   nsCOMPtr<nsIMutationObserver> kungFuDeathGrip(this);
   // The parent may no longer be a container.  Note that we don't want
   // to access oldNode after calling RemoveNode, so do this now.
   inDOMViewNode* parentNode = oldNode->parent;
   bool isOnlyChild = oldNode->previous == nullptr && oldNode->next == nullptr;
   // Keep track of how many rows we are removing.  It's at least one,
   // but if we're open it's more.
   int32_t oldCount = GetRowCount();
   if (oldNode->isOpen)
     CollapseNode(row);
   RemoveLink(oldNode);
   RemoveNode(row);
   if (isOnlyChild) {
     // Fix up the parent
     parentNode->isContainer = false;
     parentNode->isOpen = false;
     mTree->InvalidateRow(NodeToRow(parentNode));
   }
   mTree->RowCountChanged(row, GetRowCount() - oldCount);
 }
 ///////////////////////////////////////////////////////////////////////
 // inDOMView
 //////// NODE MANAGEMENT
 inDOMViewNode*
 inDOMView::GetNodeAt(int32_t aRow)
 {
   return mNodes.ElementAt(aRow);
 }
 int32_t
 inDOMView::GetRowCount()
 {
   return mNodes.Length();
 }
 int32_t
 inDOMView::NodeToRow(inDOMViewNode* aNode)
 {
   return mNodes.IndexOf(aNode);
 }
 inDOMViewNode*
 inDOMView::CreateNode(nsIDOMNode* aNode, inDOMViewNode* aParent)
 {
   inDOMViewNode* viewNode = new inDOMViewNode(aNode);
   viewNode->level = aParent ? aParent->level+1 : 0;
   viewNode->parent = aParent;
   nsCOMArray<nsIDOMNode> grandKids;
   GetChildNodesFor(aNode, grandKids);
   viewNode->isContainer = (grandKids.Count() > 0);
   return viewNode;
 }
 bool
 inDOMView::RowOutOfBounds(int32_t aRow, int32_t aCount)
 {
   return aRow < 0 || aRow >= GetRowCount() || aCount+aRow > GetRowCount();
 }
 void
 inDOMView::AppendNode(inDOMViewNode* aNode)
 {
   mNodes.AppendElement(aNode);
 }
 void
 inDOMView::InsertNode(inDOMViewNode* aNode, int32_t aRow)
 {
   if (RowOutOfBounds(aRow, 1))
     AppendNode(aNode);
   else
     mNodes.InsertElementAt(aRow, aNode);
 }
 void
 inDOMView::RemoveNode(int32_t aRow)
 {
   if (RowOutOfBounds(aRow, 1))
     return;
   delete GetNodeAt(aRow);
   mNodes.RemoveElementAt(aRow);
 }
 void
 inDOMView::ReplaceNode(inDOMViewNode* aNode, int32_t aRow)
 {
   if (RowOutOfBounds(aRow, 1))
     return;
   delete GetNodeAt(aRow);
   mNodes.ElementAt(aRow) = aNode;
 }
 void
 inDOMView::InsertNodes(nsTArray<inDOMViewNode*>& aNodes, int32_t aRow)
 {
   if (aRow < 0 || aRow > GetRowCount())
     return;
   mNodes.InsertElementsAt(aRow, aNodes);
 }
 void
 inDOMView::RemoveNodes(int32_t aRow, int32_t aCount)
 {
   if (aRow < 0)
     return;
   int32_t rowCount = GetRowCount();
   for (int32_t i = aRow; i < aRow+aCount && i < rowCount; ++i) {
     delete GetNodeAt(i);
   }
   mNodes.RemoveElementsAt(aRow, aCount);
 }
 void
 inDOMView::RemoveAllNodes()
 {
   int32_t rowCount = GetRowCount();
   for (int32_t i = 0; i < rowCount; ++i) {
     delete GetNodeAt(i);
   }
   mNodes.Clear();
 }
 void
 inDOMView::ExpandNode(int32_t aRow)
 {
   inDOMViewNode* node = nullptr;
   RowToNode(aRow, &node);
   nsCOMArray<nsIDOMNode> kids;
   GetChildNodesFor(node ? node->node : mRootNode,
                    kids);
   int32_t kidCount = kids.Count();
   nsTArray<inDOMViewNode*> list(kidCount);
   inDOMViewNode* newNode = nullptr;
   inDOMViewNode* prevNode = nullptr;
   for (int32_t i = 0; i < kidCount; ++i) {
     newNode = CreateNode(kids[i], node);
     list.AppendElement(newNode);
     if (prevNode)
       prevNode->next = newNode;
     newNode->previous = prevNode;
     prevNode = newNode;
   }
   InsertNodes(list, aRow+1);
   if (node)
     node->isOpen = true;
 }
 void
 inDOMView::CollapseNode(int32_t aRow)
 {
   inDOMViewNode* node = nullptr;
   nsresult rv = RowToNode(aRow, &node);
   if (NS_FAILED(rv)) {
     return;
   }
   int32_t row = 0;
   GetLastDescendantOf(node, aRow, &row);
   RemoveNodes(aRow+1, row-aRow);
   node->isOpen = false;
 }
 //////// NODE AND ROW CONVERSION
 nsresult
 inDOMView::RowToNode(int32_t aRow, inDOMViewNode** aNode)
 {
   if (aRow < 0 || aRow >= GetRowCount())
     return NS_ERROR_FAILURE;
   *aNode = GetNodeAt(aRow);
   return NS_OK;
 }
 nsresult
 inDOMView::NodeToRow(nsIDOMNode* aNode, int32_t* aRow)
 {
   int32_t rowCount = GetRowCount();
   for (int32_t i = 0; i < rowCount; ++i) {
     if (GetNodeAt(i)->node == aNode) {
       *aRow = i;
       return NS_OK;
     }
   }
   *aRow = -1;
   return NS_ERROR_FAILURE;
 }
 //////// NODE HIERARCHY MUTATION
 void
 inDOMView::InsertLinkAfter(inDOMViewNode* aNode, inDOMViewNode* aInsertAfter)
 {
   if (aInsertAfter->next)
     aInsertAfter->next->previous = aNode;
   aNode->next = aInsertAfter->next;
   aInsertAfter->next = aNode;
   aNode->previous = aInsertAfter;
 }
 void
 inDOMView::InsertLinkBefore(inDOMViewNode* aNode, inDOMViewNode* aInsertBefore)
 {
   if (aInsertBefore->previous)
     aInsertBefore->previous->next = aNode;
   aNode->previous = aInsertBefore->previous;
   aInsertBefore->previous = aNode;
   aNode->next = aInsertBefore;
 }
 void
 inDOMView::RemoveLink(inDOMViewNode* aNode)
 {
   if (aNode->previous)
     aNode->previous->next = aNode->next;
   if (aNode->next)
     aNode->next->previous = aNode->previous;
 }
 void
 inDOMView::ReplaceLink(inDOMViewNode* aNewNode, inDOMViewNode* aOldNode)
 {
   if (aOldNode->previous)
     aOldNode->previous->next = aNewNode;
   if (aOldNode->next)
     aOldNode->next->previous = aNewNode;
   aNewNode->next = aOldNode->next;
   aNewNode->previous = aOldNode->previous;
 }
 //////// NODE HIERARCHY UTILITIES
 nsresult
 inDOMView::GetFirstDescendantOf(inDOMViewNode* aNode, int32_t aRow, int32_t* aResult)
 {
   // get the first node that is a descendant of the previous sibling
   int32_t row = 0;
   inDOMViewNode* node;
   for (row = aRow+1; row < GetRowCount(); ++row) {
     node = GetNodeAt(row);
     if (node->parent == aNode) {
       *aResult = row;
       return NS_OK;
     }
     if (node->level <= aNode->level)
       break;
   }
   return NS_ERROR_FAILURE;
 }
 nsresult
 inDOMView::GetLastDescendantOf(inDOMViewNode* aNode, int32_t aRow, int32_t* aResult)
 {
   // get the last node that is a descendant of the previous sibling
   int32_t row = 0;
   for (row = aRow+1; row < GetRowCount(); ++row) {
     if (GetNodeAt(row)->level <= aNode->level)
       break;
   }
   *aResult = row-1;
   return NS_OK;
 }
 //////// DOM UTILITIES
 nsresult
 inDOMView::GetChildNodesFor(nsIDOMNode* aNode, nsCOMArray<nsIDOMNode>& aResult)
 {
   NS_ENSURE_ARG(aNode);
   // attribute nodes
   if (mWhatToShow & nsIDOMNodeFilter::SHOW_ATTRIBUTE) {
     nsCOMPtr<nsIDOMElement> element = do_QueryInterface(aNode);
     if (element) {
       nsCOMPtr<nsIDOMMozNamedAttrMap> attrs;
       element->GetAttributes(getter_AddRefs(attrs));
       if (attrs) {
         AppendAttrsToArray(attrs, aResult);
       }
     }
   }
   if (mWhatToShow & nsIDOMNodeFilter::SHOW_ELEMENT) {
     nsCOMPtr<nsIDOMNodeList> kids;
     if (!mDOMUtils) {
       mDOMUtils = services::GetInDOMUtils();
       if (!mDOMUtils) {
         return NS_ERROR_FAILURE;
       }
     }
     mDOMUtils->GetChildrenForNode(aNode, mShowAnonymous,
                                   getter_AddRefs(kids));
     if (kids) {
       AppendKidsToArray(kids, aResult);
     }
   }
   if (mShowSubDocuments) {
     nsCOMPtr<nsIDOMNode> domdoc =
       do_QueryInterface(inLayoutUtils::GetSubDocumentFor(aNode));
     if (domdoc) {
       aResult.AppendObject(domdoc);
     }
   }
   return NS_OK;
 }
 nsresult
 inDOMView::GetRealPreviousSibling(nsIDOMNode* aNode, nsIDOMNode* aRealParent, nsIDOMNode** aSibling)
 {
   // XXXjrh: This won't work for some cases during some situations where XBL insertion points
   // are involved.  Fix me!
   aNode->GetPreviousSibling(aSibling);
   return NS_OK;
 }
 nsresult
 inDOMView::AppendKidsToArray(nsIDOMNodeList* aKids,
                              nsCOMArray<nsIDOMNode>& aArray)
 {
   uint32_t l = 0;
   aKids->GetLength(&l);
   nsCOMPtr<nsIDOMNode> kid;
   uint16_t nodeType = 0;
   // Try and get DOM Utils in case we don't have one yet.
   if (!mShowWhitespaceNodes && !mDOMUtils) {
     mDOMUtils = services::GetInDOMUtils();
   }
   for (uint32_t i = 0; i < l; ++i) {
     aKids->Item(i, getter_AddRefs(kid));
     kid->GetNodeType(&nodeType);
     NS_ASSERTION(nodeType && nodeType <= nsIDOMNode::NOTATION_NODE,
                  "Unknown node type. "
                  "Were new types added to the spec?");
     // As of DOM Level 2 Core and Traversal, each NodeFilter constant
     // is defined as the lower nth bit in the NodeFilter bitmask,
     // where n is the numeric constant of the nodeType it represents.
     // If this invariant ever changes, we will need to update the
     // following line.
     uint32_t filterForNodeType = 1 << (nodeType - 1);
     if (mWhatToShow & filterForNodeType) {
       if ((nodeType == nsIDOMNode::TEXT_NODE ||
            nodeType == nsIDOMNode::COMMENT_NODE) &&
           !mShowWhitespaceNodes && mDOMUtils) {
         nsCOMPtr<nsIDOMCharacterData> data = do_QueryInterface(kid);
         NS_ASSERTION(data, "Does not implement nsIDOMCharacterData!");
         bool ignore;
         mDOMUtils->IsIgnorableWhitespace(data, &ignore);
         if (ignore) {
           continue;
         }
       }
       aArray.AppendObject(kid);
     }
   }
   return NS_OK;
 }
 nsresult
 inDOMView::AppendAttrsToArray(nsIDOMMozNamedAttrMap* aAttributes,
                               nsCOMArray<nsIDOMNode>& aArray)
 {
   uint32_t l = 0;
   aAttributes->GetLength(&l);
   nsCOMPtr<nsIDOMAttr> attribute;
   for (uint32_t i = 0; i < l; ++i) {
     aAttributes->Item(i, getter_AddRefs(attribute));
     aArray.AppendObject(attribute);
   }
   return NS_OK;
 }

The Tor Browser / annotate

layout/inspector/inDOMView.cpp@6474c204b198 (annotated)

layout/inspector/inDOMView.cpp