Attachment #802692 for bug #907396

Attachment #802692: 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





    FrameConstructor()->RecreateFramesForContent(aElement, false);
  } else if (aPrimaryFrame) {
    nsStyleChangeList changeList;
    ComputeStyleChangeFor(aPrimaryFrame, &changeList, aMinHint,
                          aRestyleTracker, aRestyleDescendants);
    ProcessRestyledFrames(changeList);
  } else {
    // no frames, reconstruct for content
    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.
      nsStyleChangeList changeList;
      {
        // First, reresolve contexts for descendant undisplayed content.
        TreeMatchContext treeMatchContext(true,
                                          nsRuleWalker::eRelevantLinkUnvisited,
                                          mPresContext->Document());
        nsIContent* parent = aElement->GetParent();
        Element* parentElement =
          parent && parent->IsElement() ? parent->AsElement() : nullptr;
        treeMatchContext.InitAncestors(parentElement);
        nsTArray<nsIContent*> visibleKidsOfHiddenElement;
        ElementRestyler restyler(mPresContext, aElement, &changeList,
                                 aMinHint, aRestyleTracker,
                                 treeMatchContext,
                                 visibleKidsOfHiddenElement);
        restyler.DoRestyleUndisplayedDescendants(nsRestyleHint(0), aElement,
                                                 newContext);
      }
      // Then process child frames for content that is a descendant of aElement.
      // 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 aElement's old context? (instead of the
      // XXX ContentIsDescendantOf check below)
      nsIFrame* ancestorFrame = nullptr;
      for (nsIContent* ancestor = aElement->GetParent();
           ancestor && !ancestorFrame;
           ancestor = ancestor->GetParent()) {
        ancestorFrame = ancestor->GetPrimaryFrame();
      }
      MOZ_ASSERT(ancestorFrame, "display:contents node in map although it's a "
                                "display:none descendant?");
      nsIFrame::ChildListIterator lists(ancestorFrame);
      for ( ; !lists.IsDone(); lists.Next()) {
        nsFrameList::Enumerator childFrames(lists.CurrentList());
        for (; !childFrames.AtEnd(); childFrames.Next()) {
          nsIFrame* f = childFrames.get();
          nsIContent* c = f->GetContent();
          if (nsContentUtils::ContentIsDescendantOf(c, aElement) &&
              !f->GetPrevContinuation()) {
            if (!(f->GetStateBits() & NS_FRAME_OUT_OF_FLOW)) {
              ComputeStyleChangeFor(f, &changeList, aMinHint,
                                    aRestyleTracker, aRestyleDescendants);
            }
          }
        }
      }
      ProcessRestyledFrames(changeList);
    }
  }
}

// Forwarded nsIDocumentObserver method, to handle restyling (and
// passing the notification to the frame).
nsresult
RestyleManager::ContentStateChanged(nsIContent* aContent,
                                    nsEventStates aStateMask)

  , 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)
{
  // Check some invariants about replacing one style context with another.
  NS_ASSERTION(aOldContext->GetPseudo() == aNewContext->GetPseudo(),
               "old and new style contexts should have the same pseudo");

    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;
  for (TreeMatchContext::AutoAncestorPusher
         pushAncestor(undisplayed, mTreeMatchContext,
                      undisplayedParent ? undisplayedParent->AsElement()
                                        : nullptr);

      thisChildHint =
        nsRestyleHint(thisChildHint | undisplayedRestyleData.mRestyleHint);
    }
    nsRefPtr<nsStyleContext> undisplayedContext;
    nsStyleSet* styleSet = mPresContext->StyleSet();
    if (thisChildHint) {
      undisplayedContext =
        styleSet->ResolveStyleFor(undisplayed->mContent->AsElement(),
                                  aParentContext,
                                  mTreeMatchContext);
    } else {
      undisplayedContext =
        styleSet->ReparentStyleContext(undisplayed->mStyle,
                                       aParentContext,
                                       undisplayed->mContent->AsElement());
    }
    const nsStyleDisplay* display = undisplayedContext->StyleDisplay();
    if (display->mDisplay != aDisplay) {
      NS_ASSERTION(undisplayed->mContent, "Must have undisplayed content");
      mChangeList->AppendChange(nullptr, undisplayed->mContent,
                                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, undisplayed->mContent,
                                        undisplayed->mStyle);
      }
    }
  }
}

void
ElementRestyler::RestyleBeforePseudo()
{





   * 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; }

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

  /**
   * First half of Restyle().
   */
  void RestyleSelf(nsRestyleHint aRestyleHint);

  /**
   * Restyle the children of this frame (and, in turn, their children).
   *

                     nsStyleContext* aNewContext,
                     nsChangeHint aChangeToAssume);

  /**
   * 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 RestyleBeforePseudo();
  void RestyleAfterPseudo();
  void RestyleContentChildren(nsRestyleHint aChildRestyleHint);
  void InitializeAccessibilityNotifications();
  void SendAccessibilityNotifications();

  enum DesiredA11yNotifications {






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 = GetDisplayContents(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()) {





                        nsIFrame*                scrolledFrame,
                        nsIContent*              aContent,
                        nsIFrame*                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

Return to bug 907396