DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Implementation

Mercurial (1aeaa33a64f9)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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/. */

#ifndef nsINode_h___
#define nsINode_h___

#include "mozilla/Likely.h"
#include "mozilla/UniquePtr.h"
#include "nsCOMPtr.h"   // for member, local
#include "nsGkAtoms.h"  // for nsGkAtoms::baseURIProperty
#include "nsIDOMNode.h"
#include "mozilla/dom/NodeInfo.h"  // member (in nsCOMPtr)
#include "nsIVariant.h"            // for use in GetUserData()
#include "nsNodeInfoManager.h"     // for use in NodePrincipal()
#include "nsPropertyTable.h"       // for typedefs
#include "nsTObserverArray.h"      // for member
#include "nsWindowSizes.h"         // for nsStyleSizes
#include "mozilla/ErrorResult.h"
#include "mozilla/LinkedList.h"
#include "mozilla/MemoryReporting.h"
#include "mozilla/dom/EventTarget.h"  // for base class
#include "js/TypeDecls.h"             // for Handle, Value, JSObject, JSContext
#include "mozilla/dom/DOMString.h"
#include "mozilla/dom/BindingDeclarations.h"
#include "mozilla/dom/NodeBinding.h"
#include "nsTHashtable.h"
#include <iosfwd>

// Including 'windows.h' will #define GetClassInfo to something else.
#ifdef XP_WIN
#ifdef GetClassInfo
#undef GetClassInfo
#endif
#endif

class nsAttrAndChildArray;
class nsAttrChildContentList;
struct nsCSSSelectorList;
class nsDOMAttributeMap;
class nsIAnimationObserver;
class nsIContent;
class nsIDocument;
class nsIDOMElement;
class nsIDOMNodeList;
class nsIFrame;
class nsIMutationObserver;
class nsINode;
class nsINodeList;
class nsIPresShell;
class nsIPrincipal;
class nsIURI;
class nsNodeSupportsWeakRefTearoff;
class nsNodeWeakReference;
class nsDOMMutationObserver;
class nsRange;
struct RawServoSelectorList;

namespace mozilla {
class EventListenerManager;
class TextEditor;
namespace dom {
/**
 * @return true if aChar is what the WHATWG defines as a 'ascii whitespace'.
 * https://infra.spec.whatwg.org/#ascii-whitespace
 */
inline bool IsSpaceCharacter(char16_t aChar) {
  return aChar == ' ' || aChar == '\t' || aChar == '\n' || aChar == '\r' ||
         aChar == '\f';
}
inline bool IsSpaceCharacter(char aChar) {
  return aChar == ' ' || aChar == '\t' || aChar == '\n' || aChar == '\r' ||
         aChar == '\f';
}
class AccessibleNode;
struct BoxQuadOptions;
struct ConvertCoordinateOptions;
class DocGroup;
class DOMPoint;
class DOMQuad;
class DOMRectReadOnly;
class Element;
class EventHandlerNonNull;
class L10nCallback;
template <typename T>
class Optional;
class OwningNodeOrString;
class Promise;
template <typename>
class Sequence;
class Text;
class TextOrElementOrDocument;
struct DOMPointInit;
struct GetRootNodeOptions;
enum class CallerType : uint32_t;
}  // namespace dom
}  // namespace mozilla

#define NODE_FLAG_BIT(n_) \
  (nsWrapperCache::FlagsType(1U) << (WRAPPER_CACHE_FLAGS_BITS_USED + (n_)))

enum {
  // This bit will be set if the node has a listener manager.
  NODE_HAS_LISTENERMANAGER = NODE_FLAG_BIT(0),

  // Whether this node has had any properties set on it
  NODE_HAS_PROPERTIES = NODE_FLAG_BIT(1),

  // Whether this node is the root of an anonymous subtree.  Note that this
  // need not be a native anonymous subtree.  Any anonymous subtree, including
  // XBL-generated ones, will do.  This flag is set-once: once a node has it,
  // it must not be removed.
  // NOTE: Should only be used on nsIContent nodes
  NODE_IS_ANONYMOUS_ROOT = NODE_FLAG_BIT(2),

  // Whether the node has some ancestor, possibly itself, that is native
  // anonymous.  This includes ancestors crossing XBL scopes, in cases when an
  // XBL binding is attached to an element which has a native anonymous
  // ancestor.  This flag is set-once: once a node has it, it must not be
  // removed.
  // NOTE: Should only be used on nsIContent nodes
  NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE = NODE_FLAG_BIT(3),

  // Whether this node is the root of a native anonymous (from the perspective
  // of its parent) subtree.  This flag is set-once: once a node has it, it
  // must not be removed.
  // NOTE: Should only be used on nsIContent nodes
  NODE_IS_NATIVE_ANONYMOUS_ROOT = NODE_FLAG_BIT(4),

  // Forces the XBL code to treat this node as if it were
  // in the document and therefore should get bindings attached.
  NODE_FORCE_XBL_BINDINGS = NODE_FLAG_BIT(5),

  // Whether a binding manager may have a pointer to this
  NODE_MAY_BE_IN_BINDING_MNGR = NODE_FLAG_BIT(6),

  NODE_IS_EDITABLE = NODE_FLAG_BIT(7),

  // This node was created by layout as native anonymous content. This
  // generally corresponds to things created by nsIAnonymousContentCreator,
  // though there are exceptions (svg:use content does not have this flag
  // set, and any non-nsIAnonymousContentCreator callers of
  // SetIsNativeAnonymousRoot also get this flag).
  //
  // One very important aspect here is that this node is not transitive over
  // the subtree (if you want that, use NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE).
  // If Gecko code somewhere attaches children to a node with this bit set,
  // the children will not have the bit themselves unless the calling code sets
  // it explicitly. This means that XBL content bound to NAC doesn't get this
  // bit, nor do nodes inserted by editor.
  //
  // For now, this bit exists primarily to control style inheritance behavior,
  // since the nodes for which we set it are often used to implement pseudo-
  // elements, which need to inherit style from a script-visible element.
  //
  // A more general principle for this bit might be this: If the node is
  // entirely
  // a detail of layout, is not script-observable in any way, and other engines
  // might accomplish the same task with a nodeless layout frame, then the node
  // should have this bit set.
  NODE_IS_NATIVE_ANONYMOUS = NODE_FLAG_BIT(8),

  // Whether the node participates in a shadow tree.
  NODE_IS_IN_SHADOW_TREE = NODE_FLAG_BIT(9),

  // Node has an :empty or :-moz-only-whitespace selector
  NODE_HAS_EMPTY_SELECTOR = NODE_FLAG_BIT(10),

  // A child of the node has a selector such that any insertion,
  // removal, or appending of children requires restyling the parent.
  NODE_HAS_SLOW_SELECTOR = NODE_FLAG_BIT(11),

  // A child of the node has a :first-child, :-moz-first-node,
  // :only-child, :last-child or :-moz-last-node selector.
  NODE_HAS_EDGE_CHILD_SELECTOR = NODE_FLAG_BIT(12),

  // A child of the node has a selector such that any insertion or
  // removal of children requires restyling later siblings of that
  // element.  Additionally (in this manner it is stronger than
  // NODE_HAS_SLOW_SELECTOR), if a child's style changes due to any
  // other content tree changes (e.g., the child changes to or from
  // matching :empty due to a grandchild insertion or removal), the
  // child's later siblings must also be restyled.
  NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS = NODE_FLAG_BIT(13),

  NODE_ALL_SELECTOR_FLAGS = NODE_HAS_EMPTY_SELECTOR | NODE_HAS_SLOW_SELECTOR |
                            NODE_HAS_EDGE_CHILD_SELECTOR |
                            NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS,

  // This node needs to go through frame construction to get a frame (or
  // undisplayed entry).
  NODE_NEEDS_FRAME = NODE_FLAG_BIT(14),

  // At least one descendant in the flattened tree has NODE_NEEDS_FRAME set.
  // This should be set on every node on the flattened tree path between the
  // node(s) with NODE_NEEDS_FRAME and the root content.
  NODE_DESCENDANTS_NEED_FRAMES = NODE_FLAG_BIT(15),

  // Set if the node has the accesskey attribute set.
  NODE_HAS_ACCESSKEY = NODE_FLAG_BIT(16),

  // Set if the node has right-to-left directionality
  NODE_HAS_DIRECTION_RTL = NODE_FLAG_BIT(17),

  // Set if the node has left-to-right directionality
  NODE_HAS_DIRECTION_LTR = NODE_FLAG_BIT(18),

  NODE_ALL_DIRECTION_FLAGS = NODE_HAS_DIRECTION_LTR | NODE_HAS_DIRECTION_RTL,

  NODE_CHROME_ONLY_ACCESS = NODE_FLAG_BIT(19),

  NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS = NODE_FLAG_BIT(20),

  // Remaining bits are node type specific.
  NODE_TYPE_SPECIFIC_BITS_OFFSET = 21
};

// Make sure we have space for our bits
#define ASSERT_NODE_FLAGS_SPACE(n)                         \
  static_assert(WRAPPER_CACHE_FLAGS_BITS_USED + (n) <=     \
                    sizeof(nsWrapperCache::FlagsType) * 8, \
                "Not enough space for our bits")
ASSERT_NODE_FLAGS_SPACE(NODE_TYPE_SPECIFIC_BITS_OFFSET);

/**
 * Class used to detect unexpected mutations. To use the class create an
 * nsMutationGuard on the stack before unexpected mutations could occur.
 * You can then at any time call Mutated to check if any unexpected mutations
 * have occurred.
 */
class nsMutationGuard {
 public:
  nsMutationGuard() { mStartingGeneration = sGeneration; }

  /**
   * Returns true if any unexpected mutations have occurred. You can pass in
   * an 8-bit ignore count to ignore a number of expected mutations.
   *
   * We don't need to care about overflow because subtraction of uint64_t's is
   * finding the difference between two elements of the group Z < 2^64.  Once
   * we know the difference between two elements we only need to check that is
   * less than the given number of mutations to know less than that many
   * mutations occured.  Assuming constant 1ns mutations it would take 584
   * years for sGeneration to fully wrap around so we can ignore a guard living
   * through a full wrap around.
   */
  bool Mutated(uint8_t aIgnoreCount) {
    return (sGeneration - mStartingGeneration) > aIgnoreCount;
  }

  // This function should be called whenever a mutation that we want to keep
  // track of happen. For now this is only done when children are added or
  // removed, but we might do it for attribute changes too in the future.
  static void DidMutate() { sGeneration++; }

 private:
  // This is the value sGeneration had when the guard was constructed.
  uint64_t mStartingGeneration;

  // This value is incremented on every mutation, for the life of the process.
  static uint64_t sGeneration;
};

