The Tor Browser: security/manager/pki/src/nsASN1Tree.cpp@6474c204b198 (annotated)

security/manager/pki/src/nsASN1Tree.cpp@6474c204b198 (annotated)

security/manager/pki/src/nsASN1Tree.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.

 /* 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 "nsASN1Tree.h"
 #include "nsIComponentManager.h"
 #include "nsString.h"
 #include "nsCRT.h"
 #include "nsIMutableArray.h"
 #include "nsArrayUtils.h"
 NS_IMPL_ISUPPORTS(nsNSSASN1Tree, nsIASN1Tree, nsITreeView)
 nsNSSASN1Tree::nsNSSASN1Tree()
 :mTopNode(nullptr)
 {
 }
 nsNSSASN1Tree::~nsNSSASN1Tree()
 {
   ClearNodes();
 }
 void nsNSSASN1Tree::ClearNodesRecursively(myNode *n)
 {
   myNode *walk = n;
   while (walk) {
     myNode *kill = walk;
     if (walk->child) {
       ClearNodesRecursively(walk->child);
     }
     walk = walk->next;
     delete kill;
   }
 }
 void nsNSSASN1Tree::ClearNodes()
 {
   ClearNodesRecursively(mTopNode);
   mTopNode = nullptr;
 }
 void nsNSSASN1Tree::InitChildsRecursively(myNode *n)
 {
   if (!n->obj)
     return;
   n->seq = do_QueryInterface(n->obj);
   if (!n->seq)
     return;
   // If the object is a sequence, there might still be a reason
   // why it should not be displayed as a container.
   // If we decide that it has all the properties to justify
   // displaying as a container, we will create a new child chain.
   // If we decide, it does not make sense to display as a container,
   // we forget that it is a sequence by erasing n->seq.
   // That way, n->seq and n->child will be either both set or both null.
   bool isContainer;
   n->seq->GetIsValidContainer(&isContainer);
   if (!isContainer) {
     n->seq = nullptr;
     return;
   }
   nsCOMPtr<nsIMutableArray> asn1Objects;
   n->seq->GetASN1Objects(getter_AddRefs(asn1Objects));
   uint32_t numObjects;
   asn1Objects->GetLength(&numObjects);
   if (!numObjects) {
     n->seq = nullptr;
     return;
   }
   myNode *walk = nullptr;
   myNode *prev = nullptr;
   uint32_t i;
   nsCOMPtr<nsISupports> isupports;
   for (i=0; i<numObjects; i++) {
     if (0 == i) {
       n->child = walk = new myNode;
     }
     else {
       walk = new myNode;
     }
     walk->parent = n;
     if (prev) {
       prev->next = walk;
     }
     walk->obj = do_QueryElementAt(asn1Objects, i);
     InitChildsRecursively(walk);
     prev = walk;
   }
 }
 void nsNSSASN1Tree::InitNodes()
 {
   ClearNodes();
   mTopNode = new myNode;
   mTopNode->obj = mASN1Object;
   InitChildsRecursively(mTopNode);
 }
 /* void loadASN1Structure (in nsIASN1Object asn1Object); */
 NS_IMETHODIMP
 nsNSSASN1Tree::LoadASN1Structure(nsIASN1Object *asn1Object)
 {
   //
   // The tree won't automatically re-draw if the contents
   // have been changed.  So I do a quick test here to let
   // me know if I should forced the tree to redraw itself
   // by calling RowCountChanged on it.
   //
   bool redraw = (mASN1Object && mTree);
   int32_t rowsToDelete = 0;
   if (redraw) {
     // This is the number of rows we will be deleting after
     // the contents have changed.
     rowsToDelete = 0-CountVisibleNodes(mTopNode);
   }
   mASN1Object = asn1Object;
   InitNodes();
   if (redraw) {
     // The number of rows in the new content.
     int32_t newRows = CountVisibleNodes(mTopNode);
     mTree->BeginUpdateBatch();
     // Erase all of the old rows.
     mTree->RowCountChanged(0, rowsToDelete);
     // Replace them with the new contents
     mTree->RowCountChanged(0, newRows);
     mTree->EndUpdateBatch();
   }
   return NS_OK;
 }
 /* readonly attribute long rowCount; */
 NS_IMETHODIMP
 nsNSSASN1Tree::GetRowCount(int32_t *aRowCount)
 {
   if (mASN1Object) {
     *aRowCount = CountVisibleNodes(mTopNode);
   } else {
     *aRowCount = 0;
   }
   return NS_OK;
 }
 /* attribute nsITreeSelection selection; */
 NS_IMETHODIMP
 nsNSSASN1Tree::GetSelection(nsITreeSelection * *aSelection)
 {
   *aSelection = mSelection;
   NS_IF_ADDREF(*aSelection);
   return NS_OK;
 }
 NS_IMETHODIMP
 nsNSSASN1Tree::SetSelection(nsITreeSelection * aSelection)
 {
   mSelection = aSelection;
   return NS_OK;
 }
 NS_IMETHODIMP
 nsNSSASN1Tree::GetRowProperties(int32_t index, nsAString& aProps)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 nsNSSASN1Tree::GetCellProperties(int32_t row, nsITreeColumn* col,
                                  nsAString& aProps)
 {
   return NS_OK;
 }
 NS_IMETHODIMP
 nsNSSASN1Tree::GetColumnProperties(nsITreeColumn* col, nsAString& aProps)
 {
   return NS_OK;
 }
 /* boolean isContainer (in long index); */
 NS_IMETHODIMP
 nsNSSASN1Tree::IsContainer(int32_t index, bool *_retval)
 {
   myNode *n = FindNodeFromIndex(index);
   if (!n)
     return NS_ERROR_FAILURE;
   *_retval = (n->seq != nullptr);
   return NS_OK;
 }
 /* boolean isContainerOpen (in long index); */
 NS_IMETHODIMP
 nsNSSASN1Tree::IsContainerOpen(int32_t index, bool *_retval)
 {
   myNode *n = FindNodeFromIndex(index);
   if (!n || !n->seq)
     return NS_ERROR_FAILURE;
   n->seq->GetIsExpanded(_retval);
   return NS_OK;
 }
 /* boolean isContainerEmpty (in long index); */
 NS_IMETHODIMP
 nsNSSASN1Tree::IsContainerEmpty(int32_t index, bool *_retval)
 {
   *_retval = false;
   return NS_OK;
 }
 /* boolean isSeparator (in long index); */
 NS_IMETHODIMP
 nsNSSASN1Tree::IsSeparator(int32_t index, bool *_retval)
 {
   *_retval = false;
   return NS_OK;
 }
 /* long getLevel (in long index); */
 NS_IMETHODIMP
 nsNSSASN1Tree::GetLevel(int32_t index, int32_t *_retval)
 {
   int32_t parentIndex;
   int32_t nodeLevel;
   myNode *n = FindNodeFromIndex(index, &parentIndex, &nodeLevel);
   if (!n)
     return NS_ERROR_FAILURE;
   *_retval = nodeLevel;
   return NS_OK;
 }
 /* Astring getImageSrc (in long row, in nsITreeColumn col); */
 NS_IMETHODIMP
 nsNSSASN1Tree::GetImageSrc(int32_t row, nsITreeColumn* col,
                            nsAString& _retval)
 {
   return NS_OK;
 }
 /* long getProgressMode (in long row, in nsITreeColumn col); */
 NS_IMETHODIMP
 nsNSSASN1Tree::GetProgressMode(int32_t row, nsITreeColumn* col, int32_t* _retval)
 {
   return NS_OK;
 }
 /* Astring getCellValue (in long row, in nsITreeColumn col); */
 NS_IMETHODIMP
 nsNSSASN1Tree::GetCellValue(int32_t row, nsITreeColumn* col,
                             nsAString& _retval)
 {
   return NS_OK;
 }
 /* Astring getCellText (in long row, in nsITreeColumn col); */
 NS_IMETHODIMP
 nsNSSASN1Tree::GetCellText(int32_t row, nsITreeColumn* col,
                            nsAString& _retval)
 {
   _retval.Truncate();
   myNode* n = FindNodeFromIndex(row);
   if (!n)
     return NS_ERROR_FAILURE;
   // There's only one column for ASN1 dump.
   return n->obj->GetDisplayName(_retval);
 }
 /* wstring getDisplayData (in unsigned long index); */
 NS_IMETHODIMP
 nsNSSASN1Tree::GetDisplayData(uint32_t index, nsAString &_retval)
 {
   myNode *n = FindNodeFromIndex(index);
   if (!n)
     return NS_ERROR_FAILURE;
   n->obj->GetDisplayValue(_retval);
   return NS_OK;
 }
 /* void setTree (in nsITreeBoxObject tree); */
 NS_IMETHODIMP
 nsNSSASN1Tree::SetTree(nsITreeBoxObject *tree)
 {
   mTree = tree;
   return NS_OK;
 }
 /* void toggleOpenState (in long index); */
 NS_IMETHODIMP
 nsNSSASN1Tree::ToggleOpenState(int32_t index)
 {
   myNode *n = FindNodeFromIndex(index);
   if (!n)
     return NS_ERROR_FAILURE;
   if (!n->seq)
     return NS_ERROR_FAILURE;
   bool IsExpanded;
   n->seq->GetIsExpanded(&IsExpanded);
   int32_t rowCountChange;
   if (IsExpanded) {
     rowCountChange = -CountVisibleNodes(n->child);
     n->seq->SetIsExpanded(false);
   } else {
     n->seq->SetIsExpanded(true);
     rowCountChange = CountVisibleNodes(n->child);
   }
   if (mTree)
     mTree->RowCountChanged(index, rowCountChange);
   return NS_OK;
 }
 /* void cycleHeader (in nsITreeColumn col); */
 NS_IMETHODIMP
 nsNSSASN1Tree::CycleHeader(nsITreeColumn* col)
 {
   return NS_OK;
 }
 /* void selectionChanged (); */
 NS_IMETHODIMP
 nsNSSASN1Tree::SelectionChanged()
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 /* void cycleCell (in long row, in nsITreeColumn col); */
 NS_IMETHODIMP
 nsNSSASN1Tree::CycleCell(int32_t row, nsITreeColumn* col)
 {
   return NS_OK;
 }
 /* boolean isEditable (in long row, in nsITreeColumn col); */
 NS_IMETHODIMP
 nsNSSASN1Tree::IsEditable(int32_t row, nsITreeColumn* col,
                           bool *_retval)
 {
   *_retval = false;
   return NS_OK;
 }
 /* boolean isSelectable (in long row, in nsITreeColumn col); */
 NS_IMETHODIMP
 nsNSSASN1Tree::IsSelectable(int32_t row, nsITreeColumn* col,
                             bool *_retval)
 {
   *_retval = false;
   return NS_OK;
 }
 /* void setCellValue (in long row, in nsITreeColumn col, in AString value); */
 NS_IMETHODIMP
 nsNSSASN1Tree::SetCellValue(int32_t row, nsITreeColumn* col,
                             const nsAString& value)
 {
   return NS_OK;
 }
 /* void setCellText (in long row, in nsITreeColumn col, in AString value); */
 NS_IMETHODIMP
 nsNSSASN1Tree::SetCellText(int32_t row, nsITreeColumn* col,
                            const nsAString& value)
 {
   return NS_OK;
 }
 /* void performAction (in wstring action); */
 NS_IMETHODIMP
 nsNSSASN1Tree::PerformAction(const char16_t *action)
 {
   return NS_OK;
 }
 /* void performActionOnRow (in wstring action, in long row); */
 NS_IMETHODIMP
 nsNSSASN1Tree::PerformActionOnRow(const char16_t *action, int32_t row)
 {
   return NS_OK;
 }
 /* void performActionOnCell (in wstring action, in long row, in nsITreeColumn col); */
 NS_IMETHODIMP
 nsNSSASN1Tree::PerformActionOnCell(const char16_t *action, int32_t row,
                                    nsITreeColumn* col)
 {
   return NS_OK;
 }
 //
 // CanDrop
 //
 NS_IMETHODIMP nsNSSASN1Tree::CanDrop(int32_t index, int32_t orientation,
                                      nsIDOMDataTransfer* aDataTransfer, bool *_retval)
 {
   NS_ENSURE_ARG_POINTER(_retval);
   *_retval = false;
   return NS_OK;
 }
 //
 // Drop
 //
 NS_IMETHODIMP nsNSSASN1Tree::Drop(int32_t row, int32_t orient, nsIDOMDataTransfer* aDataTransfer)
 {
   return NS_OK;
 }
 //
 // IsSorted
 //
 // ...
 //
 NS_IMETHODIMP nsNSSASN1Tree::IsSorted(bool *_retval)
 {
   *_retval = false;
   return NS_OK;
 }
 /* long getParentIndex (in long rowIndex); */
 NS_IMETHODIMP
 nsNSSASN1Tree::GetParentIndex(int32_t rowIndex, int32_t *_retval)
 {
   int32_t parentIndex = -1;
   myNode *n = FindNodeFromIndex(rowIndex, &parentIndex);
   if (!n)
     return NS_ERROR_FAILURE;
   *_retval = parentIndex;
   return NS_OK;
 }
 /* boolean hasNextSibling (in long rowIndex, in long afterIndex); */
 NS_IMETHODIMP
 nsNSSASN1Tree::HasNextSibling(int32_t rowIndex, int32_t afterIndex,
                               bool *_retval)
 {
   myNode *n = FindNodeFromIndex(rowIndex);
   if (!n)
     return NS_ERROR_FAILURE;
   if (!n->next) {
     *_retval = false;
   }
   else {
     int32_t nTotalSize = CountVisibleNodes(n);
     int32_t nLastChildPos = rowIndex + nTotalSize -1;
     int32_t nextSiblingPos = nLastChildPos +1;
     *_retval = (nextSiblingPos > afterIndex);
   }
   return NS_OK;
 }
 int32_t nsNSSASN1Tree::CountVisibleNodes(myNode *n)
 {
   if (!n)
     return 0;
   myNode *walk = n;
   int32_t count = 0;
   while (walk) {
     ++count;
     if (walk->seq) {
       bool IsExpanded;
       walk->seq->GetIsExpanded(&IsExpanded);
       if (IsExpanded) {
         count += CountVisibleNodes(walk->child);
       }
     }
     walk = walk->next;
   }
   return count;
 }
 // Entry point for find
 nsNSSASN1Tree::myNode *
 nsNSSASN1Tree::FindNodeFromIndex(int32_t wantedIndex,
                                  int32_t *optionalOutParentIndex, int32_t *optionalOutLevel)
 {
   if (0 == wantedIndex) {
     if (optionalOutLevel) {
       *optionalOutLevel = 0;
     }
     if (optionalOutParentIndex) {
       *optionalOutParentIndex = -1;
     }
     return mTopNode;
   }
   else {
     int32_t index = 0;
     int32_t level = 0;
     return FindNodeFromIndex(mTopNode, wantedIndex, index, level,
                              optionalOutParentIndex, optionalOutLevel);
   }
 }
 // Internal recursive helper function
 nsNSSASN1Tree::myNode *
 nsNSSASN1Tree::FindNodeFromIndex(myNode *n, int32_t wantedIndex,
                                  int32_t &index_counter, int32_t &level_counter,
                                  int32_t *optionalOutParentIndex, int32_t *optionalOutLevel)
 {
   if (!n)
     return nullptr;
   myNode *walk = n;
   int32_t parentIndex = index_counter-1;
   while (walk) {
     if (index_counter == wantedIndex) {
       if (optionalOutLevel) {
         *optionalOutLevel = level_counter;
       }
       if (optionalOutParentIndex) {
         *optionalOutParentIndex = parentIndex;
       }
       return walk;
     }
     if (walk->seq) {
       bool IsExpanded;
       walk->seq->GetIsExpanded(&IsExpanded);
       if (IsExpanded) {
         ++index_counter; // set to walk->child
         ++level_counter;
         myNode *found = FindNodeFromIndex(walk->child, wantedIndex, index_counter, level_counter,
                                           optionalOutParentIndex, optionalOutLevel);
         --level_counter;
         if (found)
           return found;
       }
     }
     walk = walk->next;
     if (walk) {
       ++index_counter;
     }
   }
   return nullptr;
 }

The Tor Browser / annotate

security/manager/pki/src/nsASN1Tree.cpp@6474c204b198 (annotated)

security/manager/pki/src/nsASN1Tree.cpp