Attachment #8492600 for bug #907396

Attachment #8492600: Make RestyleManager::RestyleElement and nsCSSFrameConstructor::MaybeRecreateFramesForElement deal with display:contents elements. for bug #907396

View | Details | Raw Unified | Return to bug 907396
Collapse All | Expand All





}

#ifdef DEBUG
  // To ensure that the functions below are only called within
  // |ApplyRenderingChangeToTree|.
static bool gInApplyRenderingChangeToTree = false;
#endif

static nsIFrame*
GetNearestAncestorFrame(nsIContent* aContent)
{
  nsIFrame* ancestorFrame = nullptr;
  for (nsIContent* ancestor = aContent->GetParent();
       ancestor && !ancestorFrame;
       ancestor = ancestor->GetParent()) {
    ancestorFrame = ancestor->GetPrimaryFrame();
  }
  return ancestorFrame;
}


static void
DoApplyRenderingChangeToTree(nsIFrame* aFrame,
                             nsChangeHint aChange);

/**
 * Sync views on aFrame and all of aFrame's descendants (following placeholders),
 * if aChange has nsChangeHint_SyncFrameView.
 * Calls DoApplyRenderingChangeToTree on all aFrame's out-of-flow descendants

    // We're restyling an element with no frame, so we should try to
    // make one if its new style says it should have one.  But in order
    // to try to honor the restyle hint (which we'd like to do so that,
    // for example, an animation-only style flush doesn't flush other
    // buffered style changes), we only do this if the restyle hint says
    // we have *some* restyling for this frame.  This means we'll
    // potentially get ahead of ourselves in that case, but not as much
    // as we would if we didn't check the restyle hint.
    nsStyleContext* newContext =
      FrameConstructor()->MaybeRecreateFramesForElement(aElement);
    if (newContext &&
        newContext->StyleDisplay()->mDisplay == NS_STYLE_DISPLAY_CONTENTS) {
      // Style change for a display:contents node that did not recreate frames.
      nsIFrame* frame = GetNearestAncestorFrame(aElement);
      MOZ_ASSERT(frame, "display:contents node in map although it's a "
                        "display:none descendant?");
      TreeMatchContext treeMatchContext(true,
                                        nsRuleWalker::eRelevantLinkUnvisited,
                                        frame->PresContext()->Document());
      nsIContent* parent = aElement->GetParent();
      Element* parentElement =
        parent && parent->IsElement() ? parent->AsElement() : nullptr;
      treeMatchContext.InitAncestors(parentElement);
      nsTArray<nsIContent*> visibleKidsOfHiddenElement;
      nsStyleChangeList changeList;
      ElementRestyler r(frame->PresContext(), aElement, &changeList,
                        aMinHint, aRestyleTracker, treeMatchContext,
                        visibleKidsOfHiddenElement);
      r.RestyleChildrenOfDisplayContentsElement(frame, newContext,
                                                aMinHint, aRestyleTracker,
                                                aRestyleHint, this);
      ProcessRestyledFrames(changeList);
    }
  }
}

static inline dom::Element*
ElementForStyleContext(nsIContent* aParentContent,
                       nsIFrame* aFrame,
                       nsCSSPseudoElements::Type aPseudoType);


  , mDesiredA11yNotifications(aParentRestyler.mDesiredA11yNotifications)
  , mKidsDesiredA11yNotifications(mDesiredA11yNotifications)
  , mOurA11yNotification(eDontNotify)
  , mVisibleKidsOfHiddenElement(aParentRestyler.mVisibleKidsOfHiddenElement)
#endif
{
}

ElementRestyler::ElementRestyler(nsPresContext* aPresContext,
                                 nsIContent* aContent,
                                 nsStyleChangeList* aChangeList,
                                 nsChangeHint aHintsHandledByAncestors,
                                 RestyleTracker& aRestyleTracker,
                                 TreeMatchContext& aTreeMatchContext,
                                 nsTArray<nsIContent*>&
                                 aVisibleKidsOfHiddenElement)
  : mPresContext(aPresContext)
  , mFrame(nullptr)
  , mParentContent(nullptr)
  , mContent(aContent)
  , mChangeList(aChangeList)
  , mHintsHandled(NS_SubtractHint(aHintsHandledByAncestors,
                  NS_HintsNotHandledForDescendantsIn(aHintsHandledByAncestors)))
  , mParentFrameHintsNotHandledForDescendants(nsChangeHint(0))
  , mHintsNotHandledForDescendants(nsChangeHint(0))
  , mRestyleTracker(aRestyleTracker)
  , mTreeMatchContext(aTreeMatchContext)
  , mResolvedChild(nullptr)
#ifdef ACCESSIBILITY
  , mDesiredA11yNotifications(eSendAllNotifications)
  , mKidsDesiredA11yNotifications(mDesiredA11yNotifications)
  , mOurA11yNotification(eDontNotify)
  , mVisibleKidsOfHiddenElement(aVisibleKidsOfHiddenElement)
#endif
{
}

void
ElementRestyler::CaptureChange(nsStyleContext* aOldContext,
                               nsStyleContext* aNewContext,
                               nsChangeHint aChangeToAssume,
                               uint32_t* aEqualStructs)
{
  static_assert(nsStyleStructID_Length <= 32,
                "aEqualStructs is not big enough");

      // left on mFrame.  Since we ended up restyling our parent, change
      // this old style context to point to its new parent.
      oldContext->MoveTo(parentContext);
    }

    // Send the accessibility notifications that RestyleChildren otherwise
    // would have sent.
    if (!(mHintsHandled & nsChangeHint_ReconstructFrame)) {
      InitializeAccessibilityNotifications(mFrame->StyleContext());
      SendAccessibilityNotifications();
    }

    mRestyleTracker.AddRestyleRootsIfAwaitingRestyle(descendants);
    return;
  }

  if (!swappedStructs) {

  // descendants anyway, so we want to avoid wasting time processing
  // style contexts that we're just going to throw away anyway. - dwh
  // It's also important to check mHintsHandled since reresolving the
  // kids would use mFrame->StyleContext(), which is out of date if
  // mHintsHandled has a ReconstructFrame hint; doing this could trigger
  // assertions about mismatched rule trees.
  nsIFrame *lastContinuation;
  if (!(mHintsHandled & nsChangeHint_ReconstructFrame)) {
    InitializeAccessibilityNotifications(mFrame->StyleContext());

    for (nsIFrame* f = mFrame; f;
         f = GetNextContinuationWithSameStyle(f, f->StyleContext())) {
      lastContinuation = f;
      RestyleContentChildren(f, aChildRestyleHint);
    }

    SendAccessibilityNotifications();

  // See comments above regarding :before.
  if (!(mHintsHandled & nsChangeHint_ReconstructFrame) &&
      mightReframePseudos) {
    MaybeReframeForAfterPseudo(lastContinuation);
  }
}

void
ElementRestyler::RestyleChildrenOfDisplayContentsElement(
  nsIFrame*       aParentFrame,
  nsStyleContext* aNewContext,
  nsChangeHint    aMinHint,
  RestyleTracker& aRestyleTracker,
  nsRestyleHint   aRestyleHint,
  RestyleManager* aRestyleManager)
{
  const bool mightReframePseudos = aRestyleHint & eRestyle_Subtree;
  InitializeAccessibilityNotifications(aNewContext);
  DoRestyleUndisplayedDescendants(nsRestyleHint(0), mContent, aNewContext);
  if (!(mHintsHandled & nsChangeHint_ReconstructFrame) &&
      mightReframePseudos) {
    MaybeReframeForBeforePseudo(aParentFrame, nullptr, mContent, aNewContext);
  }
  if (!(mHintsHandled & nsChangeHint_ReconstructFrame) &&
      mightReframePseudos) {
    MaybeReframeForAfterPseudo(aParentFrame, nullptr, mContent, aNewContext);
  }
  if (!(mHintsHandled & nsChangeHint_ReconstructFrame)) {
    // Then process child frames for content that is a descendant of mContent.
    // XXX perhaps it's better to walk child frames (before reresolving
    // XXX undisplayed contexts above) and mark those that has a stylecontext
    // XXX leading up to mContent's old context? (instead of the
    // XXX ContentIsDescendantOf check below)
    nsIFrame::ChildListIterator lists(aParentFrame);
    for ( ; !lists.IsDone(); lists.Next()) {
      nsFrameList::Enumerator childFrames(lists.CurrentList());
      for (; !childFrames.AtEnd(); childFrames.Next()) {
        nsIFrame* f = childFrames.get();
        if (nsContentUtils::ContentIsDescendantOf(f->GetContent(), mContent) &&
            !f->GetPrevContinuation()) {
          if (!(f->GetStateBits() & NS_FRAME_OUT_OF_FLOW)) {
            aRestyleManager->ComputeStyleChangeFor(f, mChangeList, aMinHint,
                                                   aRestyleTracker,
                                                   aRestyleHint);
          }
        }
      }
    }
  }
  if (!(mHintsHandled & nsChangeHint_ReconstructFrame)) {
    SendAccessibilityNotifications();
  }
}

void
ElementRestyler::RestyleUndisplayedDescendants(nsRestyleHint aChildRestyleHint)
{
  // When the root element is display:none, we still construct *some*
  // frames that have the root element as their mContent, down to the
  // DocElementContainingBlock.
  bool checkUndisplayed;
  nsIContent* undisplayedParent;
  if (mFrame->StyleContext()->GetPseudo()) {
    checkUndisplayed = mFrame == mPresContext->FrameConstructor()->
                                   GetDocElementContainingBlock();
    undisplayedParent = nullptr;
  } else {
    checkUndisplayed = !!mFrame->GetContent();
    undisplayedParent = mFrame->GetContent();
  }
  if (checkUndisplayed) {
    DoRestyleUndisplayedDescendants(aChildRestyleHint, undisplayedParent,
                                    mFrame->StyleContext());
  }
}

void
ElementRestyler::DoRestyleUndisplayedDescendants(nsRestyleHint aChildRestyleHint,
                                                 nsIContent* aParent,
                                                 nsStyleContext* aParentContext)
{
  nsCSSFrameConstructor* fc = mPresContext->FrameConstructor();
  UndisplayedNode* nodes = fc->GetAllUndisplayedContentIn(aParent);
  RestyleUndisplayedNodes(aChildRestyleHint, nodes, aParent,
                          aParentContext, NS_STYLE_DISPLAY_NONE);
  nodes = fc->GetAllDisplayContentsIn(aParent);
  RestyleUndisplayedNodes(aChildRestyleHint, nodes, aParent,
                          aParentContext, NS_STYLE_DISPLAY_CONTENTS);
}

void
ElementRestyler::RestyleUndisplayedNodes(nsRestyleHint    aChildRestyleHint,
                                         UndisplayedNode* aUndisplayed,
                                         nsIContent*      aUndisplayedParent,
                                         nsStyleContext*  aParentContext,
                                         const uint8_t    aDisplay)
{
  nsIContent* undisplayedParent = aUndisplayedParent;
  UndisplayedNode* undisplayed = aUndisplayed;
  TreeMatchContext::AutoAncestorPusher pusher(mTreeMatchContext);
  if (undisplayed) {
    pusher.PushAncestorAndStyleScope(undisplayedParent);
  }

                                       undisplayedRestyleData)) {
      thisChildHint =
        nsRestyleHint(thisChildHint | undisplayedRestyleData->mRestyleHint);
    }
    nsRefPtr<nsStyleContext> undisplayedContext;
    nsStyleSet* styleSet = mPresContext->StyleSet();
    if (thisChildHint & (eRestyle_Self | eRestyle_Subtree)) {
      undisplayedContext =
        styleSet->ResolveStyleFor(element, aParentContext, mTreeMatchContext);
                                  mFrame->StyleContext(),
                                  mTreeMatchContext);
    } else if (thisChildHint ||
               styleSet->IsInRuleTreeReconstruct()) {
      // Use ResolveStyleWithReplacement either for actual
      // replacements, or as a substitute for ReparentStyleContext
      // that rebuilds the path in the rule tree rather than reusing
      // the rule node, as we need to do during a rule tree
      // reconstruct.
      undisplayedContext =
        styleSet->ResolveStyleWithReplacement(element,
                                              aParentContext,
                                              undisplayed->mStyle,
                                              thisChildHint);
    } else {
      undisplayedContext =
        styleSet->ReparentStyleContext(undisplayed->mStyle,
                                       aParentContext,
                                       element, element);
    }
    const nsStyleDisplay* display = undisplayedContext->StyleDisplay();
    if (display->mDisplay != aDisplay) {
      NS_ASSERTION(element, "Must have undisplayed content");
      mChangeList->AppendChange(nullptr, element,
                                NS_STYLE_HINT_FRAMECHANGE);
      // The node should be removed from the undisplayed map when
      // we reframe it.
    } else {
      // update the undisplayed node with the new context
      undisplayed->mStyle = undisplayedContext;

      if (aDisplay == NS_STYLE_DISPLAY_CONTENTS) {
        DoRestyleUndisplayedDescendants(aChildRestyleHint, element,
                                        undisplayed->mStyle);
      }
    }
  }
}

void
ElementRestyler::MaybeReframeForBeforePseudo()
{
  MaybeReframeForBeforePseudo(mFrame, mFrame, mFrame->GetContent(),
                              mFrame->StyleContext());
}

void
ElementRestyler::MaybeReframeForBeforePseudo(nsIFrame* aGenConParentFrame,
                                             nsIFrame* aFrame,
                                             nsIContent* aContent,
                                             nsStyleContext* aStyleContext)
{
  // Make sure not to do this for pseudo-frames or frames that
  // can't have generated content.
  nsContainerFrame* cif;
  if (!aStyleContext->GetPseudo() &&
      ((aGenConParentFrame->GetStateBits() & NS_FRAME_MAY_HAVE_GENERATED_CONTENT) ||
       // Our content insertion frame might have gotten flagged.
       ((cif = aGenConParentFrame->GetContentInsertionFrame()) &&
        (cif->GetStateBits() & NS_FRAME_MAY_HAVE_GENERATED_CONTENT)))) {
    // Check for a ::before pseudo style and the absence of a ::before content,
    // but only if aFrame is null or is the first continuation.
    if (!aFrame || !aFrame->GetPrevContinuation()) {
      // Checking for a ::before frame is cheaper than getting the
      // ::before style context.
      if (!nsLayoutUtils::GetBeforeFrameForContent(aGenConParentFrame, aContent) &&
          nsLayoutUtils::HasPseudoStyle(aContent, aStyleContext,
          nsLayoutUtils::HasPseudoStyle(mFrame->GetContent(),
                                        mFrame->StyleContext(),
                                        nsCSSPseudoElements::ePseudo_before,
                                        mPresContext)) {
        // Have to create the new ::before frame.
        NS_UpdateHint(mHintsHandled, nsChangeHint_ReconstructFrame);
        mChangeList->AppendChange(aFrame, aContent,
                                  nsChangeHint_ReconstructFrame);
      }
    }
  }
}

/**
 * aFrame is the last continuation or block-in-inline sibling that this
 * ElementRestyler is restyling.
 */
