The Tor Browser: dom/xslt/xpath/txXPathNode.h@97036ab72558

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

     1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

     2 /* This Source Code Form is subject to the terms of the Mozilla Public

     3  * License, v. 2.0. If a copy of the MPL was not distributed with this

     4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     6 #ifndef txXPathNode_h__

     7 #define txXPathNode_h__

     9 #include "nsAutoPtr.h"

    10 #include "nsIContent.h"

    11 #include "nsIDocument.h"

    12 #include "nsIDOMNode.h"

    13 #include "nsNameSpaceManager.h"

    14 #include "nsContentUtils.h" // For NameSpaceManager().

    16 typedef nsIDOMNode txXPathNodeType;

    18 class txXPathNode

    19 {

    20 public:

    21     bool operator==(const txXPathNode& aNode) const;

    22     bool operator!=(const txXPathNode& aNode) const

    23     {

    24         return !(*this == aNode);

    25     }

    26     ~txXPathNode();

    28 private:

    29     friend class txNodeSet;

    30     friend class txXPathNativeNode;

    31     friend class txXPathNodeUtils;

    32     friend class txXPathTreeWalker;

    34     txXPathNode(const txXPathNode& aNode);

    36     txXPathNode(nsIDocument* aDocument) : mNode(aDocument),

    37                                           mRefCountRoot(0),

    38                                           mIndex(eDocument)

    39     {

    40         MOZ_COUNT_CTOR(txXPathNode);

    41     }

    42     txXPathNode(nsINode *aNode, uint32_t aIndex, nsINode *aRoot)

    43         : mNode(aNode),

    44           mRefCountRoot(aRoot ? 1 : 0),

    45           mIndex(aIndex)

    46     {

    47         MOZ_COUNT_CTOR(txXPathNode);

    48         if (aRoot) {

    49             NS_ADDREF(aRoot);

    50         }

    51     }

    53     static nsINode *RootOf(nsINode *aNode)

    54     {

    55         nsINode *ancestor, *root = aNode;

    56         while ((ancestor = root->GetParentNode())) {

    57             root = ancestor;

    58         }

    59         return root;

    60     }

    61     nsINode *Root() const

    62     {

    63         return RootOf(mNode);

    64     }

    65     nsINode *GetRootToAddRef() const

    66     {

    67         return mRefCountRoot ? Root() : nullptr;

    68     }

    70     bool isDocument() const

    71     {

    72         return mIndex == eDocument;

    73     }

    74     bool isContent() const

    75     {

    76         return mIndex == eContent;

    77     }

    78     bool isAttribute() const

    79     {

    80         return mIndex != eDocument && mIndex != eContent;

    81     }

    83     nsIContent* Content() const

    84     {

    85         NS_ASSERTION(isContent() || isAttribute(), "wrong type");

    86         return static_cast<nsIContent*>(mNode);

    87     }

    88     nsIDocument* Document() const

    89     {

    90         NS_ASSERTION(isDocument(), "wrong type");

    91         return static_cast<nsIDocument*>(mNode);

    92     }

    94     enum PositionType

    95     {

    96         eDocument = (1 << 30),

    97         eContent = eDocument - 1

    98     };

   100     nsINode* mNode;

   101     uint32_t mRefCountRoot : 1;

   102     uint32_t mIndex : 31;

   103 };

   105 class txNamespaceManager

   106 {

   107 public:

   108     static int32_t getNamespaceID(const nsAString& aNamespaceURI);

   109     static nsresult getNamespaceURI(const int32_t aID, nsAString& aResult);

   110 };

   112 /* static */

   113 inline int32_t

   114 txNamespaceManager::getNamespaceID(const nsAString& aNamespaceURI)

   115 {

   116     int32_t namespaceID = kNameSpaceID_Unknown;

   117     nsContentUtils::NameSpaceManager()->

   118         RegisterNameSpace(aNamespaceURI, namespaceID);

   119     return namespaceID;

   120 }

   122 /* static */

   123 inline nsresult

   124 txNamespaceManager::getNamespaceURI(const int32_t aID, nsAString& aResult)

   125 {

   126     return nsContentUtils::NameSpaceManager()->

   127         GetNameSpaceURI(aID, aResult);

   128 }

   130 inline bool

   131 txXPathNode::operator==(const txXPathNode& aNode) const

   132 {

   133     return mIndex == aNode.mIndex && mNode == aNode.mNode;

   134 }

   136 #endif /* txXPathNode_h__ */

The Tor Browser / file revision

dom/xslt/xpath/txXPathNode.h@97036ab72558

dom/xslt/xpath/txXPathNode.h