author Mike Hommey <>
Thu, 17 Jan 2019 13:18:37 +0000
changeset 454358 c28522aaf3918c5f556c65432f8bf14a65bff65a
parent 453558 aae6e06aa88ba6abdf2924afe26235e045385485
permissions -rw-r--r--
Bug 1520149 - Also disable the machine outliner on Android when LTO is enabled. r=dmajor Differential Revision:

/* -*- 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 */

 * Implementation of
 * in iterator
 * form.  This can and should be used to avoid recursion on the stack and lots
 * of function calls during shadow-including tree iteration.

#ifndef mozilla_dom_ShadowIncludingTreeIterator_h
#define mozilla_dom_ShadowIncludingTreeIterator_h

#include "nsINode.h"
#include "nsTArray.h"
#include "mozilla/dom/Element.h"
#include "mozilla/dom/ShadowRoot.h"

namespace mozilla {
namespace dom {

class ShadowIncludingTreeIterator {
   * Initialize an iterator with aRoot.  After that it can be iterated with a
   * range-based for loop.  At the moment, that's the only supported form of use
   * for this iterator.
  explicit ShadowIncludingTreeIterator(nsINode& aRoot) : mCurrent(&aRoot) {

#ifdef DEBUG
  ~ShadowIncludingTreeIterator() {
        "Don't mutate the DOM while using a ShadowIncludingTreeIterator");
#endif  // DEBUG

  // Basic support for range-based for loops.  This will modify the iterator as
  // it goes.
  ShadowIncludingTreeIterator& begin() { return *this; }

  ShadowIncludingTreeIterator end() { return ShadowIncludingTreeIterator(); }

  bool operator!=(const ShadowIncludingTreeIterator& aOther) {
    return mCurrent != aOther.mCurrent;

  void operator++() { Next(); }

  nsINode* operator*() { return mCurrent; }

  // Constructor used only for end() to represent a drained iterator.
  ShadowIncludingTreeIterator() : mCurrent(nullptr) {}

  void Next() {
    MOZ_ASSERT(mCurrent, "Don't call Next() after we have no current node");

    // We walk shadow roots immediately after their shadow host.
    if (Element* element = Element::FromNode(mCurrent)) {
      if (ShadowRoot* shadowRoot = element->GetShadowRoot()) {
        mCurrent = shadowRoot;

    mCurrent = mCurrent->GetNextNode(mRoots.LastElement());
    while (!mCurrent) {
      // Nothing left under this root.  Keep trying to pop the stack until we
      // find a node or run out of stack.
      nsINode* root = mRoots.PopLastElement();
      if (mRoots.IsEmpty()) {
        // No more roots to step out of; we're done.  mCurrent is already set to
        // null.
      mCurrent =

  // The current node we're at.
  nsINode* mCurrent;

  // Stack of roots that we're inside of right now.  An empty stack can only
  // happen when mCurrent is null (and hence we are done iterating).
  // The default array size here is picked based on gut feeling.  We want at
  // least 1, since we will always add something to it in our constructor.
  // Having a few more entries probably makes sense, because this is commonly
  // used in cases when we know we have custom elements, and hence likely have
  // shadow DOMs.  But the exact value "4" was just picked because it sounded
  // not too big, not too small.  Feel free to replace it with something else
  // based on actual data.
  AutoTArray<nsINode*, 4> mRoots;

#ifdef DEBUG
  // Make sure no one mutates the DOM while we're walking over it.
  nsMutationGuard mMutationGuard;
#endif  // DEBUG

}  // namespace dom
}  // namespace mozilla

#endif  // mozilla_dom_ShadowIncludingTreeIterator_h