// This should be used for any nsINode sub-class that has fields of its own
// that it needs to measure; any sub-class that doesn't use it will inherit
// AddSizeOfExcludingThis from its super-class. AddSizeOfIncludingThis() need
// not be defined, it is inherited from nsINode.
#define NS_DECL_ADDSIZEOFEXCLUDINGTHIS                       \
  virtual void AddSizeOfExcludingThis(nsWindowSizes& aSizes, \
                                      size_t* aNodeSize) const override;

// Categories of node properties
// 0 is global.
#define DOM_USER_DATA 1

// IID for the nsINode interface
// Must be kept in sync with xpcom/rust/xpcom/src/interfaces/nonidl.rs
#define NS_INODE_IID                                 \
  {                                                  \
    0x70ba4547, 0x7699, 0x44fc, {                    \
      0xb3, 0x20, 0x52, 0xdb, 0xe3, 0xd1, 0xf9, 0x0a \
    }                                                \
  }

/**
 * An internal interface that abstracts some DOMNode-related parts that both
 * nsIContent and nsIDocument share.  An instance of this interface has a list
 * of nsIContent children and provides access to them.
 */
class nsINode : public mozilla::dom::EventTarget {
 public:
  typedef mozilla::dom::BoxQuadOptions BoxQuadOptions;
  typedef mozilla::dom::ConvertCoordinateOptions ConvertCoordinateOptions;
  typedef mozilla::dom::DocGroup DocGroup;
  typedef mozilla::dom::DOMPoint DOMPoint;
  typedef mozilla::dom::DOMPointInit DOMPointInit;
  typedef mozilla::dom::DOMQuad DOMQuad;
  typedef mozilla::dom::DOMRectReadOnly DOMRectReadOnly;
  typedef mozilla::dom::OwningNodeOrString OwningNodeOrString;
  typedef mozilla::dom::TextOrElementOrDocument TextOrElementOrDocument;
  typedef mozilla::dom::CallerType CallerType;
  typedef mozilla::ErrorResult ErrorResult;

  // XXXbz Maybe we should codegen a class holding these constants and
  // inherit from it...
  static const auto ELEMENT_NODE = mozilla::dom::NodeBinding::ELEMENT_NODE;
  static const auto ATTRIBUTE_NODE = mozilla::dom::NodeBinding::ATTRIBUTE_NODE;
  static const auto TEXT_NODE = mozilla::dom::NodeBinding::TEXT_NODE;
  static const auto CDATA_SECTION_NODE =
      mozilla::dom::NodeBinding::CDATA_SECTION_NODE;
  static const auto ENTITY_REFERENCE_NODE =
      mozilla::dom::NodeBinding::ENTITY_REFERENCE_NODE;
  static const auto ENTITY_NODE = mozilla::dom::NodeBinding::ENTITY_NODE;
  static const auto PROCESSING_INSTRUCTION_NODE =
      mozilla::dom::NodeBinding::PROCESSING_INSTRUCTION_NODE;
  static const auto COMMENT_NODE = mozilla::dom::NodeBinding::COMMENT_NODE;
  static const auto DOCUMENT_NODE = mozilla::dom::NodeBinding::DOCUMENT_NODE;
  static const auto DOCUMENT_TYPE_NODE =
      mozilla::dom::NodeBinding::DOCUMENT_TYPE_NODE;
  static const auto DOCUMENT_FRAGMENT_NODE =
      mozilla::dom::NodeBinding::DOCUMENT_FRAGMENT_NODE;
  static const auto NOTATION_NODE = mozilla::dom::NodeBinding::NOTATION_NODE;

  template <class T>
  using Sequence = mozilla::dom::Sequence<T>;

  NS_DECLARE_STATIC_IID_ACCESSOR(NS_INODE_IID)

  // The |aNodeSize| outparam on this function is where the actual node size
  // value is put. It gets added to the appropriate value within |aSizes| by
  // AddSizeOfNodeTree().
  //
  // Among the sub-classes that inherit (directly or indirectly) from nsINode,
  // measurement of the following members may be added later if DMD finds it is
  // worthwhile:
  // - nsGenericHTMLElement:  mForm, mFieldSet
  // - nsGenericHTMLFrameElement: mFrameLoader (bug 672539)
  // - HTMLBodyElement:       mContentStyleRule
  // - HTMLDataListElement:   mOptions
  // - HTMLFieldSetElement:   mElements, mDependentElements, mFirstLegend
  // - HTMLFormElement:       many!
  // - HTMLFrameSetElement:   mRowSpecs, mColSpecs
  // - HTMLInputElement:      mInputData, mFiles, mFileList, mStaticDocfileList
  // - nsHTMLMapElement:      mAreas
  // - HTMLMediaElement:      many!
  // - nsHTMLOutputElement:   mDefaultValue, mTokenList
  // - nsHTMLRowElement:      mCells
  // - nsHTMLSelectElement:   mOptions, mRestoreState
  // - nsHTMLTableElement:    mTBodies, mRows, mTableInheritedAttributes
  // - nsHTMLTableSectionElement: mRows
  // - nsHTMLTextAreaElement: mControllers, mState
  //
  // The following members don't need to be measured:
  // - nsIContent: mPrimaryFrame, because it's non-owning and measured elsewhere
  //
  virtual void AddSizeOfExcludingThis(nsWindowSizes& aSizes,
                                      size_t* aNodeSize) const;

  // SizeOfIncludingThis doesn't need to be overridden by sub-classes because
  // sub-classes of nsINode are guaranteed to be laid out in memory in such a
  // way that |this| points to the start of the allocated object, even in
  // methods of nsINode's sub-classes, so aSizes.mState.mMallocSizeOf(this) is
  // always safe to call no matter which object it was invoked on.
  virtual void AddSizeOfIncludingThis(nsWindowSizes& aSizes,
                                      size_t* aNodeSize) const {
    *aNodeSize += aSizes.mState.mMallocSizeOf(this);
    AddSizeOfExcludingThis(aSizes, aNodeSize);
  }