void
ElementRestyler::MaybeReframeForAfterPseudo(nsIFrame* aFrame)
{
  MOZ_ASSERT(aFrame);
  MaybeReframeForAfterPseudo(aFrame, aFrame, aFrame->GetContent(),
                             aFrame->StyleContext());
}

void
ElementRestyler::MaybeReframeForAfterPseudo(nsIFrame* aGenConParentFrame,
                                            nsIFrame* aFrame,
                                            nsIContent* aContent,
                                            nsStyleContext* aStyleContext)
{
  // Make sure not to do this for pseudo-frames or frames that
  // can't have generated content.
  nsContainerFrame* cif;
  if (!aStyleContext->GetPseudo() &&
      ((aGenConParentFrame->GetStateBits() & NS_FRAME_MAY_HAVE_GENERATED_CONTENT) ||
       // Our content insertion frame might have gotten flagged.
       ((cif = aGenConParentFrame->GetContentInsertionFrame()) &&
        (cif->GetStateBits() & NS_FRAME_MAY_HAVE_GENERATED_CONTENT)))) {
    // Check for an ::after pseudo style and the absence of an ::after content,
    // but only if aFrame is null or is the last continuation.
    if (!aFrame || !aFrame->GetNextContinuation()) {
      // Checking for an ::after frame is cheaper than getting the
      // ::after style context.
      if (!nsLayoutUtils::GetAfterFrameForContent(aGenConParentFrame, aContent) &&
          nsLayoutUtils::HasPseudoStyle(aContent, aStyleContext,
      if (nsLayoutUtils::HasPseudoStyle(aFrame->GetContent(),
                                        aFrame->StyleContext(),
                                        nsCSSPseudoElements::ePseudo_after,
                                        mPresContext)) {
        // Have to create the new ::after frame.
        // have to create the new :after frame
        NS_UpdateHint(mHintsHandled, nsChangeHint_ReconstructFrame);
        mChangeList->AppendChange(aFrame, mContent,
                                  nsChangeHint_ReconstructFrame);
      }
    }
  }
}

void
ElementRestyler::InitializeAccessibilityNotifications(nsStyleContext* aNewContext)
{
#ifdef ACCESSIBILITY
  // Notify a11y for primary frame only if it's a root frame of visibility
  // changes or its parent frame was hidden while it stays visible and
  // it is not inside a {ib} split or is the first frame of {ib} split.
  if (nsIPresShell::IsAccessibilityActive() &&
      (!mFrame ||
       (!mFrame->GetPrevContinuation() &&
        !mFrame->FrameIsNonFirstInIBSplit()))) {
    if (mDesiredA11yNotifications == eSendAllNotifications) {
      bool isFrameVisible = aNewContext->StyleVisibility()->IsVisible();
      if (isFrameVisible != mWasFrameVisible) {
        if (isFrameVisible) {
          // Notify a11y the element (perhaps with its children) was shown.
          // We don't fall into this case if this element gets or stays shown
          // while its parent becomes hidden.
          mKidsDesiredA11yNotifications = eSkipNotifications;
          mOurA11yNotification = eNotifyShown;
        } else {

          // visible children then we should notify a11y about that as if
          // they were inserted into tree. Notify a11y this element was
          // hidden.
          mKidsDesiredA11yNotifications = eNotifyIfShown;
          mOurA11yNotification = eNotifyHidden;
        }
      }
    } else if (mDesiredA11yNotifications == eNotifyIfShown &&
               aNewContext->StyleVisibility()->IsVisible()) {
      // Notify a11y that element stayed visible while its parent was hidden.
      nsIContent* c = mFrame ? mFrame->GetContent() : mContent;
      mVisibleKidsOfHiddenElement.AppendElement(c);
      mKidsDesiredA11yNotifications = eSkipNotifications;
    }
  }
#endif
}

void
ElementRestyler::RestyleContentChildren(nsIFrame* aParent,

void
ElementRestyler::SendAccessibilityNotifications()
{
#ifdef ACCESSIBILITY
  // Send notifications about visibility changes.
  if (mOurA11yNotification == eNotifyShown) {
    nsAccessibilityService* accService = nsIPresShell::AccService();
    if (accService) {
      nsIPresShell* presShell = mPresContext->GetPresShell();
      nsIContent* content = mFrame ? mFrame->GetContent() : mContent;

      accService->ContentRangeInserted(presShell, content->GetParent(),
                                       content,
                                       content->GetNextSibling());
    }
  } else if (mOurA11yNotification == eNotifyHidden) {
    nsAccessibilityService* accService = nsIPresShell::AccService();
    if (accService) {
      nsIPresShell* presShell = mPresContext->GetPresShell();
      nsIContent* content = mFrame ? mFrame->GetContent() : mContent;
      accService->ContentRemoved(presShell, content->GetParent(), content);

      // Process children staying shown.
      uint32_t visibleContentCount = mVisibleKidsOfHiddenElement.Length();
      for (uint32_t idx = 0; idx < visibleContentCount; idx++) {
        nsIContent* childContent = mVisibleKidsOfHiddenElement[idx];
        accService->ContentRangeInserted(presShell, childContent->GetParent(),
                                         childContent,





   * the new parent style context will be automatically computed based on the
   * new position in the frame tree.
   *
   * @param aFrame the root of the subtree to reparent.  Must not be null.
   */
  nsresult ReparentStyleContext(nsIFrame* aFrame);

private:
  friend class ElementRestyler;
  void ComputeAndProcessStyleChange(nsIFrame* aFrame,
                                    nsChangeHint aMinChange,
                                    RestyleTracker& aRestyleTracker,
                                    nsRestyleHint aRestyleHint);

  /**
   * Re-resolve the style contexts for a frame tree, building
   * aChangeList based on the resulting style changes, plus aMinChange

  // as the parent style context for their outer table frame (table
  // wrapper frame).  We should probably try to get rid of this
  // exception and have the inheritance go the other way.)
  enum ParentContextFromChildFrame { PARENT_CONTEXT_FROM_CHILD_FRAME };
  ElementRestyler(ParentContextFromChildFrame,
                  const ElementRestyler& aParentFrameRestyler,
                  nsIFrame* aFrame);

  // For restyling undisplayed content only (mFrame==null).
  ElementRestyler(nsPresContext* aPresContext,
                  nsIContent* aContent,
                  nsStyleChangeList* aChangeList,
                  nsChangeHint aHintsHandledByAncestors,
                  RestyleTracker& aRestyleTracker,
                  TreeMatchContext& aTreeMatchContext,
                  nsTArray<nsIContent*>& aVisibleKidsOfHiddenElement);

  /**
   * Restyle our frame's element and its subtree.
   *
   * Use eRestyle_Self for the aRestyleHint argument to mean
   * "reresolve our style context but not kids", use eRestyle_Subtree
   * to mean "reresolve our style context and kids", and use
   * nsRestyleHint(0) to mean recompute a new style context for our
   * current parent and existing rulenode, and the same for kids.

   * mHintsHandled changes over time; it starts off as the hints that
   * have been handled by ancestors, and by the end of Restyle it
   * represents the hints that have been handled for this frame.  This
   * method is intended to be called after Restyle, to find out what
   * hints have been handled for this frame.
   */
  nsChangeHint HintsHandledForFrame() { return mHintsHandled; }

  /**
   * Called from RestyleManager::RestyleElement to restyle children of
   * a display:contents element.
   */
  void RestyleChildrenOfDisplayContentsElement(nsIFrame* aParentFrame,
                                               nsStyleContext* aNewContext,
                                               nsChangeHint    aMinHint,
                                               RestyleTracker& aRestyleTracker,
                                               nsRestyleHint   aRestyleHint,
                                               RestyleManager* aRestyleManager);
private:
  // Enum for the result of RestyleSelf, which indicates whether the
  // restyle procedure should continue to the children, and how.
  //
  // These values must be ordered so that later values imply that all
  // the work of the earlier values is also done.
  enum RestyleResult {


  RestyleResult ComputeRestyleResultFromNewContext(nsIFrame* aSelf,
                                                   nsStyleContext* aNewContext);

  /**
   * Helpers for RestyleChildren().
   */
  void RestyleUndisplayedDescendants(nsRestyleHint aChildRestyleHint);
  void DoRestyleUndisplayedDescendants(nsRestyleHint aChildRestyleHint,
                                       nsIContent* aParent,
                                       nsStyleContext* aParentStyleContext);
  void RestyleUndisplayedNodes(nsRestyleHint    aChildRestyleHint,
                               UndisplayedNode* aUndisplayed,
                               nsIContent*      aUndisplayedParent,
                               nsStyleContext*  aParentStyleContext,
                               const uint8_t    aDisplay);
  void MaybeReframeForBeforePseudo();
  void MaybeReframeForBeforePseudo(nsIFrame* aGenConParentFrame,
                                   nsIFrame* aFrame,
                                   nsIContent* aContent,
                                   nsStyleContext* aStyleContext);
  void MaybeReframeForAfterPseudo(nsIFrame* aFrame);
  void MaybeReframeForAfterPseudo(nsIFrame* aGenConParentFrame,
                                  nsIFrame* aFrame,
                                  nsIContent* aContent,
                                  nsStyleContext* aStyleContext);
  void RestyleContentChildren(nsIFrame* aParent,
                              nsRestyleHint aChildRestyleHint);
  void InitializeAccessibilityNotifications(nsStyleContext* aNewContext);
  void SendAccessibilityNotifications();

  enum DesiredA11yNotifications {
    eSkipNotifications,
    eSendAllNotifications,
    eNotifyIfShown
  };






      ((bits & FCDATA_DISALLOW_OUT_OF_FLOW) ||
       !aState.GetGeometricParent(display, nullptr))) {
    item->mIsLineParticipant = true;
    aItems.LineParticipantItemAdded();
  }
}

static void
AddGenConPseudoToFrame(nsIFrame* aOwnerFrame, nsIContent* aContent)
{
  typedef nsAutoTArray<nsIContent*, 2> T;
  const FramePropertyDescriptor* prop = nsIFrame::GenConProperty();
  for (T::size_type i = 0; i < arr->Length(); ++i) {
    nsIContent* content = (*arr)[i];
    content->UnbindFromTree();
    NS_RELEASE(content);
  }
  delete arr;
}

NS_DECLARE_FRAME_PROPERTY(GenConProperty, DestroyContentArray)

static void
AddGenConPseudoToFrame(nsIFrame* aOwnerFrame, nsIContent* aContent)
{
  typedef nsAutoTArray<nsIContent*, 2> T;
  const FramePropertyDescriptor* prop = GenConProperty();
  FrameProperties props = aOwnerFrame->Properties();
  T* value = static_cast<T*>(props.Get(prop));
  if (!value) {
    value = new T;
    props.Set(prop, value);
  }
  value->AppendElement(aContent);
}

static nsTArray<nsIContent*>*
GetGenConPseudos(nsIFrame* aOwnerFrame)
{
  const FramePropertyDescriptor* prop = GenConProperty();
  FrameProperties props = aOwnerFrame->Properties();
  return static_cast<nsTArray<nsIContent*>*>(props.Get(prop));
}

/**
 * Return true if the frame construction item pointed to by aIter will
 * create a frame adjacent to a line boundary in the frame tree, and that
 * line boundary is induced by a content node adjacent to the frame's
 * content node in the content tree. The latter condition is necessary so
 * that ContentAppended/ContentInserted/ContentRemoved can easily find any
 * text nodes that were suppressed here.
 */

                                  nsIContent* aChild,
                                  nsIFrame** aAfterFrame)
{
  // If the parent frame has any pseudo-elements or aContainer is a
  // display:contents node then we need to walk through the child
  // frames to find the first one that is either a ::after frame for an
  // ancestor of aChild or a frame that is for a node later in the
  // document than aChild and return that in aAfterFrame.
  if (aParentFrame->GetGenConPseudos() ||
      nsLayoutUtils::HasPseudoStyle(aContainer, aParentFrame->StyleContext(),
                                    nsCSSPseudoElements::ePseudo_after,
                                    aParentFrame->PresContext()) ||
      aFrameManager->GetDisplayContentsStyleFor(aContainer)) {
    nsIFrame* afterFrame = nullptr;
    nsContainerFrame* parent =
      static_cast<nsContainerFrame*>(aParentFrame->LastContinuation());
    bool done = false;

    nsIContent* ancestor = aContainer;
    for (; ancestor; ancestor = ancestor->GetParent()) {
      ancestorFrame = ancestor->GetPrimaryFrame();
      if (ancestorFrame) {
        break;
      }
    }
    if (ancestorFrame) {
      nsTArray<nsIContent*>* generated = ancestorFrame->GetGenConPseudos();
      if (generated) {
        LAYOUT_PHASE_TEMP_EXIT();
        // XXXmats Can we recreate frames only for the ::after/::before content?
        // XXX Perhaps even only those that belong to the aChild sub-tree?
        RecreateFramesForContent(ancestor, false);
        LAYOUT_PHASE_TEMP_REENTER();
        *aDidReconstruct = true;
        return NS_OK;


static bool EqualURIs(mozilla::css::URLValue *aURI1,
                      mozilla::css::URLValue *aURI2)
{
  return aURI1 == aURI2 ||    // handle null==null, and optimize
         (aURI1 && aURI2 && aURI1->URIEquals(*aURI2));
}

nsStyleContext*
nsCSSFrameConstructor::MaybeRecreateFramesForElement(Element* aElement)
{
  nsRefPtr<nsStyleContext> oldContext = GetUndisplayedContent(aElement);
  uint8_t oldDisplay = NS_STYLE_DISPLAY_NONE;
  if (!oldContext) {
    oldContext = GetDisplayContentsStyleFor(aElement);
    if (!oldContext) {
      return nullptr;
    }
    oldDisplay = NS_STYLE_DISPLAY_CONTENTS;
  }

  // The parent has a frame, so try resolving a new context.
  nsRefPtr<nsStyleContext> newContext = mPresShell->StyleSet()->
    ResolveStyleFor(aElement, oldContext->GetParent());

  if (oldDisplay == NS_STYLE_DISPLAY_NONE) {
    ChangeUndisplayedContent(aElement, newContext);
  } else {
    ChangeDisplayContents(aElement, newContext);
  }

  const nsStyleDisplay* disp = newContext->StyleDisplay();
  if (oldDisplay == disp->mDisplay) {
    // We can skip trying to recreate frames here, but only if our style
    // context does not have a binding URI that differs from our old one.
    // Otherwise, we should try to recreate, because we may want to apply the
    // new binding
    if (!disp->mBinding) {
      return newContext;
    }
    const nsStyleDisplay* oldDisp = oldContext->PeekStyleDisplay();
    if (oldDisp && EqualURIs(disp->mBinding, oldDisp->mBinding)) {
      return newContext;
    }
  }

  RecreateFramesForContent(aElement, false);
  return nullptr;
}

static nsIFrame*
FindFirstNonWhitespaceChild(nsIFrame* aParentFrame)
{
  nsIFrame* f = aParentFrame->GetFirstPrincipalChild();
  while (f && f->GetType() == nsGkAtoms::textFrame &&
         f->GetContent()->TextIsOnlyWhitespace()) {





                        nsContainerFrame*        aScrolledFrame,
                        nsIContent*              aContent,
                        nsContainerFrame*        aParentFrame,
                        nsStyleContext*          aStyleContext,
                        bool                     aBuildCombobox,
                        PendingBinding*          aPendingBinding,
                        nsFrameItems&            aFrameItems);

  /**
   * ReResolve style for aElement then recreate frames if required.
   * Do nothing for other types of style changes, except for undisplayed nodes
   * (display:none/contents) which will have their style context updated in the
   * frame manager undisplayed maps.
   * @return null if frames were recreated, the new style context otherwise
   */
  nsStyleContext* MaybeRecreateFramesForElement(Element* aElement);

  // If aAsyncInsert is true then a restyle event will be posted to handle the
  // required ContentInserted call instead of doing it immediately.
  nsresult RecreateFramesForContent(nsIContent* aContent, bool aAsyncInsert);

  // If removal of aFrame from the frame tree requires reconstruction of some
  // containing block (either of aFrame or of its parent) due to {ib} splits or
  // table pseudo-frames, recreate the relevant frame subtree.  The return value

-      Line
+  Link Here
-       Lines 1011-1093
      nsLayoutUtils::LastContinuationWithChild
+  Link Here
   NS_PRECONDITION(aFrame, "NULL frame pointer");
   nsIFrame* f = aFrame->LastContinuation();
   while (!f->GetFirstPrincipalChild() && f->GetPrevContinuation()) {
     f = f->GetPrevContinuation();
+  }
   return static_cast<nsContainerFrame*>(f);
+}
+/**
+ * GetFirstChildFrame returns the first "real" child frame of a
+ * given frame.  It will descend down into pseudo-frames (unless the
+ * pseudo-frame is the :before generated frame).
+ * @param aFrame the frame
+ * @param aFrame the frame's content node
+ */
+static nsIFrame*
+GetFirstChildFrame(nsIFrame*       aFrame,
+                   nsIContent*     aContent)
+{
+  NS_PRECONDITION(aFrame, "NULL frame pointer");
+  // Get the first child frame
+  nsIFrame* childFrame = aFrame->GetFirstPrincipalChild();
+  // If the child frame is a pseudo-frame, then return its first child.
+  // Note that the frame we create for the generated content is also a
+  // pseudo-frame and so don't drill down in that case
+  if (childFrame &&
+      childFrame->IsPseudoFrame(aContent) &&
+      !childFrame->IsGeneratedContentFrame()) {
+    return GetFirstChildFrame(childFrame, aContent);
+  }
+  return childFrame;
+}
+/**
+ * GetLastChildFrame returns the last "real" child frame of a
+ * given frame.  It will descend down into pseudo-frames (unless the
+ * pseudo-frame is the :after generated frame).
+ * @param aFrame the frame
+ * @param aFrame the frame's content node
+ */
+static nsIFrame*
+GetLastChildFrame(nsContainerFrame* aFrame,
+                  nsIContent*       aContent)
+{
+  NS_PRECONDITION(aFrame, "NULL frame pointer");
+  // Get the last continuation frame that's a parent
+  nsContainerFrame* lastParentContinuation =
+    nsLayoutUtils::LastContinuationWithChild(aFrame);
+  nsIFrame* lastChildFrame =
+    lastParentContinuation->GetLastChild(nsIFrame::kPrincipalList);
+  if (lastChildFrame) {
+    // Get the frame's first continuation. This matters in case the frame has
+    // been continued across multiple lines or split by BiDi resolution.
+    lastChildFrame = lastChildFrame->FirstContinuation();
+    // If the last child frame is a pseudo-frame, then return its last child.
+    // Note that the frame we create for the generated content is also a
+    // pseudo-frame and so don't drill down in that case
+    if (lastChildFrame &&
+        lastChildFrame->IsPseudoFrame(aContent) &&
+        !lastChildFrame->IsGeneratedContentFrame()) {
+      return GetLastChildFrame(static_cast<nsContainerFrame*>(lastChildFrame),
+                               aContent);
+    }
+    return lastChildFrame;
+  }
+  return nullptr;
+}
 //static
 FrameChildListID
 nsLayoutUtils::GetChildListNameFor(nsIFrame* aChildFrame)
+{
   nsIFrame::ChildListID id = nsIFrame::kPrincipalList;
   if (aChildFrame->GetStateBits() & NS_FRAME_IS_OVERFLOW_CONTAINER) {
     nsIFrame* pif = aChildFrame->GetPrevInFlow();
-       Lines 1176-1229
      nsLayoutUtils::GetChildListNameFor(nsIFr
+  Link Here
     // else it's positioned and should have been on the 'id' child list.
     NS_POSTCONDITION(found, "not in child list");
+  }
 #endif
   return id;
+}
+/*static*/ nsIFrame*
+nsLayoutUtils::GetBeforeFrameForContent(nsIFrame* aFrame,
+                                        nsIContent* aContent)
+{
+  nsContainerFrame* genConParentFrame = aFrame->GetContentInsertionFrame();
+  if (!genConParentFrame) {
+    return nullptr;
+  }
+  nsTArray<nsIContent*>* prop = genConParentFrame->GetGenConPseudos();
+  if (prop) {
+    const nsTArray<nsIContent*>& pseudos(*prop);
+    for (uint32_t i = 0; i < pseudos.Length(); ++i) {
+      if (pseudos[i]->GetParent() == aContent &&
+          pseudos[i]->Tag() == nsGkAtoms::mozgeneratedcontentbefore) {
+        return pseudos[i]->GetPrimaryFrame();
+      }
+    }
+  }
+  // If the first child frame is a pseudo-frame, then try that.
+  // Note that the frame we create for the generated content is also a
+  // pseudo-frame and so don't drill down in that case.
+  nsIFrame* childFrame = genConParentFrame->GetFirstPrincipalChild();
+  if (childFrame &&
+      childFrame->IsPseudoFrame(aContent) &&
+      !childFrame->IsGeneratedContentFrame()) {
+    return GetBeforeFrameForContent(childFrame, aContent);
+  }
+  return nullptr;
+}
+/*static*/ nsIFrame*
 nsLayoutUtils::GetBeforeFrame(nsIFrame* aFrame)
+{
+  return GetBeforeFrameForContent(aFrame, aFrame->GetContent());
+}
+/*static*/ nsIFrame*
+nsLayoutUtils::GetAfterFrameForContent(nsIFrame* aFrame,
+                                       nsIContent* aContent)
+{
+  nsContainerFrame* genConParentFrame = aFrame->GetContentInsertionFrame();
+  if (!genConParentFrame) {
     return nullptr;
+  }
+  nsTArray<nsIContent*>* prop = genConParentFrame->GetGenConPseudos();
+  if (prop) {
+    const nsTArray<nsIContent*>& pseudos(*prop);
+    for (uint32_t i = 0; i < pseudos.Length(); ++i) {
+      if (pseudos[i]->GetParent() == aContent &&
+          pseudos[i]->Tag() == nsGkAtoms::mozgeneratedcontentafter) {
+        return pseudos[i]->GetPrimaryFrame();
+      }
+    }
+  }
+  // If the last child frame is a pseudo-frame, then try that.
+  // Note that the frame we create for the generated content is also a
+  // pseudo-frame and so don't drill down in that case.
+  nsIFrame* lastParentContinuation =
+    nsLayoutUtils::LastContinuationWithChild(genConParentFrame);
+  nsIFrame* childFrame =
+    lastParentContinuation->GetLastChild(nsIFrame::kPrincipalList);
+  if (childFrame &&
+      childFrame->IsPseudoFrame(aContent) &&
+      !childFrame->IsGeneratedContentFrame()) {
+    return GetAfterFrameForContent(childFrame->FirstContinuation(), aContent);
+  }
   return nullptr;
+}
+/*static*/ nsIFrame*
 nsLayoutUtils::GetAfterFrame(nsIFrame* aFrame)
+{
+  return GetAfterFrameForContent(aFrame, aFrame->GetContent());
+  nsContainerFrame* cif = aFrame->GetContentInsertionFrame();
+  if (!cif) {
+    return nullptr;
+  }
+  nsIFrame* lastFrame = GetLastChildFrame(cif, aFrame->GetContent());
+  if (lastFrame && IsGeneratedContentFor(nullptr, lastFrame,
+                                         nsCSSPseudoElements::after)) {
+    return lastFrame;
+  }
+  return nullptr;
+}
 // static
 nsIFrame*
 nsLayoutUtils::GetClosestFrameOfType(nsIFrame* aFrame, nsIAtom* aFrameType)
+{
   for (nsIFrame* frame = aFrame; frame; frame = frame->GetParent()) {
     if (frame->GetType() == aFrameType) {






  /**
   * Use heuristics to figure out the child list that
   * aChildFrame is currently in.
   */
  static mozilla::layout::FrameChildListID GetChildListNameFor(nsIFrame* aChildFrame);

  /**
   * GetBeforeFrameForContent returns the ::before frame for aContent, if
   * one exists.  This is typically O(1).  The frame passed in must be
   * the first-in-flow.
   *
   * @param aGenConParentFrame an ancestor of the ::before frame
   * @param aContent the content whose ::before is wanted
   * @return the ::before frame or nullptr if there isn't one
   */
  static nsIFrame* GetBeforeFrameForContent(nsIFrame* aGenConParentFrame,
                                            nsIContent* aContent);

  /**
   * GetBeforeFrame returns the outermost ::before frame of the given frame, if
   * one exists.  This is typically O(1).  The frame passed in must be
   * the first-in-flow.
   *
   * @param aFrame the frame whose ::before is wanted
   * @return the :before frame or nullptr if there isn't one
   */
  static nsIFrame* GetBeforeFrame(nsIFrame* aFrame);

  /**
   * GetAfterFrameForContent returns the ::after frame for aContent, if one
   * exists.  This will walk the in-flow chain of aGenConParentFrame to the
   * last-in-flow if needed.  This function is typically O(N) in the number
   * of child frames, following in-flows, etc.
   *
   * @param aGenConParentFrame an ancestor of the ::after frame
   * @param aContent the content whose ::after is wanted
   * @return the ::after frame or nullptr if there isn't one
   */
  static nsIFrame* GetAfterFrameForContent(nsIFrame* aGenConParentFrame,
                                           nsIContent* aContent);

  /**
   * GetAfterFrame returns the outermost ::after frame of the given frame, if one
   * exists.  This will walk the in-flow chain to the last-in-flow if
   * needed.  This function is typically O(N) in the number of child
   * frames, following in-flows, etc.
   *
   * @param aFrame the frame whose ::after is wanted
   * @return the :after frame or nullptr if there isn't one
   */
  static nsIFrame* GetAfterFrame(nsIFrame* aFrame);

  /**
   * Given a frame, search up the frame tree until we find an
   * ancestor that (or the frame itself) is of type aFrameType, if any.
   *





}

void
nsIFrame::DestroyRegion(void* aPropertyValue)
{
  delete static_cast<nsRegion*>(aPropertyValue);
}

/*static*/ void
nsIFrame::DestroyContentArray(void* aPropertyValue)
{
  typedef nsTArray<nsIContent*> T;
  T* arr = static_cast<T*>(aPropertyValue);
  for (T::size_type i = 0; i < arr->Length(); ++i) {
    nsIContent* content = (*arr)[i];
    content->UnbindFromTree();
    NS_RELEASE(content);
  }
  delete arr;
}

bool
nsIFrame::IsPseudoStackingContextFromStyle() {
  const nsStyleDisplay* disp = StyleDisplay();
  // If you change this, also change the computation of pseudoStackingContext
  // in BuildDisplayListForChild()
  return disp->mOpacity != 1.0f ||
         disp->IsPositioned(this) ||
         disp->IsFloating(this) ||






  static void DestroyOverflowAreas(void* aPropertyValue)
  {
    delete static_cast<nsOverflowAreas*>(aPropertyValue);
  }

  static void DestroySurface(void* aPropertyValue);
  static void DestroyDT(void* aPropertyValue);
  static void DestroyContentArray(void* aPropertyValue);

#ifdef _MSC_VER
// XXX Workaround MSVC issue by making the static FramePropertyDescriptor
// non-const.  See bug 555727.
#define NS_PROPERTY_DESCRIPTOR_CONST
#else
#define NS_PROPERTY_DESCRIPTOR_CONST const
#endif


  NS_DECLARE_FRAME_PROPERTY(CachedBackgroundImage, DestroySurface)
  NS_DECLARE_FRAME_PROPERTY(CachedBackgroundImageDT, DestroyDT)

  NS_DECLARE_FRAME_PROPERTY(InvalidationRect, DestroyRect)

  NS_DECLARE_FRAME_PROPERTY(RefusedAsyncAnimation, nullptr)

  NS_DECLARE_FRAME_PROPERTY(GenConProperty, DestroyContentArray)

  nsTArray<nsIContent*>* GetGenConPseudos() {
    const FramePropertyDescriptor* prop = GenConProperty();
    return static_cast<nsTArray<nsIContent*>*>(Properties().Get(prop));
  }

  /**
   * Return the distance between the border edge of the frame and the
   * margin edge of the frame.  Like GetRect(), returns the dimensions
   * as of the most recent reflow.
   *
   * This doesn't include any margin collapsing that may have occurred.
   *
   * It also treats 'auto' margins as zero, and treats any margins that

Return to bug 907396