  friend class nsNodeUtils;
  friend class nsNodeWeakReference;
  friend class nsNodeSupportsWeakRefTearoff;
  friend class nsAttrAndChildArray;

#ifdef MOZILLA_INTERNAL_API
  explicit nsINode(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
      : mNodeInfo(aNodeInfo),
        mParent(nullptr)
#ifndef BOOL_FLAGS_ON_WRAPPER_CACHE
        ,
        mBoolFlags(0)
#endif
        ,
        mNextSibling(nullptr),
        mPreviousSibling(nullptr),
        mFirstChild(nullptr),
        mSubtreeRoot(this),
        mSlots(nullptr) {
  }
#endif

  virtual ~nsINode();

  /**
   * Bit-flags to pass (or'ed together) to IsNodeOfType()
   */
  enum {
    /** nsIDocument nodes */
    eDOCUMENT = 1 << 1,
    /** nsIAttribute nodes */
    eATTRIBUTE = 1 << 2,
    /** text nodes */
    eTEXT = 1 << 3,
    /** xml processing instructions */
    ePROCESSING_INSTRUCTION = 1 << 4,
    /** comment nodes */
    eCOMMENT = 1 << 5,
    /** form control elements */
    eHTML_FORM_CONTROL = 1 << 6,
    /** document fragments */
    eDOCUMENT_FRAGMENT = 1 << 7,
    /** data nodes (comments, PIs, text). Nodes of this type always
     returns a non-null value for nsIContent::GetText() */
    eDATA_NODE = 1 << 8,
    /** HTMLMediaElement */
    eMEDIA = 1 << 9,
    /** animation elements */
    eANIMATION = 1 << 10,
    /** filter elements that implement SVGFilterPrimitiveStandardAttributes */
    eFILTER = 1 << 11
  };

  /**
   * API for doing a quick check if a content is of a given
   * type, such as Text, Document, Comment ...  Use this when you can instead of
   * checking the tag.
   *
   * @param aFlags what types you want to test for (see above)
   * @return whether the content matches ALL flags passed in
   */
  virtual bool IsNodeOfType(uint32_t aFlags) const = 0;

  bool IsContainerNode() const {
    return IsElement() ||
           !(IsNodeOfType(eTEXT) || IsNodeOfType(ePROCESSING_INSTRUCTION) ||
             IsNodeOfType(eCOMMENT) || IsNodeOfType(eDATA_NODE));
  }

  bool IsSlotable() const { return IsElement() || IsNodeOfType(eTEXT); }

  virtual JSObject* WrapObject(JSContext* aCx,
                               JS::Handle<JSObject*> aGivenProto) override;

  /**
   * returns true if we are in priviliged code or
   * layout.css.getBoxQuads.enabled == true.
   */
  static bool HasBoxQuadsSupport(JSContext* aCx, JSObject* /* unused */);

 protected:
  /**
   * WrapNode is called from WrapObject to actually wrap this node, WrapObject
   * does some additional checks and fix-up that's common to all nodes. WrapNode
   * should just call the DOM binding's Wrap function.
   *
   * aGivenProto is the prototype to use (or null if the default one should be
   * used) and should just be passed directly on to the DOM binding's Wrap
   * function.
   */
  virtual JSObject* WrapNode(JSContext* aCx,
                             JS::Handle<JSObject*> aGivenProto) = 0;

 public:
  mozilla::dom::ParentObject GetParentObject()
      const;  // Implemented in nsIDocument.h

  /**
   * Return the scope chain parent for this node, for use in things
   * like event handler compilation.  Returning null means to use the
   * global object as the scope chain parent.
   */
  virtual nsINode* GetScopeChainParent() const;

  /**
   * Return whether the node is an Element node
   */
  bool IsElement() const { return GetBoolFlag(NodeIsElement); }

  /**
   * Return this node as an Element.  Should only be used for nodes
   * for which IsElement() is true.  This is defined inline in Element.h.
   */
  mozilla::dom::Element* AsElement();
  const mozilla::dom::Element* AsElement() const;

  /**
   * Return this node as nsIContent.  Should only be used for nodes for which
   * IsContent() is true.  This is defined inline in nsIContent.h.
   */
  nsIContent* AsContent();
  const nsIContent* AsContent() const {
    return const_cast<nsINode*>(this)->AsContent();
  }

  /**
   * Return this node as Text if it is one, otherwise null.  This is defined
   * inline in Text.h.
   */
  mozilla::dom::Text* GetAsText();
  const mozilla::dom::Text* GetAsText() const;

  virtual nsIDOMNode* AsDOMNode() = 0;

  /**
   * Return if this node has any children.
   */
  bool HasChildren() const { return !!mFirstChild; }

  /**
   * Get the number of children
   * @return the number of children
   */
  virtual uint32_t GetChildCount() const = 0;

  /**
   * NOTE: this function is going to be removed soon (hopefully!) Don't use it
   * in new code.
   *
   * Get a child by index
   * @param aIndex the index of the child to get
   * @return the child, or null if index out of bounds
   */
  virtual nsIContent* GetChildAt_Deprecated(uint32_t aIndex) const = 0;

  /**
   * Get the index of a child within this content
   * @param aPossibleChild the child to get the index of.
   * @return the index of the child, or -1 if not a child
   *
   * If the return value is not -1, then calling GetChildAt_Deprecated() with
   * that value will return aPossibleChild.
   */
  virtual int32_t ComputeIndexOf(const nsINode* aPossibleChild) const = 0;

  /**
   * Returns the "node document" of this node.
   *
   * https://dom.spec.whatwg.org/#concept-node-document
   *
   * Note that in the case that this node is a document node this method
   * will return |this|.  That is different to the Node.ownerDocument DOM
   * attribute (implemented by nsINode::GetOwnerDocument) which is specified to
   * be null in that case:
   *
   * https://dom.spec.whatwg.org/#dom-node-ownerdocument
   *
   * For all other cases OwnerDoc and GetOwnerDocument behave identically.
   */
  nsIDocument* OwnerDoc() const { return mNodeInfo->GetDocument(); }

  /**
   * Return the "owner document" of this node as an nsINode*.  Implemented
   * in nsIDocument.h.
   */
  inline nsINode* OwnerDocAsNode() const;

  /**
   * Returns true if the content has an ancestor that is a document.
   *
   * @return whether this content is in a document tree
   */
  bool IsInUncomposedDoc() const { return GetBoolFlag(IsInDocument); }

  /**
   * Get the document that this content is currently in, if any. This will be
   * null if the content has no ancestor that is a document.
   *
   * @return the current document
   */

  nsIDocument* GetUncomposedDoc() const {
    return IsInUncomposedDoc() ? OwnerDoc() : nullptr;
  }

  /**
   * This method returns the owner doc if the node is in the
   * composed document (as defined in the Shadow DOM spec), otherwise
   * it returns null.
   */
  nsIDocument* GetComposedDoc() const {
    return IsInShadowTree() ? GetComposedDocInternal() : GetUncomposedDoc();
  }

  /**
   * Returns true if GetComposedDoc() would return a non-null value.
   */
  bool IsInComposedDoc() const {
    return IsInUncomposedDoc() ||
           (IsInShadowTree() && GetComposedDocInternal());
  }

  /**
   * The values returned by this function are the ones defined for
   * nsIDOMNode.nodeType
   */
  uint16_t NodeType() const { return mNodeInfo->NodeType(); }
  const nsString& NodeName() const { return mNodeInfo->NodeName(); }
  const nsString& LocalName() const { return mNodeInfo->LocalName(); }

  /**
   * Get the NodeInfo for this element
   * @return the nodes node info
   */
  inline mozilla::dom::NodeInfo* NodeInfo() const { return mNodeInfo; }

  inline bool IsInNamespace(int32_t aNamespace) const {
    return mNodeInfo->NamespaceID() == aNamespace;
  }

  /**
   * Returns the DocGroup of the "node document" of this node.
   */
  DocGroup* GetDocGroup() const;

  /**
   * Print a debugger friendly descriptor of this element. This will describe
   * the position of this element in the document.
   */
  friend std::ostream& operator<<(std::ostream& aStream, const nsINode& aNode);

 protected:
  // These 2 methods are useful for the recursive templates IsHTMLElement,
  // IsSVGElement, etc.
  inline bool IsNodeInternal() const { return false; }

  template <typename First, typename... Args>
  inline bool IsNodeInternal(First aFirst, Args... aArgs) const {
    return mNodeInfo->Equals(aFirst) || IsNodeInternal(aArgs...);
  }

 public:
  inline bool IsHTMLElement() const {
    return IsElement() && IsInNamespace(kNameSpaceID_XHTML);
  }

  inline bool IsHTMLElement(nsAtom* aTag) const {
    return IsElement() && mNodeInfo->Equals(aTag, kNameSpaceID_XHTML);
  }

  template <typename First, typename... Args>
  inline bool IsAnyOfHTMLElements(First aFirst, Args... aArgs) const {
    return IsHTMLElement() && IsNodeInternal(aFirst, aArgs...);
  }

  inline bool IsSVGElement() const {
    return IsElement() && IsInNamespace(kNameSpaceID_SVG);
  }

  inline bool IsSVGElement(nsAtom* aTag) const {
    return IsElement() && mNodeInfo->Equals(aTag, kNameSpaceID_SVG);
  }

  template <typename First, typename... Args>
  inline bool IsAnyOfSVGElements(First aFirst, Args... aArgs) const {
    return IsSVGElement() && IsNodeInternal(aFirst, aArgs...);
  }

  inline bool IsXULElement() const {
    return IsElement() && IsInNamespace(kNameSpaceID_XUL);
  }

  inline bool IsXULElement(nsAtom* aTag) const {
    return IsElement() && mNodeInfo->Equals(aTag, kNameSpaceID_XUL);
  }

  template <typename First, typename... Args>
  inline bool IsAnyOfXULElements(First aFirst, Args... aArgs) const {
    return IsXULElement() && IsNodeInternal(aFirst, aArgs...);
  }

  inline bool IsMathMLElement() const {
    return IsElement() && IsInNamespace(kNameSpaceID_MathML);
  }

  inline bool IsMathMLElement(nsAtom* aTag) const {
    return IsElement() && mNodeInfo->Equals(aTag, kNameSpaceID_MathML);
  }

  template <typename First, typename... Args>
  inline bool IsAnyOfMathMLElements(First aFirst, Args... aArgs) const {
    return IsMathMLElement() && IsNodeInternal(aFirst, aArgs...);
  }

  bool IsShadowRoot() const {
    const bool isShadowRoot = IsInShadowTree() && !GetParentNode();
    MOZ_ASSERT_IF(isShadowRoot, NodeType() == DOCUMENT_FRAGMENT_NODE);
    return isShadowRoot;
  }

  /**
   * Insert a content node before another or at the end.
   * This method handles calling BindToTree on the child appropriately.
   *
   * @param aKid the content to insert
   * @param aBeforeThis an existing node. Use nullptr if you want to
   *        add aKid at the end.
   * @param aNotify whether to notify the document (current document for
   *        nsIContent, and |this| for nsIDocument) that the insert has
   *        occurred
   *
   * @throws NS_ERROR_DOM_HIERARCHY_REQUEST_ERR if one attempts to have more
   * than one element node as a child of a document.  Doing this will also
   * assert -- you shouldn't be doing it!  Check with
   * nsIDocument::GetRootElement() first if you're not sure.  Apart from this
   * one constraint, this doesn't do any checking on whether aKid is a valid
   * child of |this|.
   *
   * @throws NS_ERROR_OUT_OF_MEMORY in some cases (from BindToTree).
   */
  virtual nsresult InsertChildBefore(nsIContent* aKid, nsIContent* aBeforeThis,
                                     bool aNotify) = 0;

  /**
   * Insert a content node at a particular index.  This method handles calling
   * BindToTree on the child appropriately.
   *
   * @param aKid the content to insert
   * @param aIndex the index it is being inserted at (the index it will have
   *        after it is inserted)
   * @param aNotify whether to notify the document (current document for
   *        nsIContent, and |this| for nsIDocument) that the insert has
   *        occurred
   *
   * @throws NS_ERROR_DOM_HIERARCHY_REQUEST_ERR if one attempts to have more
   * than one element node as a child of a document.  Doing this will also
   * assert -- you shouldn't be doing it!  Check with
   * nsIDocument::GetRootElement() first if you're not sure.  Apart from this
   * one constraint, this doesn't do any checking on whether aKid is a valid
   * child of |this|.
   *
   * @throws NS_ERROR_OUT_OF_MEMORY in some cases (from BindToTree).
   */
  virtual nsresult InsertChildAt_Deprecated(nsIContent* aKid, uint32_t aIndex,
                                            bool aNotify) = 0;

  /**
   * Append a content node to the end of the child list.  This method handles
   * calling BindToTree on the child appropriately.
   *
   * @param aKid the content to append
   * @param aNotify whether to notify the document (current document for
   *        nsIContent, and |this| for nsIDocument) that the append has
   *        occurred
   *
   * @throws NS_ERROR_DOM_HIERARCHY_REQUEST_ERR if one attempts to have more
   * than one element node as a child of a document.  Doing this will also
   * assert -- you shouldn't be doing it!  Check with
   * nsIDocument::GetRootElement() first if you're not sure.  Apart from this
   * one constraint, this doesn't do any checking on whether aKid is a valid
   * child of |this|.
   *
   * @throws NS_ERROR_OUT_OF_MEMORY in some cases (from BindToTree).
   */
  nsresult AppendChildTo(nsIContent* aKid, bool aNotify) {
    return InsertChildAt_Deprecated(aKid, GetChildCount(), aNotify);
  }

  /**
   * NOTE: this function is going to be removed soon (hopefully!) Don't use it
   * in new code.
   *
   * Remove a child from this node.  This method handles calling UnbindFromTree
   * on the child appropriately.
   *
   * @param aIndex the index of the child to remove
   * @param aNotify whether to notify the document (current document for
   *        nsIContent, and |this| for nsIDocument) that the remove has
   *        occurred
   *
   * Note: If there is no child at aIndex, this method will simply do nothing.
   */
  virtual void RemoveChildAt_Deprecated(uint32_t aIndex, bool aNotify) = 0;

  /**
   * Remove a child from this node.  This method handles calling UnbindFromTree
   * on the child appropriately.
   *
   * @param aKid the content to remove
   * @param aNotify whether to notify the document (current document for
   *        nsIContent, and |this| for nsIDocument) that the remove has
   *        occurred
   */
  virtual void RemoveChildNode(nsIContent* aKid, bool aNotify) = 0;

  /**
   * Get a property associated with this node.
   *
   * @param aPropertyName  name of property to get.
   * @param aStatus        out parameter for storing resulting status.
   *                       Set to NS_PROPTABLE_PROP_NOT_THERE if the property
   *                       is not set.
   * @return               the property. Null if the property is not set
   *                       (though a null return value does not imply the
   *                       property was not set, i.e. it can be set to null).
   */
  void* GetProperty(nsAtom* aPropertyName, nsresult* aStatus = nullptr) const {
    return GetProperty(0, aPropertyName, aStatus);
  }

  /**
   * Get a property associated with this node.
   *
   * @param aCategory      category of property to get.
   * @param aPropertyName  name of property to get.
   * @param aStatus        out parameter for storing resulting status.
   *                       Set to NS_PROPTABLE_PROP_NOT_THERE if the property
   *                       is not set.
   * @return               the property. Null if the property is not set
   *                       (though a null return value does not imply the
   *                       property was not set, i.e. it can be set to null).
   */
  void* GetProperty(uint16_t aCategory, nsAtom* aPropertyName,
                    nsresult* aStatus = nullptr) const;

  /**
   * Set a property to be associated with this node. This will overwrite an
   * existing value if one exists. The existing value is destroyed using the
   * destructor function given when that value was set.
   *
   * @param aPropertyName  name of property to set.
   * @param aValue         new value of property.
   * @param aDtor          destructor function to be used when this property
   *                       is destroyed.
   * @param aTransfer      if true the property will not be deleted when the
   *                       ownerDocument of the node changes, if false it
   *                       will be deleted.
   *
   * @return NS_PROPTABLE_PROP_OVERWRITTEN (success value) if the property
   *                                       was already set
   * @throws NS_ERROR_OUT_OF_MEMORY if that occurs
   */
  nsresult SetProperty(nsAtom* aPropertyName, void* aValue,
                       NSPropertyDtorFunc aDtor = nullptr,
                       bool aTransfer = false) {
    return SetProperty(0, aPropertyName, aValue, aDtor, aTransfer);
  }

  /**
   * Set a property to be associated with this node. This will overwrite an
   * existing value if one exists. The existing value is destroyed using the
   * destructor function given when that value was set.
   *
   * @param aCategory       category of property to set.
   * @param aPropertyName   name of property to set.
   * @param aValue          new value of property.
   * @param aDtor           destructor function to be used when this property
   *                        is destroyed.
   * @param aTransfer       if true the property will not be deleted when the
   *                        ownerDocument of the node changes, if false it
   *                        will be deleted.
   * @param aOldValue [out] previous value of property.
   *
   * @return NS_PROPTABLE_PROP_OVERWRITTEN (success value) if the property
   *                                       was already set
   * @throws NS_ERROR_OUT_OF_MEMORY if that occurs
   */
  nsresult SetProperty(uint16_t aCategory, nsAtom* aPropertyName, void* aValue,
                       NSPropertyDtorFunc aDtor = nullptr,
                       bool aTransfer = false, void** aOldValue = nullptr);

  /**
   * A generic destructor for property values allocated with new.
   */
  template <class T>
  static void DeleteProperty(void*, nsAtom*, void* aPropertyValue, void*) {
    delete static_cast<T*>(aPropertyValue);
  }

  /**
   * Destroys a property associated with this node. The value is destroyed
   * using the destruction function given when that value was set.
   *
   * @param aPropertyName  name of property to destroy.
   */
  void DeleteProperty(nsAtom* aPropertyName) {
    DeleteProperty(0, aPropertyName);
  }

  /**
   * Destroys a property associated with this node. The value is destroyed
   * using the destruction function given when that value was set.
   *
   * @param aCategory      category of property to destroy.
   * @param aPropertyName  name of property to destroy.
   */
  void DeleteProperty(uint16_t aCategory, nsAtom* aPropertyName);

  /**
   * Unset a property associated with this node. The value will not be
   * destroyed but rather returned. It is the caller's responsibility to
   * destroy the value after that point.
   *
   * @param aPropertyName  name of property to unset.
   * @param aStatus        out parameter for storing resulting status.
   *                       Set to NS_PROPTABLE_PROP_NOT_THERE if the property
   *                       is not set.
   * @return               the property. Null if the property is not set
   *                       (though a null return value does not imply the
   *                       property was not set, i.e. it can be set to null).
   */
  void* UnsetProperty(nsAtom* aPropertyName, nsresult* aStatus = nullptr) {
    return UnsetProperty(0, aPropertyName, aStatus);
  }

  /**
   * Unset a property associated with this node. The value will not be
   * destroyed but rather returned. It is the caller's responsibility to
   * destroy the value after that point.
   *
   * @param aCategory      category of property to unset.
   * @param aPropertyName  name of property to unset.
   * @param aStatus        out parameter for storing resulting status.
   *                       Set to NS_PROPTABLE_PROP_NOT_THERE if the property
   *                       is not set.
   * @return               the property. Null if the property is not set
   *                       (though a null return value does not imply the
   *                       property was not set, i.e. it can be set to null).
   */
  void* UnsetProperty(uint16_t aCategory, nsAtom* aPropertyName,
                      nsresult* aStatus = nullptr);

  bool HasProperties() const { return HasFlag(NODE_HAS_PROPERTIES); }

  /**
   * Return the principal of this node.  This is guaranteed to never be a null
   * pointer.
   */
  nsIPrincipal* NodePrincipal() const {
    return mNodeInfo->NodeInfoManager()->DocumentPrincipal();
  }

  /**
   * Get the parent nsIContent for this node.
   * @return the parent, or null if no parent or the parent is not an nsIContent
   */
  nsIContent* GetParent() const {
    return MOZ_LIKELY(GetBoolFlag(ParentIsContent))
               ? reinterpret_cast<nsIContent*>(mParent)
               : nullptr;
  }

  /**
   * Get the parent nsINode for this node. This can be either an nsIContent,
   * an nsIDocument or an nsIAttribute.
   * @return the parent node
   */
  nsINode* GetParentNode() const { return mParent; }

  /**
   * This is similar to above, but in case 'this' is ShadowRoot, we return its
   * host element.
   */
  nsINode* GetParentOrHostNode() const;

  enum FlattenedParentType { eNotForStyle, eForStyle };

  /**
   * Returns the node that is the parent of this node in the flattened
   * tree. This differs from the normal parent if the node is filtered
   * into an insertion point, or if the node is a direct child of a
   * shadow root.
   *
   * @return the flattened tree parent
   */
  inline nsINode* GetFlattenedTreeParentNode() const;

  /**
   * Like GetFlattenedTreeParentNode, but returns the document for any native
   * anonymous content that was generated for ancestor frames of the document
   * element's primary frame, such as scrollbar elements created by the root
   * scroll frame.
   */
  inline nsINode* GetFlattenedTreeParentNodeForStyle() const;

  inline mozilla::dom::Element* GetFlattenedTreeParentElement() const;
  inline mozilla::dom::Element* GetFlattenedTreeParentElementForStyle() const;

  /**
   * Get the parent nsINode for this node if it is an Element.
   * @return the parent node
   */
  mozilla::dom::Element* GetParentElement() const {
    return mParent && mParent->IsElement() ? mParent->AsElement() : nullptr;
  }

  /**
   * Get the parent Element of this node, traversing over a ShadowRoot
   * to its host if necessary.
   */
  mozilla::dom::Element* GetParentElementCrossingShadowRoot() const;

  /**
   * Get the root of the subtree this node belongs to.  This never returns
   * null.  It may return 'this' (e.g. for document nodes, and nodes that
   * are the roots of disconnected subtrees).
   */
  nsINode* SubtreeRoot() const;

  /*
   * Get context object's shadow-including root if options's composed is true,
   * and context object's root otherwise.
   */
  nsINode* GetRootNode(const mozilla::dom::GetRootNodeOptions& aOptions);

  /**
   * See nsIDOMEventTarget
   */
  NS_DECL_NSIDOMEVENTTARGET

  virtual mozilla::EventListenerManager* GetExistingListenerManager()
      const override;
  virtual mozilla::EventListenerManager* GetOrCreateListenerManager() override;

  using mozilla::dom::EventTarget::RemoveEventListener;
  using nsIDOMEventTarget::AddEventListener;
  virtual void AddEventListener(
      const nsAString& aType, mozilla::dom::EventListener* aListener,
      const mozilla::dom::AddEventListenerOptionsOrBoolean& aOptions,
      const mozilla::dom::Nullable<bool>& aWantsUntrusted,
      mozilla::ErrorResult& aRv) override;
  using nsIDOMEventTarget::AddSystemEventListener;

  virtual bool IsApzAware() const override;

  virtual nsPIDOMWindowOuter* GetOwnerGlobalForBindings() override;
  virtual nsIGlobalObject* GetOwnerGlobal() const override;

  /**
   * Returns true if this is a node belonging to a document that uses the Servo
   * style system.
   */
#ifdef MOZ_STYLO
  bool IsStyledByServo() const;
#else
  bool IsStyledByServo() const { return false; }
#endif

  inline void UnsetRestyleFlagsIfGecko();

  /**
   * Adds a mutation observer to be notified when this node, or any of its
   * descendants, are modified. The node will hold a weak reference to the
   * observer, which means that it is the responsibility of the observer to
   * remove itself in case it dies before the node.  If an observer is added
   * while observers are being notified, it may also be notified.  In general,
   * adding observers while inside a notification is not a good idea.  An
   * observer that is already observing the node must not be added without
   * being removed first.
   *
   * For mutation observers that implement nsIAnimationObserver, use
   * AddAnimationObserver instead.
   */
  void AddMutationObserver(nsIMutationObserver* aMutationObserver) {
    nsSlots* s = Slots();
    NS_ASSERTION(s->mMutationObservers.IndexOf(aMutationObserver) ==
                     nsTArray<int>::NoIndex,
                 "Observer already in the list");
    s->mMutationObservers.AppendElement(aMutationObserver);
  }

  /**
   * Same as above, but only adds the observer if its not observing
   * the node already.
   *
   * For mutation observers that implement nsIAnimationObserver, use
   * AddAnimationObserverUnlessExists instead.
   */
  void AddMutationObserverUnlessExists(nsIMutationObserver* aMutationObserver) {
    nsSlots* s = Slots();
    s->mMutationObservers.AppendElementUnlessExists(aMutationObserver);
  }

  /**
   * Same as AddMutationObserver, but for nsIAnimationObservers.  This
   * additionally records on the document that animation observers have
   * been registered, which is used to determine whether notifications
   * must be fired when animations are added, removed or changed.
   */
  void AddAnimationObserver(nsIAnimationObserver* aAnimationObserver);

  /**
   * Same as above, but only adds the observer if its not observing
   * the node already.
   */
  void AddAnimationObserverUnlessExists(
      nsIAnimationObserver* aAnimationObserver);

  /**
   * Removes a mutation observer.
   */
  void RemoveMutationObserver(nsIMutationObserver* aMutationObserver) {
    nsSlots* s = GetExistingSlots();
    if (s) {
      s->mMutationObservers.RemoveElement(aMutationObserver);
    }
  }

  /**
   * Clones this node. This needs to be overriden by all node classes. aNodeInfo
   * should be identical to this node's nodeInfo, except for the document which
   * may be different. When cloning an element, all attributes of the element
   * will be cloned. The children of the node will not be cloned.
   *
   * @param aNodeInfo the nodeinfo to use for the clone
   * @param aResult the clone
   * @param aPreallocateChildren If true, the array of children will be
   *                             preallocated in preparation for a deep copy.
   */
  virtual nsresult Clone(mozilla::dom::NodeInfo* aNodeInfo, nsINode** aResult,
                         bool aPreallocateChildren) const = 0;

  // This class can be extended by subclasses that wish to store more
  // information in the slots.
  class nsSlots {
   public:
    nsSlots();

    // If needed we could remove the vtable pointer this dtor causes by
    // putting a DestroySlots function on nsINode
    virtual ~nsSlots();

    virtual void Traverse(nsCycleCollectionTraversalCallback&);
    virtual void Unlink();

    /**
     * A list of mutation observers
     */
    nsAutoTObserverArray<nsIMutationObserver*, 1> mMutationObservers;

    /**
     * An object implementing nsIDOMNodeList for this content (childNodes)
     * @see nsIDOMNodeList
     * @see nsGenericHTMLElement::GetChildNodes
     */
    RefPtr<nsAttrChildContentList> mChildNodes;

    /**
     * Weak reference to this node.  This is cleared by the destructor of
     * nsNodeWeakReference.
     */
    nsNodeWeakReference* MOZ_NON_OWNING_REF mWeakReference;

    /**
     * A set of ranges which are in the selection and which have this node as
     * their endpoints' common ancestor.  This is a UniquePtr instead of just a
     * LinkedList, because that prevents us from pushing DOMSlots up to the next
     * allocation bucket size, at the cost of some complexity.
     */
    mozilla::UniquePtr<mozilla::LinkedList<nsRange>> mCommonAncestorRanges;

    /**
     * Number of descendant nodes in the uncomposed document that have been
     * explicitly set as editable.
     */
    uint32_t mEditableDescendantCount;
  };

  /**
   * Functions for managing flags and slots
   */
#ifdef DEBUG
  nsSlots* DebugGetSlots() { return Slots(); }
#endif

  void SetFlags(FlagsType aFlagsToSet) {
    NS_ASSERTION(
        !(aFlagsToSet &
          (NODE_IS_ANONYMOUS_ROOT | NODE_IS_NATIVE_ANONYMOUS_ROOT |
           NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE | NODE_DESCENDANTS_NEED_FRAMES |
           NODE_NEEDS_FRAME | NODE_CHROME_ONLY_ACCESS)) ||
            IsContent(),
        "Flag only permitted on nsIContent nodes");
    nsWrapperCache::SetFlags(aFlagsToSet);
  }

  void UnsetFlags(FlagsType aFlagsToUnset) {
    NS_ASSERTION(!(aFlagsToUnset & (NODE_IS_ANONYMOUS_ROOT |
                                    NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE |
                                    NODE_IS_NATIVE_ANONYMOUS_ROOT)),
                 "Trying to unset write-only flags");
    nsWrapperCache::UnsetFlags(aFlagsToUnset);
  }

  void ChangeEditableDescendantCount(int32_t aDelta);

  /**
   * Returns the count of descendant nodes in the uncomposed
   * document that are explicitly set as editable.
   */
  uint32_t EditableDescendantCount();

  /**
   * Sets the editable descendant count to 0. The editable
   * descendant count only counts explicitly editable nodes
   * that are in the uncomposed document so this method
   * should be called when nodes are are removed from it.
   */
  void ResetEditableDescendantCount();

  void SetEditableFlag(bool aEditable) {
    if (aEditable) {
      SetFlags(NODE_IS_EDITABLE);
    } else {
      UnsetFlags(NODE_IS_EDITABLE);
    }
  }

  bool IsEditable() const {
#ifdef MOZILLA_INTERNAL_API
    return IsEditableInternal();
#else
    return IsEditableExternal();
#endif
  }

  /**
   * Returns true if |this| is native anonymous (i.e. created by
   * nsIAnonymousContentCreator);
   */
  bool IsNativeAnonymous() const { return HasFlag(NODE_IS_NATIVE_ANONYMOUS); }

  /**
   * Returns true if |this| or any of its ancestors is native anonymous.
   */
  bool IsInNativeAnonymousSubtree() const {
#ifdef DEBUG
    if (HasFlag(NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE)) {
      return true;
    }
    CheckNotNativeAnonymous();
    return false;
#else
    return HasFlag(NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE);
#endif
  }

  bool IsInAnonymousSubtree() const;

  // Note: This asserts |IsInAnonymousSubtree()|.
  bool IsAnonymousContentInSVGUseSubtree() const;

  // True for native anonymous content and for XBL content if the binding
  // has chromeOnlyContent="true".
  bool ChromeOnlyAccess() const {
    return HasFlag(NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE |
                   NODE_CHROME_ONLY_ACCESS);
  }

  bool IsInShadowTree() const { return HasFlag(NODE_IS_IN_SHADOW_TREE); }

  /**
   * Returns true if |this| node is the common ancestor of the start/end
   * nodes of a Range in a Selection or a descendant of such a common ancestor.
   * This node is definitely not selected when |false| is returned, but it may
   * or may not be selected when |true| is returned.
   */
  bool IsSelectionDescendant() const {
    return IsDescendantOfCommonAncestorForRangeInSelection() ||
           IsCommonAncestorForRangeInSelection();
  }

  /**
   * Get the root content of an editor. So, this node must be a descendant of
   * an editor. Note that this should be only used for getting input or textarea
   * editor's root content. This method doesn't support HTML editors.
   */
  nsIContent* GetTextEditorRootContent(
      mozilla::TextEditor** aTextEditor = nullptr);

  /**
   * Get the nearest selection root, ie. the node that will be selected if the
   * user does "Select All" while the focus is in this node. Note that if this
   * node is not in an editor, the result comes from the nsFrameSelection that
   * is related to aPresShell, so the result might not be the ancestor of this
   * node. Be aware that if this node and the computed selection limiter are
   * not in same subtree, this returns the root content of the closeset subtree.
   */
  nsIContent* GetSelectionRootContent(nsIPresShell* aPresShell);

  virtual nsINodeList* ChildNodes();
  nsIContent* GetFirstChild() const { return mFirstChild; }
  nsIContent* GetLastChild() const {
    uint32_t count = GetChildCount();

    return count > 0 ? GetChildAt_Deprecated(count - 1) : nullptr;
  }

  /**
   * Implementation is in nsIDocument.h, because it needs to cast from
   * nsIDocument* to nsINode*.
   */
  nsIDocument* GetOwnerDocument() const;

  void Normalize();

  /**
   * Get the base URI for any relative URIs within this piece of
   * content. Generally, this is the document's base URI, but certain
   * content carries a local base for backward compatibility, and XML
   * supports setting a per-node base URI.
   *
   * @return the base URI
   */
  virtual already_AddRefed<nsIURI> GetBaseURI(
      bool aTryUseXHRDocBaseURI = false) const = 0;
  already_AddRefed<nsIURI> GetBaseURIObject() const;

  /**
   * Return true if the node may be apz aware. There are two cases. One is that
   * the node is apz aware (such as HTMLInputElement with number type). The
   * other is that the node has apz aware listeners. This is a non-virtual
   * function which calls IsNodeApzAwareInternal only when the MayBeApzAware is
   * set. We check the details in IsNodeApzAwareInternal which may be overriden
   * by child classes
   */
  bool IsNodeApzAware() const {
    return NodeMayBeApzAware() ? IsNodeApzAwareInternal() : false;
  }

  /**
   * Override this function and set the flag MayBeApzAware in case the node has
   * to let APZC be aware of it. It's used when the node may handle the apz
   * aware events and may do preventDefault to stop APZC to do default actions.
   *
   * For example, instead of scrolling page by APZ, we handle mouse wheel event
   * in HTMLInputElement with number type as increasing / decreasing its value.
   */
  virtual bool IsNodeApzAwareInternal() const;

  // HTML elements named <shadow> may or may not be HTMLShadowElement.  This is
  // a way to ask an element whether it's an HTMLShadowElement.
  virtual bool IsHTMLShadowElement() const { return false; }

  // Elements named <content> may or may not be HTMLContentElement.  This is a
  // way to ask an element whether it's an HTMLContentElement.
  virtual bool IsHTMLContentElement() const { return false; }

  void GetTextContent(nsAString& aTextContent, mozilla::OOMReporter& aError) {
    GetTextContentInternal(aTextContent, aError);
  }
  void SetTextContent(const nsAString& aTextContent,
                      nsIPrincipal* aSubjectPrincipal,
                      mozilla::ErrorResult& aError) {
    SetTextContentInternal(aTextContent, aSubjectPrincipal, aError);
  }
  void SetTextContent(const nsAString& aTextContent,
                      mozilla::ErrorResult& aError) {
    SetTextContentInternal(aTextContent, nullptr, aError);
  }

  mozilla::dom::Element* QuerySelector(const nsAString& aSelector,
                                       mozilla::ErrorResult& aResult);
  already_AddRefed<nsINodeList> QuerySelectorAll(const nsAString& aSelector,
                                                 mozilla::ErrorResult& aResult);

 protected:
  // nsIDocument overrides this with its own (faster) version.  This
  // should really only be called for elements and document fragments.
  mozilla::dom::Element* GetElementById(const nsAString& aId);

  /**
   * Associate an object aData to aKey on this node. If aData is null any
   * previously registered object associated to aKey on this node will
   * be removed.
   * Should only be used to implement the DOM Level 3 UserData API.
   *
   * @param aKey the key to associate the object to
   * @param aData the object to associate to aKey on this node (may be null)
   * @param aResult [out] the previously registered object for aKey on this
   *                      node, if any
   * @return whether adding the object succeeded
   */
  nsresult SetUserData(const nsAString& aKey, nsIVariant* aData,
                       nsIVariant** aResult);

  /**
   * Get the UserData object registered for a Key on this node, if any.
   * Should only be used to implement the DOM Level 3 UserData API.
   *
   * @param aKey the key to get UserData for
   * @return aResult the previously registered object for aKey on this node, if
   *                 any
   */
  nsIVariant* GetUserData(const nsAString& aKey);

 public:
  void LookupPrefix(const nsAString& aNamespace, nsAString& aResult);
  bool IsDefaultNamespace(const nsAString& aNamespaceURI) {
    nsAutoString defaultNamespace;
    LookupNamespaceURI(EmptyString(), defaultNamespace);
    return aNamespaceURI.Equals(defaultNamespace);
  }
  void LookupNamespaceURI(const nsAString& aNamespacePrefix,
                          nsAString& aNamespaceURI);

  nsIContent* GetNextSibling() const { return mNextSibling; }
  nsIContent* GetPreviousSibling() const { return mPreviousSibling; }

  /**
   * Get the next node in the pre-order tree traversal of the DOM.  If
   * aRoot is non-null, then it must be an ancestor of |this|
   * (possibly equal to |this|) and only nodes that are descendants of
   * aRoot, not including aRoot itself, will be returned.  Returns
   * null if there are no more nodes to traverse.
   */
  nsIContent* GetNextNode(const nsINode* aRoot = nullptr) const {
    return GetNextNodeImpl(aRoot, false);
  }

  /**
   * Get the next node in the pre-order tree traversal of the DOM but ignoring
   * the children of this node.  If aRoot is non-null, then it must be an
   * ancestor of |this| (possibly equal to |this|) and only nodes that are
   * descendants of aRoot, not including aRoot itself, will be returned.
   * Returns null if there are no more nodes to traverse.
   */
  nsIContent* GetNextNonChildNode(const nsINode* aRoot = nullptr) const {
    return GetNextNodeImpl(aRoot, true);
  }

  /**
   * Returns true if 'this' is either document or element or
   * document fragment and aOther is a descendant in the same
   * anonymous tree.
   */
  bool Contains(const nsINode* aOther) const;

  bool UnoptimizableCCNode() const;

 private:
  nsIDocument* GetComposedDocInternal() const;

  nsIContent* GetNextNodeImpl(const nsINode* aRoot,
                              const bool aSkipChildren) const {
  // Can't use nsContentUtils::ContentIsDescendantOf here, since we
  // can't include it here.
#ifdef DEBUG
    if (aRoot) {
      const nsINode* cur = this;
      for (; cur; cur = cur->GetParentNode())
        if (cur == aRoot) break;
      NS_ASSERTION(cur, "aRoot not an ancestor of |this|?");
    }
#endif
    if (!aSkipChildren) {
      nsIContent* kid = GetFirstChild();
      if (kid) {
        return kid;
      }
    }
    if (this == aRoot) {
      return nullptr;
    }
    const nsINode* cur = this;
    while (1) {
      nsIContent* next = cur->GetNextSibling();
      if (next) {
        return next;
      }
      nsINode* parent = cur->GetParentNode();
      if (parent == aRoot) {
        return nullptr;
      }
      cur = parent;
    }
    NS_NOTREACHED("How did we get here?");
  }

 public:
  /**
   * Get the previous nsIContent in the pre-order tree traversal of the DOM.  If
   * aRoot is non-null, then it must be an ancestor of |this|
   * (possibly equal to |this|) and only nsIContents that are descendants of
   * aRoot, including aRoot itself, will be returned.  Returns
   * null if there are no more nsIContents to traverse.
   */
  nsIContent* GetPreviousContent(const nsINode* aRoot = nullptr) const {
  // Can't use nsContentUtils::ContentIsDescendantOf here, since we
  // can't include it here.
#ifdef DEBUG
    if (aRoot) {
      const nsINode* cur = this;
      for (; cur; cur = cur->GetParentNode())
        if (cur == aRoot) break;
      NS_ASSERTION(cur, "aRoot not an ancestor of |this|?");
    }
#endif

    if (this == aRoot) {
      return nullptr;
    }
    nsIContent* cur = this->GetParent();
    nsIContent* iter = this->GetPreviousSibling();
    while (iter) {
      cur = iter;
      iter = reinterpret_cast<nsINode*>(iter)->GetLastChild();
    }
    return cur;
  }

  /**
   * Boolean flags
   */
 private:
  enum BooleanFlag {
    // Set if we're being used from -moz-element
    NodeHasRenderingObservers,
    // Set if our parent chain (including this node itself) terminates
    // in a document
    IsInDocument,
    // Set if mParent is an nsIContent
    ParentIsContent,
    // Set if this node is an Element
    NodeIsElement,
    // Set if the element has a non-empty id attribute. This can in rare
    // cases lie for nsXMLElement, such as when the node has been moved between
    // documents with different id mappings.
    ElementHasID,
    // Set if the element might have a class.
    ElementMayHaveClass,
    // Set if the element might have inline style.
    ElementMayHaveStyle,
    // Set if the element has a name attribute set.
    ElementHasName,
    // Set if the element might have a contenteditable attribute set.
    ElementMayHaveContentEditableAttr,
    // Set if the node is the common ancestor of the start/end nodes of a Range
    // that is in a Selection.
    NodeIsCommonAncestorForRangeInSelection,
    // Set if the node is a descendant of a node with the above bit set.
    NodeIsDescendantOfCommonAncestorForRangeInSelection,
    // Set if CanSkipInCC check has been done for this subtree root.
    NodeIsCCMarkedRoot,
    // Maybe set if this node is in black subtree.
    NodeIsCCBlackTree,
    // Maybe set if the node is a root of a subtree
    // which needs to be kept in the purple buffer.
    NodeIsPurpleRoot,
    // Set if the element has some style states locked
    ElementHasLockedStyleStates,
    // Set if element has pointer locked
    ElementHasPointerLock,
    // Set if the node may have DOMMutationObserver attached to it.
    NodeMayHaveDOMMutationObserver,
    // Set if node is Content
    NodeIsContent,
    // Set if the node has animations or transitions
    ElementHasAnimations,
    // Set if node has a dir attribute with a valid value (ltr, rtl, or auto).
    // Note that we cannot compute this from the dir attribute event state
    // flags, because we can't use those to distinguish
    // <bdi dir="some-invalid-value"> and <bdi dir="auto">.
    NodeHasValidDirAttribute,
    // Set if the node has dir=auto and has a property pointing to the text
    // node that determines its direction
    NodeHasDirAutoSet,
    // Set if the node is a text node descendant of a node with dir=auto
    // and has a TextNodeDirectionalityMap property listing the elements whose
    // direction it determines.
    NodeHasTextNodeDirectionalityMap,
    // Set if a node in the node's parent chain has dir=auto.
    NodeAncestorHasDirAuto,
    // Set if the element is in the scope of a scoped style sheet; this flag is
    // only accurate for elements bound to a document
    ElementIsInStyleScope,
    // Set if the element is a scoped style sheet root
    ElementIsScopedStyleRoot,
    // Set if the node is handling a click.
    NodeHandlingClick,
    // Set if the node has had :hover selectors matched against it
    NodeHasRelevantHoverRules,
    // Set if the element has a parser insertion mode other than "in body",
    // per the HTML5 "Parse state" section.
    ElementHasWeirdParserInsertionMode,
    // Parser sets this flag if it has notified about the node.
    ParserHasNotified,
    // Sets if the node is apz aware or we have apz aware listeners.
    MayBeApzAware,
    // Set if the element might have any kind of anonymous content children,
    // which would not be found through the element's children list.
    ElementMayHaveAnonymousChildren,
    // Set if this node has at some point (and may still have)
    // display:none or display:contents children.
    NodeMayHaveChildrenWithLayoutBoxesDisabled,
    // Guard value
    BooleanFlagCount
  };

  void SetBoolFlag(BooleanFlag name, bool value) {
    static_assert(BooleanFlagCount <= 8 * sizeof(mBoolFlags),
                  "Too many boolean flags");
    mBoolFlags = (mBoolFlags & ~(1 << name)) | (value << name);
  }

  void SetBoolFlag(BooleanFlag name) {
    static_assert(BooleanFlagCount <= 8 * sizeof(mBoolFlags),
                  "Too many boolean flags");
    mBoolFlags |= (1 << name);
  }

  void ClearBoolFlag(BooleanFlag name) {
    static_assert(BooleanFlagCount <= 8 * sizeof(mBoolFlags),
                  "Too many boolean flags");
    mBoolFlags &= ~(1 << name);
  }

  bool GetBoolFlag(BooleanFlag name) const {
    static_assert(BooleanFlagCount <= 8 * sizeof(mBoolFlags),
                  "Too many boolean flags");
    return mBoolFlags & (1 << name);
  }

 public:
  bool HasRenderingObservers() const {
    return GetBoolFlag(NodeHasRenderingObservers);
  }
  void SetHasRenderingObservers(bool aValue) {
    SetBoolFlag(NodeHasRenderingObservers, aValue);
  }
  bool IsContent() const { return GetBoolFlag(NodeIsContent); }
  bool HasID() const { return GetBoolFlag(ElementHasID); }
  bool MayHaveClass() const { return GetBoolFlag(ElementMayHaveClass); }
  void SetMayHaveClass() { SetBoolFlag(ElementMayHaveClass); }
  bool MayHaveStyle() const { return GetBoolFlag(ElementMayHaveStyle); }
  bool HasName() const { return GetBoolFlag(ElementHasName); }
  bool MayHaveContentEditableAttr() const {
    return GetBoolFlag(ElementMayHaveContentEditableAttr);
  }
  bool IsCommonAncestorForRangeInSelection() const {
    return GetBoolFlag(NodeIsCommonAncestorForRangeInSelection);
  }
  void SetCommonAncestorForRangeInSelection() {
    SetBoolFlag(NodeIsCommonAncestorForRangeInSelection);
  }
  void ClearCommonAncestorForRangeInSelection() {
    ClearBoolFlag(NodeIsCommonAncestorForRangeInSelection);
  }
  bool IsDescendantOfCommonAncestorForRangeInSelection() const {
    return GetBoolFlag(NodeIsDescendantOfCommonAncestorForRangeInSelection);
  }
  void SetDescendantOfCommonAncestorForRangeInSelection() {
    SetBoolFlag(NodeIsDescendantOfCommonAncestorForRangeInSelection);
  }
  void ClearDescendantOfCommonAncestorForRangeInSelection() {
    ClearBoolFlag(NodeIsDescendantOfCommonAncestorForRangeInSelection);
  }

  void SetCCMarkedRoot(bool aValue) { SetBoolFlag(NodeIsCCMarkedRoot, aValue); }
  bool CCMarkedRoot() const { return GetBoolFlag(NodeIsCCMarkedRoot); }
  void SetInCCBlackTree(bool aValue) { SetBoolFlag(NodeIsCCBlackTree, aValue); }
  bool InCCBlackTree() const { return GetBoolFlag(NodeIsCCBlackTree); }
  void SetIsPurpleRoot(bool aValue) { SetBoolFlag(NodeIsPurpleRoot, aValue); }
  bool IsPurpleRoot() const { return GetBoolFlag(NodeIsPurpleRoot); }
  bool MayHaveDOMMutationObserver() {
    return GetBoolFlag(NodeMayHaveDOMMutationObserver);
  }
  void SetMayHaveDOMMutationObserver() {
    SetBoolFlag(NodeMayHaveDOMMutationObserver, true);
  }
  bool HasListenerManager() { return HasFlag(NODE_HAS_LISTENERMANAGER); }
  bool HasPointerLock() const { return GetBoolFlag(ElementHasPointerLock); }
  void SetPointerLock() { SetBoolFlag(ElementHasPointerLock); }
  void ClearPointerLock() { ClearBoolFlag(ElementHasPointerLock); }
  bool MayHaveAnimations() const { return GetBoolFlag(ElementHasAnimations); }
  void SetMayHaveAnimations() { SetBoolFlag(ElementHasAnimations); }
  void SetHasValidDir() { SetBoolFlag(NodeHasValidDirAttribute); }
  void ClearHasValidDir() { ClearBoolFlag(NodeHasValidDirAttribute); }
  bool HasValidDir() const { return GetBoolFlag(NodeHasValidDirAttribute); }
  void SetHasDirAutoSet() {
    MOZ_ASSERT(NodeType() != TEXT_NODE, "SetHasDirAutoSet on text node");
    SetBoolFlag(NodeHasDirAutoSet);
  }
  void ClearHasDirAutoSet() {
    MOZ_ASSERT(NodeType() != TEXT_NODE, "ClearHasDirAutoSet on text node");
    ClearBoolFlag(NodeHasDirAutoSet);
  }
  bool HasDirAutoSet() const { return GetBoolFlag(NodeHasDirAutoSet); }
  void SetHasTextNodeDirectionalityMap() {
    MOZ_ASSERT(NodeType() == TEXT_NODE,
               "SetHasTextNodeDirectionalityMap on non-text node");
    SetBoolFlag(NodeHasTextNodeDirectionalityMap);
  }
  void ClearHasTextNodeDirectionalityMap() {
    MOZ_ASSERT(NodeType() == TEXT_NODE,
               "ClearHasTextNodeDirectionalityMap on non-text node");
    ClearBoolFlag(NodeHasTextNodeDirectionalityMap);
  }
  bool HasTextNodeDirectionalityMap() const {
    MOZ_ASSERT(NodeType() == TEXT_NODE,
               "HasTextNodeDirectionalityMap on non-text node");
    return GetBoolFlag(NodeHasTextNodeDirectionalityMap);
  }

  void SetAncestorHasDirAuto() { SetBoolFlag(NodeAncestorHasDirAuto); }
  void ClearAncestorHasDirAuto() { ClearBoolFlag(NodeAncestorHasDirAuto); }
  bool AncestorHasDirAuto() const {
    return GetBoolFlag(NodeAncestorHasDirAuto);
  }

  // Implemented in nsIContentInlines.h.
  inline bool NodeOrAncestorHasDirAuto() const;

  void SetIsElementInStyleScope(bool aValue) {
    MOZ_ASSERT(IsElement(), "SetIsInStyleScope on a non-Element node");
    SetBoolFlag(ElementIsInStyleScope, aValue);
  }
  void SetIsElementInStyleScope() {
    MOZ_ASSERT(IsElement(), "SetIsInStyleScope on a non-Element node");
    SetBoolFlag(ElementIsInStyleScope);
  }
  void ClearIsElementInStyleScope() {
    MOZ_ASSERT(IsElement(), "ClearIsInStyleScope on a non-Element node");
    ClearBoolFlag(ElementIsInStyleScope);
  }
  bool IsElementInStyleScope() const {
    return GetBoolFlag(ElementIsInStyleScope);
  }

  void SetIsScopedStyleRoot() { SetBoolFlag(ElementIsScopedStyleRoot); }
  void ClearIsScopedStyleRoot() { ClearBoolFlag(ElementIsScopedStyleRoot); }
  bool IsScopedStyleRoot() { return GetBoolFlag(ElementIsScopedStyleRoot); }
  bool HasRelevantHoverRules() const {
    return GetBoolFlag(NodeHasRelevantHoverRules);
  }
  void SetHasRelevantHoverRules() { SetBoolFlag(NodeHasRelevantHoverRules); }
  void SetParserHasNotified() { SetBoolFlag(ParserHasNotified); };
  bool HasParserNotified() { return GetBoolFlag(ParserHasNotified); }

  void SetMayBeApzAware() { SetBoolFlag(MayBeApzAware); }
  bool NodeMayBeApzAware() const { return GetBoolFlag(MayBeApzAware); }

  void SetMayHaveAnonymousChildren() {
    SetBoolFlag(ElementMayHaveAnonymousChildren);
  }
  bool MayHaveAnonymousChildren() const {
    return GetBoolFlag(ElementMayHaveAnonymousChildren);
  }

  void SetMayHaveChildrenWithLayoutBoxesDisabled() {
    SetBoolFlag(NodeMayHaveChildrenWithLayoutBoxesDisabled);
  }
  void UnsetMayHaveChildrenWithLayoutBoxesDisabled() {
    ClearBoolFlag(NodeMayHaveChildrenWithLayoutBoxesDisabled);
  }
  bool MayHaveChildrenWithLayoutBoxesDisabled() const {
    return GetBoolFlag(NodeMayHaveChildrenWithLayoutBoxesDisabled);
  }

 protected:
  void SetParentIsContent(bool aValue) { SetBoolFlag(ParentIsContent, aValue); }
  void SetIsInDocument() { SetBoolFlag(IsInDocument); }
  void SetNodeIsContent() { SetBoolFlag(NodeIsContent); }
  void ClearInDocument() { ClearBoolFlag(IsInDocument); }
  void SetIsElement() { SetBoolFlag(NodeIsElement); }
  void SetHasID() { SetBoolFlag(ElementHasID); }
  void ClearHasID() { ClearBoolFlag(ElementHasID); }
  void SetMayHaveStyle() { SetBoolFlag(ElementMayHaveStyle); }
  void SetHasName() { SetBoolFlag(ElementHasName); }
  void ClearHasName() { ClearBoolFlag(ElementHasName); }
  void SetMayHaveContentEditableAttr() {
    SetBoolFlag(ElementMayHaveContentEditableAttr);
  }
  void SetHasLockedStyleStates() { SetBoolFlag(ElementHasLockedStyleStates); }
  void ClearHasLockedStyleStates() {
    ClearBoolFlag(ElementHasLockedStyleStates);
  }
  bool HasLockedStyleStates() const {
    return GetBoolFlag(ElementHasLockedStyleStates);
  }
  void SetHasWeirdParserInsertionMode() {
    SetBoolFlag(ElementHasWeirdParserInsertionMode);
  }
  bool HasWeirdParserInsertionMode() const {
    return GetBoolFlag(ElementHasWeirdParserInsertionMode);
  }
  bool HandlingClick() const { return GetBoolFlag(NodeHandlingClick); }
  void SetHandlingClick() { SetBoolFlag(NodeHandlingClick); }
  void ClearHandlingClick() { ClearBoolFlag(NodeHandlingClick); }

  void SetSubtreeRootPointer(nsINode* aSubtreeRoot) {
    NS_ASSERTION(aSubtreeRoot, "aSubtreeRoot can never be null!");
    NS_ASSERTION(!(IsContent() && IsInUncomposedDoc()) && !IsInShadowTree(),
                 "Shouldn't be here!");
    mSubtreeRoot = aSubtreeRoot;
  }

  void ClearSubtreeRootPointer() { mSubtreeRoot = nullptr; }

 public:
  // Makes nsINode object to keep aObject alive.
  void BindObject(nsISupports* aObject);
  // After calling UnbindObject nsINode object doesn't keep
  // aObject alive anymore.
  void UnbindObject(nsISupports* aObject);

  void GetBoundMutationObservers(
      nsTArray<RefPtr<nsDOMMutationObserver>>& aResult);
  void GenerateXPath(nsAString& aResult);

  already_AddRefed<mozilla::dom::Promise> Localize(
      JSContext* aCx, mozilla::dom::L10nCallback& aCallback,
      mozilla::ErrorResult& aRv);

  already_AddRefed<mozilla::dom::AccessibleNode> GetAccessibleNode();

  /**
   * Returns the length of this node, as specified at
   * <http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html#concept-node-length>
   */
  uint32_t Length() const;

  void GetNodeName(mozilla::dom::DOMString& aNodeName) {
    const nsString& nodeName = NodeName();
    aNodeName.SetKnownLiveString(nodeName);
  }
  MOZ_MUST_USE nsresult GetBaseURI(nsAString& aBaseURI) const;
  // Return the base URI for the document.
  // The returned value may differ if the document is loaded via XHR, and
  // when accessed from chrome privileged script and
  // from content privileged script for compatibility.
  void GetBaseURIFromJS(nsAString& aBaseURI, CallerType aCallerType,
                        ErrorResult& aRv) const;
  bool HasChildNodes() const { return HasChildren(); }
  uint16_t CompareDocumentPosition(nsINode& aOther) const;
  void GetNodeValue(nsAString& aNodeValue) { GetNodeValueInternal(aNodeValue); }
  void SetNodeValue(const nsAString& aNodeValue, mozilla::ErrorResult& aError) {
    SetNodeValueInternal(aNodeValue, aError);
  }
  virtual void GetNodeValueInternal(nsAString& aNodeValue);
  virtual void SetNodeValueInternal(const nsAString& aNodeValue,
                                    mozilla::ErrorResult& aError) {
    // The DOM spec says that when nodeValue is defined to be null "setting it
    // has no effect", so we don't throw an exception.
  }
  void EnsurePreInsertionValidity(nsINode& aNewChild, nsINode* aRefChild,
                                  mozilla::ErrorResult& aError);
  nsINode* InsertBefore(nsINode& aNode, nsINode* aChild,
                        mozilla::ErrorResult& aError) {
    return ReplaceOrInsertBefore(false, &aNode, aChild, aError);
  }
  nsINode* AppendChild(nsINode& aNode, mozilla::ErrorResult& aError) {
    return InsertBefore(aNode, nullptr, aError);
  }
  nsINode* ReplaceChild(nsINode& aNode, nsINode& aChild,
                        mozilla::ErrorResult& aError) {
    return ReplaceOrInsertBefore(true, &aNode, &aChild, aError);
  }
  nsINode* RemoveChild(nsINode& aChild, mozilla::ErrorResult& aError);
  already_AddRefed<nsINode> CloneNode(bool aDeep, mozilla::ErrorResult& aError);
  bool IsSameNode(nsINode* aNode);
  bool IsEqualNode(nsINode* aNode);
  void GetNamespaceURI(nsAString& aNamespaceURI) const {
    mNodeInfo->GetNamespaceURI(aNamespaceURI);
  }
#ifdef MOZILLA_INTERNAL_API
  void GetPrefix(nsAString& aPrefix) { mNodeInfo->GetPrefix(aPrefix); }
#endif
  void GetLocalName(mozilla::dom::DOMString& aLocalName) const {
    const nsString& localName = LocalName();
    aLocalName.SetKnownLiveString(localName);
  }

  nsDOMAttributeMap* GetAttributes();
  void SetUserData(JSContext* aCx, const nsAString& aKey,
                   JS::Handle<JS::Value> aData,
                   JS::MutableHandle<JS::Value> aRetval,
                   mozilla::ErrorResult& aError);
  void GetUserData(JSContext* aCx, const nsAString& aKey,
                   JS::MutableHandle<JS::Value> aRetval,
                   mozilla::ErrorResult& aError);

  // Helper method to remove this node from its parent. This is not exposed
  // through WebIDL.
  // Only call this if the node has a parent node.
  nsresult RemoveFromParent() {
    nsINode* parent = GetParentNode();
    mozilla::ErrorResult rv;
    parent->RemoveChild(*this, rv);
    return rv.StealNSResult();
  }

  // ChildNode methods
  mozilla::dom::Element* GetPreviousElementSibling() const;
  mozilla::dom::Element* GetNextElementSibling() const;

  MOZ_CAN_RUN_SCRIPT void Before(const Sequence<OwningNodeOrString>& aNodes,
                                 ErrorResult& aRv);
  MOZ_CAN_RUN_SCRIPT void After(const Sequence<OwningNodeOrString>& aNodes,
                                ErrorResult& aRv);
  MOZ_CAN_RUN_SCRIPT void ReplaceWith(
      const Sequence<OwningNodeOrString>& aNodes, ErrorResult& aRv);
  /**
   * Remove this node from its parent, if any.
   */
  void Remove();

  // ParentNode methods
  mozilla::dom::Element* GetFirstElementChild() const;
  mozilla::dom::Element* GetLastElementChild() const;

  MOZ_CAN_RUN_SCRIPT void Prepend(const Sequence<OwningNodeOrString>& aNodes,
                                  ErrorResult& aRv);
  MOZ_CAN_RUN_SCRIPT void Append(const Sequence<OwningNodeOrString>& aNodes,
                                 ErrorResult& aRv);

  void GetBoxQuads(const BoxQuadOptions& aOptions,
                   nsTArray<RefPtr<DOMQuad>>& aResult, CallerType aCallerType,
                   ErrorResult& aRv);

  already_AddRefed<DOMQuad> ConvertQuadFromNode(
      DOMQuad& aQuad, const TextOrElementOrDocument& aFrom,
      const ConvertCoordinateOptions& aOptions, CallerType aCallerType,
      ErrorResult& aRv);
  already_AddRefed<DOMQuad> ConvertRectFromNode(
      DOMRectReadOnly& aRect, const TextOrElementOrDocument& aFrom,
      const ConvertCoordinateOptions& aOptions, CallerType aCallerType,
      ErrorResult& aRv);
  already_AddRefed<DOMPoint> ConvertPointFromNode(
      const DOMPointInit& aPoint, const TextOrElementOrDocument& aFrom,
      const ConvertCoordinateOptions& aOptions, CallerType aCallerType,
      ErrorResult& aRv);

  const mozilla::LinkedList<nsRange>* GetExistingCommonAncestorRanges() const {
    if (!HasSlots()) {
      return nullptr;
    }
    return GetExistingSlots()->mCommonAncestorRanges.get();
  }

  mozilla::LinkedList<nsRange>* GetExistingCommonAncestorRanges() {
    if (!HasSlots()) {
      return nullptr;
    }
    return GetExistingSlots()->mCommonAncestorRanges.get();
  }

  mozilla::UniquePtr<mozilla::LinkedList<nsRange>>&
  GetCommonAncestorRangesPtr() {
    return Slots()->mCommonAncestorRanges;
  }

 protected:
  // Override this function to create a custom slots class.
  // Must not return null.
  virtual nsINode::nsSlots* CreateSlots();

  bool HasSlots() const { return mSlots != nullptr; }

  nsSlots* GetExistingSlots() const { return mSlots; }

  nsSlots* Slots() {
    if (!HasSlots()) {
      mSlots = CreateSlots();
      MOZ_ASSERT(mSlots);
    }
    return GetExistingSlots();
  }

  nsAutoTObserverArray<nsIMutationObserver*, 1>* GetMutationObservers() {
    return HasSlots() ? &GetExistingSlots()->mMutationObservers : nullptr;
  }

  /**
   * Invalidate cached child array inside mChildNodes
   * of type nsParentNodeChildContentList.
   */
  void InvalidateChildNodes();

  bool IsEditableInternal() const;
  virtual bool IsEditableExternal() const { return IsEditableInternal(); }

  virtual void GetTextContentInternal(nsAString& aTextContent,
                                      mozilla::OOMReporter& aError);
  virtual void SetTextContentInternal(const nsAString& aTextContent,
                                      nsIPrincipal* aSubjectPrincipal,
                                      mozilla::ErrorResult& aError) {}

#ifdef DEBUG
  // Note: virtual so that IsInNativeAnonymousSubtree can be called accross
  // module boundaries.
  virtual void CheckNotNativeAnonymous() const;
#endif

  void EnsurePreInsertionValidity1(nsINode& aNewChild, nsINode* aRefChild,
                                   mozilla::ErrorResult& aError);
  void EnsurePreInsertionValidity2(bool aReplace, nsINode& aNewChild,
                                   nsINode* aRefChild,
                                   mozilla::ErrorResult& aError);
  nsINode* ReplaceOrInsertBefore(bool aReplace, nsINode* aNewChild,
                                 nsINode* aRefChild,
                                 mozilla::ErrorResult& aError);

  /**
   * Returns the Element that should be used for resolving namespaces
   * on this node (ie the ownerElement for attributes, the documentElement for
   * documents, the node itself for elements and for other nodes the parentNode
   * if it is an element).
   */
  virtual mozilla::dom::Element* GetNameSpaceElement() = 0;

  /**
   * Most of the implementation of the nsINode RemoveChildAt method.
   * Should only be called on document, element, and document fragment
   * nodes.  The aChildArray passed in should be the one for |this|.
   *
   * @param aIndex The index to remove at.
   * @param aNotify Whether to notify.
   * @param aKid The kid at aIndex.  Must not be null.
   * @param aChildArray The child array to work with.
   * @param aMutationEvent whether to fire a mutation event for this removal.
   */
  void doRemoveChildAt(uint32_t aIndex, bool aNotify, nsIContent* aKid,
                       nsAttrAndChildArray& aChildArray);

  /**
   * Most of the implementation of the nsINode InsertChildAt_Deprecated method.
   * Should only be called on document, element, and document fragment
   * nodes.  The aChildArray passed in should be the one for |this|.
   *
   * @param aKid The child to insert.
   * @param aIndex The index to insert at.
   * @param aNotify Whether to notify.
   * @param aChildArray The child array to work with
   */
  nsresult doInsertChildAt(nsIContent* aKid, uint32_t aIndex, bool aNotify,
                           nsAttrAndChildArray& aChildArray);

  /**
   * Parse the given selector string into an nsCSSSelectorList.
   *
   * A null return value with a non-failing aRv means the string only
   * contained pseudo-element selectors.
   *
   * A failing aRv means the string was not a valid selector.
   *
   * Note that the selector list returned here is owned by the owner doc's
   * selector cache.
   */
  nsCSSSelectorList* ParseSelectorList(const nsAString& aSelectorString,
                                       mozilla::ErrorResult& aRv);

  /**
   * Parse the given selector string into a servo SelectorList.
   *
   * Never returns null if aRv is not failing.
   *
   * Note that the selector list returned here is owned by the owner doc's
   * selector cache.
   */
  const RawServoSelectorList* ParseServoSelectorList(
      const nsAString& aSelectorString, mozilla::ErrorResult& aRv);

  /**
   * Parse the given selector string a SelectorList, depending on whether we're
   * in a Servo or Gecko-backed document, and execute either aServoFunctor or
   * aGeckoFunctor on it.
   *
   * Note that the selector list is owned by the owner doc's selector cache
   * which can get expired, so you shouldn't keep it around for long.
   */
  template <typename Ret, typename ServoFunctor, typename GeckoFunctor>
  Ret WithSelectorList(const nsAString& aSelectorString,
                       mozilla::ErrorResult& aRv,
                       const ServoFunctor& aServoFunctor,
                       const GeckoFunctor& aGeckoFunctor) {
    if (IsStyledByServo()) {
      return aServoFunctor(ParseServoSelectorList(aSelectorString, aRv));
    }
#ifdef MOZ_OLD_STYLE
    return aGeckoFunctor(ParseSelectorList(aSelectorString, aRv));
#else
    MOZ_CRASH("old style system disabled");
#endif
  }

 public:
  /* Event stuff that documents and elements share.  This needs to be
     NS_IMETHOD because some subclasses implement DOM methods with
     this exact name and signature and then the calling convention
     needs to match.

     Note that we include DOCUMENT_ONLY_EVENT events here so that we
     can forward all the document stuff to this implementation.
  */
#define EVENT(name_, id_, type_, struct_)            \
  mozilla::dom::EventHandlerNonNull* GetOn##name_(); \
  void SetOn##name_(mozilla::dom::EventHandlerNonNull* listener);
#define TOUCH_EVENT EVENT
#define DOCUMENT_ONLY_EVENT EVENT
#include "mozilla/EventNameList.h"
#undef DOCUMENT_ONLY_EVENT
#undef TOUCH_EVENT
#undef EVENT

 protected:
  static bool Traverse(nsINode* tmp, nsCycleCollectionTraversalCallback& cb);
  static void Unlink(nsINode* tmp);

  RefPtr<mozilla::dom::NodeInfo> mNodeInfo;

  // mParent is an owning ref most of the time, except for the case of document
  // nodes, so it cannot be represented by nsCOMPtr, so mark is as
  // MOZ_OWNING_REF.
  nsINode* MOZ_OWNING_REF mParent;

 private:
#ifndef BOOL_FLAGS_ON_WRAPPER_CACHE
  // Boolean flags.
  uint32_t mBoolFlags;
#endif

 protected:
  // These references are non-owning and safe, as they are managed by
  // nsAttrAndChildArray.
  nsIContent* MOZ_NON_OWNING_REF mNextSibling;
  nsIContent* MOZ_NON_OWNING_REF mPreviousSibling;
  // This reference is non-owning and safe, since in the case of documents,
  // it is set to null when the document gets destroyed, and in the case of
  // other nodes, the children keep the parents alive.
  nsIContent* MOZ_NON_OWNING_REF mFirstChild;

  union {
    // Pointer to our primary frame.  Might be null.
    nsIFrame* mPrimaryFrame;

    // Pointer to the root of our subtree.  Might be null.
    // This reference is non-owning and safe, since it either points to the
    // object itself, or is reset by ClearSubtreeRootPointer.
    nsINode* MOZ_NON_OWNING_REF mSubtreeRoot;
  };

  // Storage for more members that are usually not needed; allocated lazily.
  nsSlots* mSlots;
};

inline nsIDOMNode* GetAsDOMNode(nsINode* aNode) {
  return aNode ? aNode->AsDOMNode() : nullptr;
}

// Useful inline function for getting a node given an nsIContent and an
// nsIDocument.  Returns the first argument cast to nsINode if it is non-null,
// otherwise returns the second (which may be null).  We use type variables
// instead of nsIContent* and nsIDocument* because the actual types must be
// known for the cast to work.
template <class C, class D>
inline nsINode* NODE_FROM(C& aContent, D& aDocument) {
  if (aContent) return static_cast<nsINode*>(aContent);
  return static_cast<nsINode*>(aDocument);
}

NS_DEFINE_STATIC_IID_ACCESSOR(nsINode, NS_INODE_IID)

inline nsISupports* ToSupports(nsINode* aPointer) { return aPointer; }

inline nsISupports* ToCanonicalSupports(nsINode* aPointer) { return aPointer; }

#endif /* nsINode_h___ */