The Tor Browser / file revision

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

 // vim:cindent:ts=2:et:sw=2:

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

 /* base class of all rendering objects */

 #include "nsFrame.h"

 #include "mozilla/Attributes.h"

 #include "mozilla/DebugOnly.h"

 #include "nsCOMPtr.h"

 #include "nsFrameList.h"

 #include "nsPlaceholderFrame.h"

 #include "nsIContent.h"

 #include "nsContentUtils.h"

 #include "nsIAtom.h"

 #include "nsString.h"

 #include "nsReadableUtils.h"

 #include "nsStyleContext.h"

 #include "nsTableOuterFrame.h"

 #include "nsView.h"

 #include "nsViewManager.h"

 #include "nsIScrollableFrame.h"

 #include "nsPresContext.h"

 #include "nsStyleConsts.h"

 #include "nsIPresShell.h"

 #include "prlog.h"

 #include "prprf.h"

 #include <stdarg.h>

 #include "nsFrameManager.h"

 #include "nsLayoutUtils.h"

 #include "nsIDOMNode.h"

 #include "nsISelection.h"

 #include "nsISelectionPrivate.h"

 #include "nsFrameSelection.h"

 #include "nsGkAtoms.h"

 #include "nsCSSAnonBoxes.h"

 #include "nsFrameTraversal.h"

 #include "nsRange.h"

 #include "nsITextControlFrame.h"

 #include "nsNameSpaceManager.h"

 #include "nsIPercentHeightObserver.h"

 #include "nsStyleStructInlines.h"

 #include <algorithm>

 #include "nsBidiPresUtils.h"

 // For triple-click pref

 #include "imgIContainer.h"

 #include "imgIRequest.h"

 #include "nsError.h"

 #include "nsContainerFrame.h"

 #include "nsBoxLayoutState.h"

 #include "nsBlockFrame.h"

 #include "nsDisplayList.h"

 #include "nsSVGIntegrationUtils.h"

 #include "nsSVGEffects.h"

 #include "nsChangeHint.h"

 #include "nsDeckFrame.h"

 #include "nsSubDocumentFrame.h"

 #include "SVGTextFrame.h"

 #include "gfxContext.h"

 #include "nsRenderingContext.h"

 #include "nsAbsoluteContainingBlock.h"

 #include "StickyScrollContainer.h"

 #include "nsFontInflationData.h"

 #include "gfxASurface.h"

 #include "nsRegion.h"

 #include "nsIFrameInlines.h"

 #include "mozilla/AsyncEventDispatcher.h"

 #include "mozilla/EventListenerManager.h"

 #include "mozilla/EventStateManager.h"

 #include "mozilla/EventStates.h"

 #include "mozilla/Preferences.h"

 #include "mozilla/LookAndFeel.h"

 #include "mozilla/MouseEvents.h"

 #include "mozilla/css/ImageLoader.h"

 #include "mozilla/gfx/Tools.h"

 #include "nsPrintfCString.h"

 using namespace mozilla;

 using namespace mozilla::css;

 using namespace mozilla::dom;

 using namespace mozilla::layers;

 using namespace mozilla::layout;

 // Struct containing cached metrics for box-wrapped frames.

 struct nsBoxLayoutMetrics

 {

   nsSize mPrefSize;

   nsSize mMinSize;

   nsSize mMaxSize;

   nsSize mBlockMinSize;

   nsSize mBlockPrefSize;

   nscoord mBlockAscent;

   nscoord mFlex;

   nscoord mAscent;

   nsSize mLastSize;

 };

 struct nsContentAndOffset

 {

   nsIContent* mContent;

   int32_t mOffset;

 };

 // Some Misc #defines

 #define SELECTION_DEBUG        0

 #define FORCE_SELECTION_UPDATE 1

 #define CALC_DEBUG             0

 #include "nsILineIterator.h"

 //non Hack prototypes

 #if 0

 static void RefreshContentFrames(nsPresContext* aPresContext, nsIContent * aStartContent, nsIContent * aEndContent);

 #endif

 #include "prenv.h"

 // Formerly the nsIFrameDebug interface

 #ifdef DEBUG

 static bool gShowFrameBorders = false;

 void nsFrame::ShowFrameBorders(bool aEnable)

 {

   gShowFrameBorders = aEnable;

 }

 bool nsFrame::GetShowFrameBorders()

 {

   return gShowFrameBorders;

 }

 static bool gShowEventTargetFrameBorder = false;

 void nsFrame::ShowEventTargetFrameBorder(bool aEnable)

 {

   gShowEventTargetFrameBorder = aEnable;

 }

 bool nsFrame::GetShowEventTargetFrameBorder()

 {

   return gShowEventTargetFrameBorder;

 }

 /**

  * Note: the log module is created during library initialization which

  * means that you cannot perform logging before then.

  */

 static PRLogModuleInfo* gLogModule;

 static PRLogModuleInfo* gStyleVerifyTreeLogModuleInfo;

 static uint32_t gStyleVerifyTreeEnable = 0x55;

 bool

 nsFrame::GetVerifyStyleTreeEnable()

 {

   if (gStyleVerifyTreeEnable == 0x55) {

     if (nullptr == gStyleVerifyTreeLogModuleInfo) {

       gStyleVerifyTreeLogModuleInfo = PR_NewLogModule("styleverifytree");

       gStyleVerifyTreeEnable = 0 != gStyleVerifyTreeLogModuleInfo->level;

     }

   }

   return gStyleVerifyTreeEnable;

 }

 void

 nsFrame::SetVerifyStyleTreeEnable(bool aEnabled)

 {

   gStyleVerifyTreeEnable = aEnabled;

 }

 PRLogModuleInfo*

 nsFrame::GetLogModuleInfo()

 {

   if (nullptr == gLogModule) {

     gLogModule = PR_NewLogModule("frame");

   }

   return gLogModule;

 }

 #endif

 static void

 DestroyAbsoluteContainingBlock(void* aPropertyValue)

 {

   delete static_cast<nsAbsoluteContainingBlock*>(aPropertyValue);

 }

 NS_DECLARE_FRAME_PROPERTY(AbsoluteContainingBlockProperty, DestroyAbsoluteContainingBlock)

 bool

 nsIFrame::HasAbsolutelyPositionedChildren() const {

   return IsAbsoluteContainer() && GetAbsoluteContainingBlock()->HasAbsoluteFrames();

 }

 nsAbsoluteContainingBlock*

 nsIFrame::GetAbsoluteContainingBlock() const {

   NS_ASSERTION(IsAbsoluteContainer(), "The frame is not marked as an abspos container correctly");

   nsAbsoluteContainingBlock* absCB = static_cast<nsAbsoluteContainingBlock*>

     (Properties().Get(AbsoluteContainingBlockProperty()));

   NS_ASSERTION(absCB, "The frame is marked as an abspos container but doesn't have the property");

   return absCB;

 }

 void

 nsIFrame::MarkAsAbsoluteContainingBlock()

 {

   MOZ_ASSERT(GetStateBits() & NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN);

   NS_ASSERTION(!Properties().Get(AbsoluteContainingBlockProperty()),

                "Already has an abs-pos containing block property?");

   NS_ASSERTION(!HasAnyStateBits(NS_FRAME_HAS_ABSPOS_CHILDREN),

                "Already has NS_FRAME_HAS_ABSPOS_CHILDREN state bit?");

   AddStateBits(NS_FRAME_HAS_ABSPOS_CHILDREN);

   Properties().Set(AbsoluteContainingBlockProperty(), new nsAbsoluteContainingBlock(GetAbsoluteListID()));

 }

 void

 nsIFrame::MarkAsNotAbsoluteContainingBlock()

 {

   NS_ASSERTION(!HasAbsolutelyPositionedChildren(), "Think of the children!");

   NS_ASSERTION(Properties().Get(AbsoluteContainingBlockProperty()),

                "Should have an abs-pos containing block property");

   NS_ASSERTION(HasAnyStateBits(NS_FRAME_HAS_ABSPOS_CHILDREN),

                "Should have NS_FRAME_HAS_ABSPOS_CHILDREN state bit");

   MOZ_ASSERT(HasAnyStateBits(NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN));

   RemoveStateBits(NS_FRAME_HAS_ABSPOS_CHILDREN);

   Properties().Delete(AbsoluteContainingBlockProperty());

 }

 bool

 nsIFrame::CheckAndClearPaintedState()

 {

   bool result = (GetStateBits() & NS_FRAME_PAINTED_THEBES);

   RemoveStateBits(NS_FRAME_PAINTED_THEBES);

   nsIFrame::ChildListIterator lists(this);

   for (; !lists.IsDone(); lists.Next()) {

     nsFrameList::Enumerator childFrames(lists.CurrentList());

     for (; !childFrames.AtEnd(); childFrames.Next()) {

       nsIFrame* child = childFrames.get();

       if (child->CheckAndClearPaintedState()) {

         result = true;

       }

     }

   }

   return result;

 }

 bool

 nsIFrame::IsVisibleConsideringAncestors(uint32_t aFlags) const

 {

   if (!StyleVisibility()->IsVisible()) {

     return false;

   }

   const nsIFrame* frame = this;

   while (frame) {

     nsView* view = frame->GetView();

     if (view && view->GetVisibility() == nsViewVisibility_kHide)

       return false;

     nsIFrame* parent = frame->GetParent();

     nsDeckFrame* deck = do_QueryFrame(parent);

     if (deck) {

       if (deck->GetSelectedBox() != frame)

         return false;

     }

     if (parent) {

       frame = parent;

     } else {

       parent = nsLayoutUtils::GetCrossDocParentFrame(frame);

       if (!parent)

         break;

       if ((aFlags & nsIFrame::VISIBILITY_CROSS_CHROME_CONTENT_BOUNDARY) == 0 &&

           parent->PresContext()->IsChrome() && !frame->PresContext()->IsChrome()) {

         break;

       }

       if (!parent->StyleVisibility()->IsVisible())

         return false;

       frame = parent;

     }

   }

   return true;

 }

 void

 nsIFrame::FindCloserFrameForSelection(

                                  nsPoint aPoint,

                                  nsIFrame::FrameWithDistance* aCurrentBestFrame)

 {

   if (nsLayoutUtils::PointIsCloserToRect(aPoint, mRect,

                                          aCurrentBestFrame->mXDistance,

                                          aCurrentBestFrame->mYDistance)) {

     aCurrentBestFrame->mFrame = this;

   }

 }

 void

 nsIFrame::ContentStatesChanged(mozilla::EventStates aStates)

 {

 }

 void

 NS_MergeReflowStatusInto(nsReflowStatus* aPrimary, nsReflowStatus aSecondary)

 {

   *aPrimary |= aSecondary &

     (NS_FRAME_NOT_COMPLETE | NS_FRAME_OVERFLOW_INCOMPLETE |

      NS_FRAME_TRUNCATED | NS_FRAME_REFLOW_NEXTINFLOW);

   if (*aPrimary & NS_FRAME_NOT_COMPLETE) {

     *aPrimary &= ~NS_FRAME_OVERFLOW_INCOMPLETE;

   }

 }

 void

 nsWeakFrame::Init(nsIFrame* aFrame)

 {

   Clear(mFrame ? mFrame->PresContext()->GetPresShell() : nullptr);

   mFrame = aFrame;

   if (mFrame) {

     nsIPresShell* shell = mFrame->PresContext()->GetPresShell();

     NS_WARN_IF_FALSE(shell, "Null PresShell in nsWeakFrame!");

     if (shell) {

       shell->AddWeakFrame(this);

     } else {

       mFrame = nullptr;

     }

   }

 }

 nsIFrame*

 NS_NewEmptyFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)

 {

   return new (aPresShell) nsFrame(aContext);

 }

 nsFrame::nsFrame(nsStyleContext* aContext)

 {

   MOZ_COUNT_CTOR(nsFrame);

   mState = NS_FRAME_FIRST_REFLOW | NS_FRAME_IS_DIRTY;

   mStyleContext = aContext;

   mStyleContext->AddRef();

 }

 nsFrame::~nsFrame()

 {

   MOZ_COUNT_DTOR(nsFrame);

   NS_IF_RELEASE(mContent);

   mStyleContext->Release();

 }

 NS_IMPL_FRAMEARENA_HELPERS(nsFrame)

 // Dummy operator delete.  Will never be called, but must be defined

 // to satisfy some C++ ABIs.

 void

 nsFrame::operator delete(void *, size_t)

 {

   NS_RUNTIMEABORT("nsFrame::operator delete should never be called");

 }

 NS_QUERYFRAME_HEAD(nsFrame)

   NS_QUERYFRAME_ENTRY(nsIFrame)

 NS_QUERYFRAME_TAIL_INHERITANCE_ROOT

 /////////////////////////////////////////////////////////////////////////////

 // nsIFrame

 static bool

 IsFontSizeInflationContainer(nsIFrame* aFrame,

                              const nsStyleDisplay* aStyleDisplay)

 {

   /*

    * Font size inflation is built around the idea that we're inflating

    * the fonts for a pan-and-zoom UI so that when the user scales up a

    * block or other container to fill the width of the device, the fonts

    * will be readable.  To do this, we need to pick what counts as a

    * container.

    *

    * From a code perspective, the only hard requirement is that frames

    * that are line participants

    * (nsIFrame::IsFrameOfType(nsIFrame::eLineParticipant)) are never

    * containers, since line layout assumes that the inflation is

    * consistent within a line.

    *

    * This is not an imposition, since we obviously want a bunch of text

    * (possibly with inline elements) flowing within a block to count the

    * block (or higher) as its container.

    *

    * We also want form controls, including the text in the anonymous

    * content inside of them, to match each other and the text next to

    * them, so they and their anonymous content should also not be a

    * container.

    *

    * However, because we can't reliably compute sizes across XUL during

    * reflow, any XUL frame with a XUL parent is always a container.

    *

    * There are contexts where it would be nice if some blocks didn't

    * count as a container, so that, for example, an indented quotation

    * didn't end up with a smaller font size.  However, it's hard to

    * distinguish these situations where we really do want the indented

    * thing to count as a container, so we don't try, and blocks are

    * always containers.

    */

   // The root frame should always be an inflation container.

   if (!aFrame->GetParent()) {

     return true;

   }

   nsIContent *content = aFrame->GetContent();

   bool isInline = (aFrame->GetDisplay() == NS_STYLE_DISPLAY_INLINE ||

                    (aFrame->IsFloating() &&

                     aFrame->GetType() == nsGkAtoms::letterFrame) ||

                    // Given multiple frames for the same node, only the

                    // outer one should be considered a container.

                    // (Important, e.g., for nsSelectsAreaFrame.)

                    (aFrame->GetParent()->GetContent() == content) ||

                    (content && (content->IsHTML(nsGkAtoms::option) ||

                                 content->IsHTML(nsGkAtoms::optgroup) ||

                                 content->IsHTML(nsGkAtoms::select) ||

                                 content->IsInNativeAnonymousSubtree()))) &&

                   !(aFrame->IsBoxFrame() && aFrame->GetParent()->IsBoxFrame());

   NS_ASSERTION(!aFrame->IsFrameOfType(nsIFrame::eLineParticipant) ||

                isInline ||

                // br frames and mathml frames report being line

                // participants even when their position or display is

                // set

                aFrame->GetType() == nsGkAtoms::brFrame ||

                aFrame->IsFrameOfType(nsIFrame::eMathML),

                "line participants must not be containers");

   NS_ASSERTION(aFrame->GetType() != nsGkAtoms::bulletFrame || isInline,

                "bullets should not be containers");

   return !isInline;

 }

 void

 nsFrame::Init(nsIContent*      aContent,

               nsIFrame*        aParent,

               nsIFrame*        aPrevInFlow)

 {

   NS_PRECONDITION(!mContent, "Double-initing a frame?");

   NS_ASSERTION(IsFrameOfType(eDEBUGAllFrames) &&

                !IsFrameOfType(eDEBUGNoFrames),

                "IsFrameOfType implementation that doesn't call base class");

   mContent = aContent;

   mParent = aParent;

   if (aContent) {

     NS_ADDREF(aContent);

   }

   if (aPrevInFlow) {

     // Make sure the general flags bits are the same

     nsFrameState state = aPrevInFlow->GetStateBits();

     // Make bits that are currently off (see constructor) the same:

     mState |= state & (NS_FRAME_INDEPENDENT_SELECTION |

                        NS_FRAME_PART_OF_IBSPLIT |

                        NS_FRAME_MAY_BE_TRANSFORMED |

                        NS_FRAME_MAY_HAVE_GENERATED_CONTENT |

                        NS_FRAME_CAN_HAVE_ABSPOS_CHILDREN);

   }

   if (mParent) {

     nsFrameState state = mParent->GetStateBits();

     // Make bits that are currently off (see constructor) the same:

     mState |= state & (NS_FRAME_INDEPENDENT_SELECTION |

                        NS_FRAME_GENERATED_CONTENT |

                        NS_FRAME_IS_SVG_TEXT |

                        NS_FRAME_IN_POPUP |

                        NS_FRAME_IS_NONDISPLAY);

   }

   const nsStyleDisplay *disp = StyleDisplay();

   if (disp->HasTransform(this)) {

     // The frame gets reconstructed if we toggle the -moz-transform

     // property, so we can set this bit here and then ignore it.

     mState |= NS_FRAME_MAY_BE_TRANSFORMED;

   }

   if (disp->mPosition == NS_STYLE_POSITION_STICKY &&

       !aPrevInFlow &&

       !(mState & NS_FRAME_IS_NONDISPLAY) &&

       !disp->IsInnerTableStyle()) {

     // Note that we only add first continuations, but we really only

     // want to add first continuation-or-ib-split-siblings.  But since we

     // don't yet know if we're a later part of a block-in-inline split,

     // we'll just add later members of a block-in-inline split here, and

     // then StickyScrollContainer will remove them later.

     // We don't currently support relative positioning of inner table

     // elements (bug 35168), so exclude them from sticky positioning too.

     StickyScrollContainer* ssc =

       StickyScrollContainer::GetStickyScrollContainerForFrame(this);

     if (ssc) {

       ssc->AddFrame(this);

     }

   }

   if (nsLayoutUtils::FontSizeInflationEnabled(PresContext()) || !GetParent()

 #ifdef DEBUG

       // We have assertions that check inflation invariants even when

       // font size inflation is not enabled.

       || true

 #endif

       ) {

     if (IsFontSizeInflationContainer(this, disp)) {

       AddStateBits(NS_FRAME_FONT_INFLATION_CONTAINER);

       if (!GetParent() ||

           // I'd use NS_FRAME_OUT_OF_FLOW, but it's not set yet.

           disp->IsFloating(this) || disp->IsAbsolutelyPositioned(this)) {

         AddStateBits(NS_FRAME_FONT_INFLATION_FLOW_ROOT);

       }

     }

     NS_ASSERTION(GetParent() ||

                  (GetStateBits() & NS_FRAME_FONT_INFLATION_CONTAINER),

                  "root frame should always be a container");

   }

   DidSetStyleContext(nullptr);

   if (IsBoxWrapped())

     InitBoxMetrics(false);

 }

 nsresult nsFrame::SetInitialChildList(ChildListID     aListID,

                                            nsFrameList&    aChildList)

 {

   // XXX This shouldn't be getting called at all, but currently is for backwards

   // compatility reasons...

 #if 0

   NS_ERROR("not a container");

   return NS_ERROR_UNEXPECTED;

 #else

   NS_ASSERTION(aChildList.IsEmpty(), "not a container");

   return NS_OK;

 #endif

 }

 nsresult

 nsFrame::AppendFrames(ChildListID     aListID,

                       nsFrameList&    aFrameList)

 {

   NS_PRECONDITION(false, "not a container");

   return NS_ERROR_UNEXPECTED;

 }

 nsresult

 nsFrame::InsertFrames(ChildListID     aListID,

                       nsIFrame*       aPrevFrame,

                       nsFrameList&    aFrameList)

 {

   NS_PRECONDITION(false, "not a container");

   return NS_ERROR_UNEXPECTED;

 }

 nsresult

 nsFrame::RemoveFrame(ChildListID     aListID,

                      nsIFrame*       aOldFrame)

 {

   NS_PRECONDITION(false, "not a container");

   return NS_ERROR_UNEXPECTED;

 }

 void

 nsFrame::DestroyFrom(nsIFrame* aDestructRoot)

 {

   NS_ASSERTION(!nsContentUtils::IsSafeToRunScript(),

     "destroy called on frame while scripts not blocked");

   NS_ASSERTION(!GetNextSibling() && !GetPrevSibling(),

                "Frames should be removed before destruction.");

   NS_ASSERTION(aDestructRoot, "Must specify destruct root");

   MOZ_ASSERT(!HasAbsolutelyPositionedChildren());

   nsSVGEffects::InvalidateDirectRenderingObservers(this);

   if (StyleDisplay()->mPosition == NS_STYLE_POSITION_STICKY) {

     StickyScrollContainer* ssc =

       StickyScrollContainer::GetStickyScrollContainerForFrame(this);

     if (ssc) {

       ssc->RemoveFrame(this);

     }

   }

   // Get the view pointer now before the frame properties disappear

   // when we call NotifyDestroyingFrame()

   nsView* view = GetView();

   nsPresContext* presContext = PresContext();

   nsIPresShell *shell = presContext->GetPresShell();

   if (mState & NS_FRAME_OUT_OF_FLOW) {

     nsPlaceholderFrame* placeholder =

       shell->FrameManager()->GetPlaceholderFrameFor(this);

     NS_ASSERTION(!placeholder || (aDestructRoot != this),

                  "Don't call Destroy() on OOFs, call Destroy() on the placeholder.");

     NS_ASSERTION(!placeholder ||

                  nsLayoutUtils::IsProperAncestorFrame(aDestructRoot, placeholder),

                  "Placeholder relationship should have been torn down already; "

                  "this might mean we have a stray placeholder in the tree.");

     if (placeholder) {

       shell->FrameManager()->UnregisterPlaceholderFrame(placeholder);

       placeholder->SetOutOfFlowFrame(nullptr);

     }

   }

   // If we have any IB split siblings, clear their references to us.

   // (Note: This has to happen before we call shell->NotifyDestroyingFrame,

   // because that clears our Properties() table.)

   if (mState & NS_FRAME_PART_OF_IBSPLIT) {

     // Delete previous sibling's reference to me.

     nsIFrame* prevSib = static_cast<nsIFrame*>

       (Properties().Get(nsIFrame::IBSplitPrevSibling()));

     if (prevSib) {

       NS_WARN_IF_FALSE(this ==

          prevSib->Properties().Get(nsIFrame::IBSplitSibling()),

          "IB sibling chain is inconsistent");

       prevSib->Properties().Delete(nsIFrame::IBSplitSibling());

     }

     // Delete next sibling's reference to me.

     nsIFrame* nextSib = static_cast<nsIFrame*>

       (Properties().Get(nsIFrame::IBSplitSibling()));

     if (nextSib) {

       NS_WARN_IF_FALSE(this ==

          nextSib->Properties().Get(nsIFrame::IBSplitPrevSibling()),

          "IB sibling chain is inconsistent");

       nextSib->Properties().Delete(nsIFrame::IBSplitPrevSibling());

     }

   }

   shell->NotifyDestroyingFrame(this);

   if (mState & NS_FRAME_EXTERNAL_REFERENCE) {

     shell->ClearFrameRefs(this);

   }

   if (view) {

     // Break association between view and frame

     view->SetFrame(nullptr);

     // Destroy the view

     view->Destroy();

   }

   // Make sure that our deleted frame can't be returned from GetPrimaryFrame()

   if (mContent && mContent->GetPrimaryFrame() == this) {

     mContent->SetPrimaryFrame(nullptr);

   }

   // Must retrieve the object ID before calling destructors, so the

   // vtable is still valid.

   //

   // Note to future tweakers: having the method that returns the

   // object size call the destructor will not avoid an indirect call;

   // the compiler cannot devirtualize the call to the destructor even

   // if it's from a method defined in the same class.

   nsQueryFrame::FrameIID id = GetFrameId();

   this->~nsFrame();

   // Now that we're totally cleaned out, we need to add ourselves to

   // the presshell's recycler.

   shell->FreeFrame(id, this);

 }

 nsresult

 nsFrame::GetOffsets(int32_t &aStart, int32_t &aEnd) const

 {

   aStart = 0;

   aEnd = 0;

   return NS_OK;

 }

 // Subclass hook for style post processing

 /* virtual */ void

 nsFrame::DidSetStyleContext(nsStyleContext* aOldStyleContext)

 {

   if (IsSVGText()) {

     SVGTextFrame* svgTextFrame = static_cast<SVGTextFrame*>(

         nsLayoutUtils::GetClosestFrameOfType(this, nsGkAtoms::svgTextFrame));

     nsIFrame* anonBlock = svgTextFrame->GetFirstPrincipalChild();

     // Just as in SVGTextFrame::DidSetStyleContext, we need to ensure that

     // any non-display SVGTextFrames get reflowed when a child text frame

     // gets new style.

     //

     // Note that we must check NS_FRAME_FIRST_REFLOW on our SVGTextFrame's

     // anonymous block frame rather than our self, since NS_FRAME_FIRST_REFLOW

     // may be set on us if we're a new frame that has been inserted after the

     // document's first reflow. (In which case this DidSetStyleContext call may

     // be happening under frame construction under a Reflow() call.)

     if (anonBlock && !(anonBlock->GetStateBits() & NS_FRAME_FIRST_REFLOW) &&

         (svgTextFrame->GetStateBits() & NS_FRAME_IS_NONDISPLAY) &&

         !(svgTextFrame->GetStateBits() & NS_STATE_SVG_TEXT_IN_REFLOW)) {

       svgTextFrame->ScheduleReflowSVGNonDisplayText();

     }

   }

   ImageLoader* imageLoader = PresContext()->Document()->StyleImageLoader();

   // If the old context had a background image image and new context

   // does not have the same image, clear the image load notifier

   // (which keeps the image loading, if it still is) for the frame.

   // We want to do this conservatively because some frames paint their

   // backgrounds from some other frame's style data, and we don't want

   // to clear those notifiers unless we have to.  (They'll be reset

   // when we paint, although we could miss a notification in that

   // interval.)

   const nsStyleBackground *oldBG = aOldStyleContext ?

                                    aOldStyleContext->StyleBackground() :

                                    nullptr;

   const nsStyleBackground *newBG = StyleBackground();

   if (oldBG) {

     NS_FOR_VISIBLE_BACKGROUND_LAYERS_BACK_TO_FRONT(i, oldBG) {

       // If there is an image in oldBG that's not in newBG, drop it.

       if (i >= newBG->mImageCount ||

           !oldBG->mLayers[i].mImage.ImageDataEquals(newBG->mLayers[i].mImage)) {

         const nsStyleImage& oldImage = oldBG->mLayers[i].mImage;

         if (oldImage.GetType() != eStyleImageType_Image) {

           continue;

         }

         imageLoader->DisassociateRequestFromFrame(oldImage.GetImageData(),

                                                   this);

       }          

     }

   }

   NS_FOR_VISIBLE_BACKGROUND_LAYERS_BACK_TO_FRONT(i, newBG) {

     // If there is an image in newBG that's not in oldBG, add it.

     if (!oldBG || i >= oldBG->mImageCount ||

         !newBG->mLayers[i].mImage.ImageDataEquals(oldBG->mLayers[i].mImage)) {

       const nsStyleImage& newImage = newBG->mLayers[i].mImage;

       if (newImage.GetType() != eStyleImageType_Image) {

         continue;

       }

       imageLoader->AssociateRequestToFrame(newImage.GetImageData(), this);

     }          

   }

   if (aOldStyleContext) {

     // If we detect a change on margin, padding or border, we store the old

     // values on the frame itself between now and reflow, so if someone

     // calls GetUsed(Margin|Border|Padding)() before the next reflow, we

     // can give an accurate answer.

     // We don't want to set the property if one already exists.

     FrameProperties props = Properties();

     nsMargin oldValue(0, 0, 0, 0);

     nsMargin newValue(0, 0, 0, 0);

     const nsStyleMargin* oldMargin = aOldStyleContext->PeekStyleMargin();

     if (oldMargin && oldMargin->GetMargin(oldValue)) {

       if ((!StyleMargin()->GetMargin(newValue) || oldValue != newValue) &&

           !props.Get(UsedMarginProperty())) {

         props.Set(UsedMarginProperty(), new nsMargin(oldValue));

       }

     }

     const nsStylePadding* oldPadding = aOldStyleContext->PeekStylePadding();

     if (oldPadding && oldPadding->GetPadding(oldValue)) {

       if ((!StylePadding()->GetPadding(newValue) || oldValue != newValue) &&

           !props.Get(UsedPaddingProperty())) {

         props.Set(UsedPaddingProperty(), new nsMargin(oldValue));

       }

     }

     const nsStyleBorder* oldBorder = aOldStyleContext->PeekStyleBorder();

     if (oldBorder) {

       oldValue = oldBorder->GetComputedBorder();

       newValue = StyleBorder()->GetComputedBorder();

       if (oldValue != newValue &&

           !props.Get(UsedBorderProperty())) {

         props.Set(UsedBorderProperty(), new nsMargin(oldValue));

       }

     }

   }

   imgIRequest *oldBorderImage = aOldStyleContext

     ? aOldStyleContext->StyleBorder()->GetBorderImageRequest()

     : nullptr;

   imgIRequest *newBorderImage = StyleBorder()->GetBorderImageRequest();

   // FIXME (Bug 759996): The following is no longer true.

   // For border-images, we can't be as conservative (we need to set the

   // new loaders if there has been any change) since the CalcDifference

   // call depended on the result of GetComputedBorder() and that result

   // depends on whether the image has loaded, start the image load now

   // so that we'll get notified when it completes loading and can do a

   // restyle.  Otherwise, the image might finish loading from the

   // network before we start listening to its notifications, and then

   // we'll never know that it's finished loading.  Likewise, we want to

   // do this for freshly-created frames to prevent a similar race if the

   // image loads between reflow (which can depend on whether the image

   // is loaded) and paint.  We also don't really care about any callers

   // who try to paint borders with a different style context, because

   // they won't have the correct size for the border either.

   if (oldBorderImage != newBorderImage) {

     // stop and restart the image loading/notification

     if (oldBorderImage) {

       imageLoader->DisassociateRequestFromFrame(oldBorderImage, this);

     }

     if (newBorderImage) {

       imageLoader->AssociateRequestToFrame(newBorderImage, this);

     }

   }

   // If the page contains markup that overrides text direction, and

   // does not contain any characters that would activate the Unicode

   // bidi algorithm, we need to call |SetBidiEnabled| on the pres

   // context before reflow starts.  See bug 115921.

   if (StyleVisibility()->mDirection == NS_STYLE_DIRECTION_RTL) {

     PresContext()->SetBidiEnabled();

   }

 }

 // MSVC fails with link error "one or more multiply defined symbols found",

 // gcc fails with "hidden symbol `nsIFrame::kPrincipalList' isn't defined"

 // etc if they are not defined.

 #ifndef _MSC_VER

 // static nsIFrame constants; initialized in the header file.

 const nsIFrame::ChildListID nsIFrame::kPrincipalList;

 const nsIFrame::ChildListID nsIFrame::kAbsoluteList;

 const nsIFrame::ChildListID nsIFrame::kBulletList;

 const nsIFrame::ChildListID nsIFrame::kCaptionList;

 const nsIFrame::ChildListID nsIFrame::kColGroupList;

 const nsIFrame::ChildListID nsIFrame::kExcessOverflowContainersList;

 const nsIFrame::ChildListID nsIFrame::kFixedList;

 const nsIFrame::ChildListID nsIFrame::kFloatList;

 const nsIFrame::ChildListID nsIFrame::kOverflowContainersList;

 const nsIFrame::ChildListID nsIFrame::kOverflowList;

 const nsIFrame::ChildListID nsIFrame::kOverflowOutOfFlowList;

 const nsIFrame::ChildListID nsIFrame::kPopupList;

 const nsIFrame::ChildListID nsIFrame::kPushedFloatsList;

 const nsIFrame::ChildListID nsIFrame::kSelectPopupList;

 const nsIFrame::ChildListID nsIFrame::kNoReflowPrincipalList;

 #endif

 /* virtual */ nsMargin

 nsIFrame::GetUsedMargin() const

 {

   nsMargin margin(0, 0, 0, 0);

   if (((mState & NS_FRAME_FIRST_REFLOW) &&

        !(mState & NS_FRAME_IN_REFLOW)) ||

       IsSVGText())

     return margin;

   nsMargin *m = static_cast<nsMargin*>

                            (Properties().Get(UsedMarginProperty()));

   if (m) {

     margin = *m;

   } else {

     DebugOnly<bool> hasMargin = StyleMargin()->GetMargin(margin);

     NS_ASSERTION(hasMargin, "We should have a margin here! (out of memory?)");

   }

   return margin;

 }

 /* virtual */ nsMargin

 nsIFrame::GetUsedBorder() const

 {

   nsMargin border(0, 0, 0, 0);

   if (((mState & NS_FRAME_FIRST_REFLOW) &&

        !(mState & NS_FRAME_IN_REFLOW)) ||

       IsSVGText())

     return border;

   // Theme methods don't use const-ness.

   nsIFrame *mutable_this = const_cast<nsIFrame*>(this);

   const nsStyleDisplay *disp = StyleDisplay();

   if (mutable_this->IsThemed(disp)) {

     nsIntMargin result;

     nsPresContext *presContext = PresContext();

     presContext->GetTheme()->GetWidgetBorder(presContext->DeviceContext(),

                                              mutable_this, disp->mAppearance,

                                              &result);

     border.left = presContext->DevPixelsToAppUnits(result.left);

     border.top = presContext->DevPixelsToAppUnits(result.top);

     border.right = presContext->DevPixelsToAppUnits(result.right);

     border.bottom = presContext->DevPixelsToAppUnits(result.bottom);

     return border;

   }

   nsMargin *b = static_cast<nsMargin*>

                            (Properties().Get(UsedBorderProperty()));

   if (b) {

     border = *b;

   } else {

     border = StyleBorder()->GetComputedBorder();

   }

   return border;

 }

 /* virtual */ nsMargin

 nsIFrame::GetUsedPadding() const

 {

   nsMargin padding(0, 0, 0, 0);

   if (((mState & NS_FRAME_FIRST_REFLOW) &&

        !(mState & NS_FRAME_IN_REFLOW)) ||

       IsSVGText())

     return padding;

   // Theme methods don't use const-ness.

   nsIFrame *mutable_this = const_cast<nsIFrame*>(this);

   const nsStyleDisplay *disp = StyleDisplay();

   if (mutable_this->IsThemed(disp)) {

     nsPresContext *presContext = PresContext();

     nsIntMargin widget;

     if (presContext->GetTheme()->GetWidgetPadding(presContext->DeviceContext(),

                                                   mutable_this,

                                                   disp->mAppearance,

                                                   &widget)) {

       padding.top = presContext->DevPixelsToAppUnits(widget.top);

       padding.right = presContext->DevPixelsToAppUnits(widget.right);

       padding.bottom = presContext->DevPixelsToAppUnits(widget.bottom);

       padding.left = presContext->DevPixelsToAppUnits(widget.left);

       return padding;

     }

   }

   nsMargin *p = static_cast<nsMargin*>

                            (Properties().Get(UsedPaddingProperty()));

   if (p) {

     padding = *p;

   } else {

     DebugOnly<bool> hasPadding = StylePadding()->GetPadding(padding);

     NS_ASSERTION(hasPadding, "We should have padding here! (out of memory?)");

   }

   return padding;

 }

 int

 nsIFrame::GetSkipSides(const nsHTMLReflowState* aReflowState) const

 {

   // Convert the logical skip sides to physical sides using the frame's

   // writing mode

   WritingMode writingMode = GetWritingMode();

   int logicalSkip = GetLogicalSkipSides(aReflowState);

   int skip = 0;

   if (logicalSkip & LOGICAL_SIDE_B_START) {

     if (writingMode.IsVertical()) {

       skip |= 1 << (writingMode.IsVerticalLR() ? NS_SIDE_LEFT : NS_SIDE_RIGHT);

     } else {

       skip |= 1 << NS_SIDE_TOP;

     }

   }

   if (logicalSkip & LOGICAL_SIDE_B_END) {

     if (writingMode.IsVertical()) {

       skip |= 1 << (writingMode.IsVerticalLR() ? NS_SIDE_RIGHT : NS_SIDE_LEFT);

     } else {

       skip |= 1 << NS_SIDE_BOTTOM;

     }

   }

   if (logicalSkip & LOGICAL_SIDE_I_START) {

     if (writingMode.IsVertical()) {

       skip |= 1 << NS_SIDE_TOP;

     } else {

       skip |= 1 << (writingMode.IsBidiLTR() ? NS_SIDE_LEFT : NS_SIDE_RIGHT);

     }

   }

   if (logicalSkip & LOGICAL_SIDE_I_END) {

     if (writingMode.IsVertical()) {

       skip |= 1 << NS_SIDE_BOTTOM;

     } else {

       skip |= 1 << (writingMode.IsBidiLTR() ? NS_SIDE_RIGHT : NS_SIDE_LEFT);

     }

   }

   return skip;

 }

 void

 nsIFrame::ApplySkipSides(nsMargin& aMargin,

                          const nsHTMLReflowState* aReflowState) const

 {

   int skipSides = GetSkipSides(aReflowState);

   if (skipSides & (1 << NS_SIDE_TOP)) {

     aMargin.top = 0;

   }

   if (skipSides & (1 << NS_SIDE_RIGHT)) {

     aMargin.right = 0;

   }

   if (skipSides & (1 << NS_SIDE_BOTTOM)) {

     aMargin.bottom = 0;

   }

   if (skipSides & (1 << NS_SIDE_LEFT)) {

     aMargin.left = 0;

   }

 }

 void

 nsIFrame::ApplyLogicalSkipSides(LogicalMargin& aMargin,

                                 const nsHTMLReflowState* aReflowState) const

 {

   int skipSides = GetLogicalSkipSides(aReflowState);

   if (skipSides & (LOGICAL_SIDE_B_START)) {

     aMargin.BStart(GetWritingMode()) = 0;

   }

   if (skipSides & (LOGICAL_SIDE_I_END)) {

     aMargin.IEnd(GetWritingMode()) = 0;

   }

   if (skipSides & (LOGICAL_SIDE_B_END)) {

     aMargin.BEnd(GetWritingMode()) = 0;

   }

   if (skipSides & (LOGICAL_SIDE_I_START)) {

     aMargin.IStart(GetWritingMode()) = 0;

   }

 }

 nsRect

 nsIFrame::GetPaddingRectRelativeToSelf() const

 {

   nsMargin border(GetUsedBorder());

   ApplySkipSides(border);

   nsRect r(0, 0, mRect.width, mRect.height);

   r.Deflate(border);

   return r;

 }

 nsRect

 nsIFrame::GetPaddingRect() const

 {

   return GetPaddingRectRelativeToSelf() + GetPosition();

 }

 WritingMode

 nsIFrame::GetWritingMode(nsIFrame* aSubFrame) const

 {

   WritingMode writingMode = GetWritingMode();

   if (!writingMode.IsVertical() &&

       (StyleTextReset()->mUnicodeBidi & NS_STYLE_UNICODE_BIDI_PLAINTEXT)) {

     nsBidiLevel frameLevel = nsBidiPresUtils::GetFrameBaseLevel(aSubFrame);

     writingMode.SetDirectionFromBidiLevel(frameLevel);

   }

   return writingMode;

 }

 nsRect

 nsIFrame::GetMarginRectRelativeToSelf() const

 {

   nsMargin m = GetUsedMargin();

   ApplySkipSides(m);

   nsRect r(0, 0, mRect.width, mRect.height);

   r.Inflate(m);

   return r;

 }

 bool

 nsIFrame::IsTransformed() const

 {

   return ((mState & NS_FRAME_MAY_BE_TRANSFORMED) &&

           (StyleDisplay()->HasTransform(this) ||

            IsSVGTransformed() ||

            (mContent &&

             nsLayoutUtils::HasAnimationsForCompositor(mContent,

                                                       eCSSProperty_transform) &&

             IsFrameOfType(eSupportsCSSTransforms) &&

             mContent->GetPrimaryFrame() == this)));

 }

 bool

 nsIFrame::HasOpacityInternal(float aThreshold) const

 {

   MOZ_ASSERT(0.0 <= aThreshold && aThreshold <= 1.0, "Invalid argument");

   const nsStyleDisplay* displayStyle = StyleDisplay();

   return StyleDisplay()->mOpacity < aThreshold ||

          (displayStyle->mWillChangeBitField & NS_STYLE_WILL_CHANGE_OPACITY) ||

          (mContent &&

            nsLayoutUtils::HasAnimationsForCompositor(mContent,

                                                      eCSSProperty_opacity) &&

            mContent->GetPrimaryFrame() == this);

 }

 bool

 nsIFrame::IsSVGTransformed(gfx::Matrix *aOwnTransforms,

                            gfx::Matrix *aFromParentTransforms) const

 {

   return false;

 }

 bool

 nsIFrame::Preserves3DChildren() const

 {

   const nsStyleDisplay* disp = StyleDisplay();

   if (disp->mTransformStyle != NS_STYLE_TRANSFORM_STYLE_PRESERVE_3D ||

       !IsFrameOfType(nsIFrame::eSupportsCSSTransforms)) {

     return false;

   }

   // If we're all scroll frame, then all descendants will be clipped, so we can't preserve 3d.

   if (GetType() == nsGkAtoms::scrollFrame) {

     return false;

   }

   nsRect temp;

   return !nsFrame::ShouldApplyOverflowClipping(this, disp) &&

          !GetClipPropClipRect(disp, &temp, GetSize()) &&

          !nsSVGIntegrationUtils::UsingEffectsForFrame(this);

 }

 bool

 nsIFrame::Preserves3D() const

 {

   if (!GetParent() || !GetParent()->Preserves3DChildren()) {

     return false;

   }

   return StyleDisplay()->HasTransform(this) || StyleDisplay()->BackfaceIsHidden();

 }

 bool

 nsIFrame::HasPerspective() const

 {

   if (!IsTransformed()) {

     return false;

   }

   nsStyleContext* parentStyleContext = StyleContext()->GetParent();

   if (!parentStyleContext) {

     return false;

   }

   const nsStyleDisplay* parentDisp = parentStyleContext->StyleDisplay();

   return parentDisp->mChildPerspective.GetUnit() == eStyleUnit_Coord;

 }

 bool

 nsIFrame::ChildrenHavePerspective() const

 {

   return StyleDisplay()->HasPerspectiveStyle();

 }

 nsRect

 nsIFrame::GetContentRectRelativeToSelf() const

 {

   nsMargin bp(GetUsedBorderAndPadding());

   ApplySkipSides(bp);

   nsRect r(0, 0, mRect.width, mRect.height);

   r.Deflate(bp);

   return r;

 }

 nsRect

 nsIFrame::GetContentRect() const

 {

   return GetContentRectRelativeToSelf() + GetPosition();

 }

 bool

 nsIFrame::ComputeBorderRadii(const nsStyleCorners& aBorderRadius,

                              const nsSize& aFrameSize,

                              const nsSize& aBorderArea,

                              int aSkipSides,

                              nscoord aRadii[8])

 {

   // Percentages are relative to whichever side they're on.

   NS_FOR_CSS_HALF_CORNERS(i) {

     const nsStyleCoord c = aBorderRadius.Get(i);

     nscoord axis =

       NS_HALF_CORNER_IS_X(i) ? aFrameSize.width : aFrameSize.height;

     if (c.IsCoordPercentCalcUnit()) {

       aRadii[i] = nsRuleNode::ComputeCoordPercentCalc(c, axis);

       if (aRadii[i] < 0) {

         // clamp calc()

         aRadii[i] = 0;

       }

     } else {

       NS_NOTREACHED("ComputeBorderRadii: bad unit");

       aRadii[i] = 0;

     }

   }

   if (aSkipSides & (1 << NS_SIDE_TOP)) {

     aRadii[NS_CORNER_TOP_LEFT_X] = 0;

     aRadii[NS_CORNER_TOP_LEFT_Y] = 0;

     aRadii[NS_CORNER_TOP_RIGHT_X] = 0;

     aRadii[NS_CORNER_TOP_RIGHT_Y] = 0;

   }

   if (aSkipSides & (1 << NS_SIDE_RIGHT)) {

     aRadii[NS_CORNER_TOP_RIGHT_X] = 0;

     aRadii[NS_CORNER_TOP_RIGHT_Y] = 0;

     aRadii[NS_CORNER_BOTTOM_RIGHT_X] = 0;

     aRadii[NS_CORNER_BOTTOM_RIGHT_Y] = 0;

   }

   if (aSkipSides & (1 << NS_SIDE_BOTTOM)) {

     aRadii[NS_CORNER_BOTTOM_RIGHT_X] = 0;

     aRadii[NS_CORNER_BOTTOM_RIGHT_Y] = 0;

     aRadii[NS_CORNER_BOTTOM_LEFT_X] = 0;

     aRadii[NS_CORNER_BOTTOM_LEFT_Y] = 0;

   }

   if (aSkipSides & (1 << NS_SIDE_LEFT)) {

     aRadii[NS_CORNER_BOTTOM_LEFT_X] = 0;

     aRadii[NS_CORNER_BOTTOM_LEFT_Y] = 0;

     aRadii[NS_CORNER_TOP_LEFT_X] = 0;

     aRadii[NS_CORNER_TOP_LEFT_Y] = 0;

   }

   // css3-background specifies this algorithm for reducing

   // corner radii when they are too big.

   bool haveRadius = false;

   double ratio = 1.0f;

   NS_FOR_CSS_SIDES(side) {

     uint32_t hc1 = NS_SIDE_TO_HALF_CORNER(side, false, true);

     uint32_t hc2 = NS_SIDE_TO_HALF_CORNER(side, true, true);

     nscoord length =

       NS_SIDE_IS_VERTICAL(side) ? aBorderArea.height : aBorderArea.width;

     nscoord sum = aRadii[hc1] + aRadii[hc2];

     if (sum)

       haveRadius = true;

     // avoid floating point division in the normal case

     if (length < sum)

       ratio = std::min(ratio, double(length)/sum);

   }

   if (ratio < 1.0) {

     NS_FOR_CSS_HALF_CORNERS(corner) {

       aRadii[corner] *= ratio;

     }

   }

   return haveRadius;

 }

 /* static */ void

 nsIFrame::InsetBorderRadii(nscoord aRadii[8], const nsMargin &aOffsets)

 {

   NS_FOR_CSS_SIDES(side) {

     nscoord offset = aOffsets.Side(side);

     uint32_t hc1 = NS_SIDE_TO_HALF_CORNER(side, false, false);

     uint32_t hc2 = NS_SIDE_TO_HALF_CORNER(side, true, false);

     aRadii[hc1] = std::max(0, aRadii[hc1] - offset);

     aRadii[hc2] = std::max(0, aRadii[hc2] - offset);

   }

 }

 /* static */ void

 nsIFrame::OutsetBorderRadii(nscoord aRadii[8], const nsMargin &aOffsets)

 {

   NS_FOR_CSS_SIDES(side) {

     nscoord offset = aOffsets.Side(side);

     uint32_t hc1 = NS_SIDE_TO_HALF_CORNER(side, false, false);

     uint32_t hc2 = NS_SIDE_TO_HALF_CORNER(side, true, false);

     if (aRadii[hc1] > 0)

       aRadii[hc1] += offset;

     if (aRadii[hc2] > 0)

       aRadii[hc2] += offset;

   }

 }

 /* virtual */ bool

 nsIFrame::GetBorderRadii(nscoord aRadii[8]) const

 {

   if (IsThemed()) {

     // When we're themed, the native theme code draws the border and

     // background, and therefore it doesn't make sense to tell other

     // code that's interested in border-radius that we have any radii.

     //

     // In an ideal world, we might have a way for the them to tell us an

     // border radius, but since we don't, we're better off assuming

     // zero.

     NS_FOR_CSS_HALF_CORNERS(corner) {

       aRadii[corner] = 0;

     }

     return false;

   }

   nsSize size = GetSize();

   return ComputeBorderRadii(StyleBorder()->mBorderRadius, size, size,

                             GetSkipSides(), aRadii);

 }

 bool

 nsIFrame::GetPaddingBoxBorderRadii(nscoord aRadii[8]) const

 {

   if (!GetBorderRadii(aRadii))

     return false;

   InsetBorderRadii(aRadii, GetUsedBorder());

   NS_FOR_CSS_HALF_CORNERS(corner) {

     if (aRadii[corner])

       return true;

   }

   return false;

 }

 bool

 nsIFrame::GetContentBoxBorderRadii(nscoord aRadii[8]) const

 {

   if (!GetBorderRadii(aRadii))

     return false;

   InsetBorderRadii(aRadii, GetUsedBorderAndPadding());

   NS_FOR_CSS_HALF_CORNERS(corner) {

     if (aRadii[corner])

       return true;

   }

   return false;

 }

 nsStyleContext*

 nsFrame::GetAdditionalStyleContext(int32_t aIndex) const

 {

   NS_PRECONDITION(aIndex >= 0, "invalid index number");

   return nullptr;

 }

 void

 nsFrame::SetAdditionalStyleContext(int32_t aIndex, 

                                    nsStyleContext* aStyleContext)

 {

   NS_PRECONDITION(aIndex >= 0, "invalid index number");

 }

 nscoord

 nsFrame::GetBaseline() const

 {

   NS_ASSERTION(!NS_SUBTREE_DIRTY(this),

                "frame must not be dirty");

   // Default to the bottom margin edge, per CSS2.1's definition of the

   // 'baseline' value of 'vertical-align'.

   return mRect.height + GetUsedMargin().bottom;

 }

 const nsFrameList&

 nsFrame::GetChildList(ChildListID aListID) const

 {

   if (IsAbsoluteContainer() &&

       aListID == GetAbsoluteListID()) {

     return GetAbsoluteContainingBlock()->GetChildList();

   } else {

     return nsFrameList::EmptyList();

   }

 }

 void

 nsFrame::GetChildLists(nsTArray<ChildList>* aLists) const

 {

   if (IsAbsoluteContainer()) {

     nsFrameList absoluteList = GetAbsoluteContainingBlock()->GetChildList();

     absoluteList.AppendIfNonempty(aLists, GetAbsoluteListID());

   }

 }

 void

 nsIFrame::GetCrossDocChildLists(nsTArray<ChildList>* aLists)

 {

   nsSubDocumentFrame* subdocumentFrame = do_QueryFrame(this);

   if (subdocumentFrame) {

     // Descend into the subdocument

     nsIFrame* root = subdocumentFrame->GetSubdocumentRootFrame();

     if (root) {

       aLists->AppendElement(nsIFrame::ChildList(

         nsFrameList(root, nsLayoutUtils::GetLastSibling(root)),

         nsIFrame::kPrincipalList));

     }

   }

   GetChildLists(aLists);

 }

 static nsIFrame*

 GetActiveSelectionFrame(nsPresContext* aPresContext, nsIFrame* aFrame)

 {

   nsIContent* capturingContent = nsIPresShell::GetCapturingContent();

   if (capturingContent) {

     nsIFrame* activeFrame = aPresContext->GetPrimaryFrameFor(capturingContent);

     return activeFrame ? activeFrame : aFrame;

   }

   return aFrame;

 }

 int16_t

 nsFrame::DisplaySelection(nsPresContext* aPresContext, bool isOkToTurnOn)

 {

   int16_t selType = nsISelectionController::SELECTION_OFF;

   nsCOMPtr<nsISelectionController> selCon;

   nsresult result = GetSelectionController(aPresContext, getter_AddRefs(selCon));

   if (NS_SUCCEEDED(result) && selCon) {

     result = selCon->GetDisplaySelection(&selType);

     if (NS_SUCCEEDED(result) && (selType != nsISelectionController::SELECTION_OFF)) {

       // Check whether style allows selection.

       bool selectable;

       IsSelectable(&selectable, nullptr);

       if (!selectable) {

         selType = nsISelectionController::SELECTION_OFF;

         isOkToTurnOn = false;

       }

     }

     if (isOkToTurnOn && (selType == nsISelectionController::SELECTION_OFF)) {

       selCon->SetDisplaySelection(nsISelectionController::SELECTION_ON);

       selType = nsISelectionController::SELECTION_ON;

     }

   }

   return selType;

 }

 class nsDisplaySelectionOverlay : public nsDisplayItem {

 public:

   nsDisplaySelectionOverlay(nsDisplayListBuilder* aBuilder,

                             nsFrame* aFrame, int16_t aSelectionValue)

     : nsDisplayItem(aBuilder, aFrame), mSelectionValue(aSelectionValue) {

     MOZ_COUNT_CTOR(nsDisplaySelectionOverlay);

   }

 #ifdef NS_BUILD_REFCNT_LOGGING

   virtual ~nsDisplaySelectionOverlay() {

     MOZ_COUNT_DTOR(nsDisplaySelectionOverlay);

   }

 #endif

   virtual void Paint(nsDisplayListBuilder* aBuilder,

                      nsRenderingContext* aCtx) MOZ_OVERRIDE;

   NS_DISPLAY_DECL_NAME("SelectionOverlay", TYPE_SELECTION_OVERLAY)

 private:

   int16_t mSelectionValue;

 };

 void nsDisplaySelectionOverlay::Paint(nsDisplayListBuilder* aBuilder,

                                       nsRenderingContext* aCtx)

 {

   LookAndFeel::ColorID colorID;

   if (mSelectionValue == nsISelectionController::SELECTION_ON) {

     colorID = LookAndFeel::eColorID_TextSelectBackground;

   } else if (mSelectionValue == nsISelectionController::SELECTION_ATTENTION) {

     colorID = LookAndFeel::eColorID_TextSelectBackgroundAttention;

   } else {

     colorID = LookAndFeel::eColorID_TextSelectBackgroundDisabled;

   }

   nscolor color = LookAndFeel::GetColor(colorID, NS_RGB(255, 255, 255));

   gfxRGBA c(color);

   c.a = .5;

   gfxContext *ctx = aCtx->ThebesContext();

   ctx->SetColor(c);

   nsIntRect pxRect =

     mVisibleRect.ToOutsidePixels(mFrame->PresContext()->AppUnitsPerDevPixel());

   ctx->NewPath();

   ctx->Rectangle(gfxRect(pxRect.x, pxRect.y, pxRect.width, pxRect.height), true);

   ctx->Fill();

 }

 /********************************************************

 * Refreshes each content's frame

 *********************************************************/

 void

 nsFrame::DisplaySelectionOverlay(nsDisplayListBuilder*   aBuilder,

                                  nsDisplayList*          aList,

                                  uint16_t                aContentType)

 {

   if (!IsSelected() || !IsVisibleForPainting(aBuilder))

     return;

   nsPresContext* presContext = PresContext();

   nsIPresShell *shell = presContext->PresShell();

   if (!shell)

     return;

   int16_t displaySelection = shell->GetSelectionFlags();

   if (!(displaySelection & aContentType))

     return;

   const nsFrameSelection* frameSelection = GetConstFrameSelection();

   int16_t selectionValue = frameSelection->GetDisplaySelection();

   if (selectionValue <= nsISelectionController::SELECTION_HIDDEN)

     return; // selection is hidden or off

   nsIContent *newContent = mContent->GetParent();

   //check to see if we are anonymous content

   int32_t offset = 0;

   if (newContent) {

     // XXXbz there has GOT to be a better way of determining this!

     offset = newContent->IndexOf(mContent);

   }

   SelectionDetails *details;

   //look up to see what selection(s) are on this frame

   details = frameSelection->LookUpSelection(newContent, offset, 1, false);

   if (!details)

     return;

   bool normal = false;

   while (details) {

     if (details->mType == nsISelectionController::SELECTION_NORMAL) {

       normal = true;

     }

     SelectionDetails *next = details->mNext;

     delete details;

     details = next;

   }

   if (!normal && aContentType == nsISelectionDisplay::DISPLAY_IMAGES) {

     // Don't overlay an image if it's not in the primary selection.

     return;

   }

   aList->AppendNewToTop(new (aBuilder)

     nsDisplaySelectionOverlay(aBuilder, this, selectionValue));

 }

 void

 nsFrame::DisplayOutlineUnconditional(nsDisplayListBuilder*   aBuilder,

                                      const nsDisplayListSet& aLists)

 {

   if (StyleOutline()->GetOutlineStyle() == NS_STYLE_BORDER_STYLE_NONE)

     return;

   aLists.Outlines()->AppendNewToTop(

     new (aBuilder) nsDisplayOutline(aBuilder, this));

 }

 void

 nsFrame::DisplayOutline(nsDisplayListBuilder*   aBuilder,

                         const nsDisplayListSet& aLists)

 {

   if (!IsVisibleForPainting(aBuilder))

     return;

   DisplayOutlineUnconditional(aBuilder, aLists);

 }

 void

 nsIFrame::DisplayCaret(nsDisplayListBuilder* aBuilder,

                        const nsRect& aDirtyRect, nsDisplayList* aList)

 {

   if (!IsVisibleForPainting(aBuilder))

     return;

   aList->AppendNewToTop(

     new (aBuilder) nsDisplayCaret(aBuilder, this, aBuilder->GetCaret()));

 }

 nscolor

 nsIFrame::GetCaretColorAt(int32_t aOffset)

 {

   nscolor color = NS_RGB(0, 0, 0);

   if (nsLayoutUtils::GetNativeTextColor(this, color))

     return color;

   // Use CSS text color.

   return StyleColor()->mColor;

 }

 bool

 nsFrame::DisplayBackgroundUnconditional(nsDisplayListBuilder* aBuilder,

                                         const nsDisplayListSet& aLists,

                                         bool aForceBackground)

 {

   // Here we don't try to detect background propagation. Frames that might

   // receive a propagated background should just set aForceBackground to

   // true.

   if (aBuilder->IsForEventDelivery() || aForceBackground ||

       !StyleBackground()->IsTransparent() || StyleDisplay()->mAppearance) {

     return nsDisplayBackgroundImage::AppendBackgroundItemsToTop(

         aBuilder, this, aLists.BorderBackground());

   }

   return false;

 }

 void

 nsFrame::DisplayBorderBackgroundOutline(nsDisplayListBuilder*   aBuilder,

                                         const nsDisplayListSet& aLists,

                                         bool                    aForceBackground)

 {

   // The visibility check belongs here since child elements have the

   // opportunity to override the visibility property and display even if

   // their parent is hidden.

   if (!IsVisibleForPainting(aBuilder))

     return;

   nsCSSShadowArray* shadows = StyleBorder()->mBoxShadow;

   if (shadows && shadows->HasShadowWithInset(false)) {

     aLists.BorderBackground()->AppendNewToTop(new (aBuilder)

       nsDisplayBoxShadowOuter(aBuilder, this));

   }

   bool bgIsThemed = DisplayBackgroundUnconditional(aBuilder, aLists,

                                                    aForceBackground);

   if (shadows && shadows->HasShadowWithInset(true)) {

     aLists.BorderBackground()->AppendNewToTop(new (aBuilder)

       nsDisplayBoxShadowInner(aBuilder, this));

   }

   // If there's a themed background, we should not create a border item.

   // It won't be rendered.

   if (!bgIsThemed && StyleBorder()->HasBorder()) {

     aLists.BorderBackground()->AppendNewToTop(new (aBuilder)

       nsDisplayBorder(aBuilder, this));

   }

   DisplayOutlineUnconditional(aBuilder, aLists);

 }

 inline static bool IsSVGContentWithCSSClip(const nsIFrame *aFrame)

 {

   // The CSS spec says that the 'clip' property only applies to absolutely

   // positioned elements, whereas the SVG spec says that it applies to SVG

   // elements regardless of the value of the 'position' property. Here we obey

   // the CSS spec for outer-<svg> (since that's what we generally do), but

   // obey the SVG spec for other SVG elements to which 'clip' applies.

   nsIAtom *tag = aFrame->GetContent()->Tag();

   return (aFrame->GetStateBits() & NS_FRAME_SVG_LAYOUT) &&

     (tag == nsGkAtoms::svg || tag == nsGkAtoms::foreignObject);

 }

 bool

 nsIFrame::GetClipPropClipRect(const nsStyleDisplay* aDisp, nsRect* aRect,

                               const nsSize& aSize) const

 {

   NS_PRECONDITION(aRect, "Must have aRect out parameter");

   if (!(aDisp->mClipFlags & NS_STYLE_CLIP_RECT) ||

       !(aDisp->IsAbsolutelyPositioned(this) || IsSVGContentWithCSSClip(this))) {

     return false;

   }

   *aRect = aDisp->mClip;

   if (NS_STYLE_CLIP_RIGHT_AUTO & aDisp->mClipFlags) {

     aRect->width = aSize.width - aRect->x;

   }

   if (NS_STYLE_CLIP_BOTTOM_AUTO & aDisp->mClipFlags) {

     aRect->height = aSize.height - aRect->y;

   }

   return true;

 }

 /**

  * If the CSS 'clip' property applies to this frame, set it up

  * in aBuilder->ClipState() to clip all content descendants. Returns true

  * if the property applies, and if so also returns the clip rect (relative

  * to aFrame) in *aRect.

  */

 static bool

 ApplyClipPropClipping(nsDisplayListBuilder* aBuilder,

                       const nsIFrame* aFrame,

                       const nsStyleDisplay* aDisp,

                       nsRect* aRect,

                       DisplayListClipState::AutoSaveRestore& aClipState)

 {

   if (!aFrame->GetClipPropClipRect(aDisp, aRect, aFrame->GetSize()))

     return false;

   nsRect clipRect = *aRect + aBuilder->ToReferenceFrame(aFrame);

   aClipState.ClipContentDescendants(clipRect);

   return true;

 }

 /**

  * If the CSS 'overflow' property applies to this frame, and is not

  * handled by constructing a dedicated nsHTML/XULScrollFrame, set up clipping

  * for that overflow in aBuilder->ClipState() to clip all containing-block

  * descendants.

  */

 static void

 ApplyOverflowClipping(nsDisplayListBuilder* aBuilder,

                       const nsIFrame* aFrame,

                       const nsStyleDisplay* aDisp,

                       DisplayListClipState::AutoClipMultiple& aClipState)

 {

   // Only -moz-hidden-unscrollable is handled here (and 'hidden' for table

   // frames, and any non-visible value for blocks in a paginated context).

   // We allow -moz-hidden-unscrollable to apply to any kind of frame. This

   // is required by comboboxes which make their display text (an inline frame)

   // have clipping.

   if (!nsFrame::ShouldApplyOverflowClipping(aFrame, aDisp)) {

     return;

   }

   nsRect clipRect;

   bool haveRadii = false;

   nscoord radii[8];

   if (aFrame->StyleDisplay()->mOverflowClipBox ==

         NS_STYLE_OVERFLOW_CLIP_BOX_PADDING_BOX) {

     clipRect = aFrame->GetPaddingRectRelativeToSelf() +

       aBuilder->ToReferenceFrame(aFrame);

     haveRadii = aFrame->GetPaddingBoxBorderRadii(radii);

   } else {

     clipRect = aFrame->GetContentRectRelativeToSelf() +

       aBuilder->ToReferenceFrame(aFrame);

     // XXX border-radius

   }

   aClipState.ClipContainingBlockDescendantsExtra(clipRect, haveRadii ? radii : nullptr);

 }

 #ifdef DEBUG

 static void PaintDebugBorder(nsIFrame* aFrame, nsRenderingContext* aCtx,

      const nsRect& aDirtyRect, nsPoint aPt) {

   nsRect r(aPt, aFrame->GetSize());

   if (aFrame->HasView()) {

     aCtx->SetColor(NS_RGB(0,0,255));

   } else {

     aCtx->SetColor(NS_RGB(255,0,0));

   }

   aCtx->DrawRect(r);

 }

 static void PaintEventTargetBorder(nsIFrame* aFrame, nsRenderingContext* aCtx,

      const nsRect& aDirtyRect, nsPoint aPt) {

   nsRect r(aPt, aFrame->GetSize());

   aCtx->SetColor(NS_RGB(128,0,128));

   aCtx->DrawRect(r);

 }

 static void

 DisplayDebugBorders(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame,

                     const nsDisplayListSet& aLists) {

   // Draw a border around the child

   // REVIEW: From nsContainerFrame::PaintChild

   if (nsFrame::GetShowFrameBorders() && !aFrame->GetRect().IsEmpty()) {

     aLists.Outlines()->AppendNewToTop(new (aBuilder)

         nsDisplayGeneric(aBuilder, aFrame, PaintDebugBorder, "DebugBorder",

                          nsDisplayItem::TYPE_DEBUG_BORDER));

   }

   // Draw a border around the current event target

   if (nsFrame::GetShowEventTargetFrameBorder() &&

       aFrame->PresContext()->PresShell()->GetDrawEventTargetFrame() == aFrame) {

     aLists.Outlines()->AppendNewToTop(new (aBuilder)

         nsDisplayGeneric(aBuilder, aFrame, PaintEventTargetBorder, "EventTargetBorder",

                          nsDisplayItem::TYPE_EVENT_TARGET_BORDER));

   }

 }

 #endif

 static nsresult

 WrapPreserve3DListInternal(nsIFrame* aFrame, nsDisplayListBuilder *aBuilder, nsDisplayList *aList, nsDisplayList *aOutput, uint32_t& aIndex, nsDisplayList* aTemp)

 {

   if (aIndex > nsDisplayTransform::INDEX_MAX) {

     return NS_OK;

   }

   nsresult rv = NS_OK;

   while (nsDisplayItem *item = aList->RemoveBottom()) {

     nsIFrame *childFrame = item->Frame();

     // We accumulate sequential items that aren't transforms into the 'temp' list

     // and then flush this list into aOutput by wrapping the whole lot with a single

     // nsDisplayTransform.

     if (childFrame->GetParent() &&

         (childFrame->GetParent()->Preserves3DChildren() || childFrame == aFrame)) {

       switch (item->GetType()) {

         case nsDisplayItem::TYPE_TRANSFORM: {

           if (!aTemp->IsEmpty()) {

             aOutput->AppendToTop(new (aBuilder) nsDisplayTransform(aBuilder, aFrame, aTemp, aIndex++));

           }

           // Override item's clipping with our current clip state (if any). Since we're

           // bubbling up a preserve-3d transformed child to a preserve-3d parent,

           // we can be sure the child doesn't have clip state of its own.

           NS_ASSERTION(!item->GetClip().HasClip(), "Unexpected clip on item");

           const DisplayItemClip* clip = aBuilder->ClipState().GetCurrentCombinedClip(aBuilder);

           if (clip) {

             item->SetClip(aBuilder, *clip);

           }

           aOutput->AppendToTop(item);

           break;

         }

         case nsDisplayItem::TYPE_WRAP_LIST: {

           nsDisplayWrapList *list = static_cast<nsDisplayWrapList*>(item);

           rv = WrapPreserve3DListInternal(aFrame, aBuilder,

               list->GetChildren(), aOutput, aIndex, aTemp);

           list->~nsDisplayWrapList();

           break;

         }

         case nsDisplayItem::TYPE_OPACITY: {

           if (!aTemp->IsEmpty()) {

             aOutput->AppendToTop(new (aBuilder) nsDisplayTransform(aBuilder, aFrame, aTemp, aIndex++));

           }

           nsDisplayOpacity *opacity = static_cast<nsDisplayOpacity*>(item);

           nsDisplayList output;

           // Call GetChildren, not GetSameCoordinateSystemChildren, because

           // the preserve-3d children of 'opacity' are temporarily not in the

           // same coordinate system as the opacity --- until this wrapping is done.

           rv = WrapPreserve3DListInternal(aFrame, aBuilder,

               opacity->GetChildren(), &output, aIndex, aTemp);

           if (!aTemp->IsEmpty()) {

             output.AppendToTop(new (aBuilder) nsDisplayTransform(aBuilder, aFrame, aTemp, aIndex++));

           }

           opacity->GetChildren()->AppendToTop(&output);

           opacity->UpdateBounds(aBuilder);

           aOutput->AppendToTop(item);

           break;

         }

         default: {

           if (childFrame->StyleDisplay()->BackfaceIsHidden()) {

             if (!aTemp->IsEmpty()) {

               aOutput->AppendToTop(new (aBuilder) nsDisplayTransform(aBuilder, aFrame, aTemp, aIndex++));

             }

             aOutput->AppendToTop(new (aBuilder) nsDisplayTransform(aBuilder, childFrame, item, aIndex++));

           } else {

             aTemp->AppendToTop(item);

           }

           break;

         }

       } 

     } else {

       aTemp->AppendToTop(item);

     }

     if (NS_FAILED(rv) || !item || aIndex > nsDisplayTransform::INDEX_MAX)

       return rv;

   }

   return NS_OK;

 }

 static bool

 IsScrollFrameActive(nsIScrollableFrame* aScrollableFrame)

 {

   return aScrollableFrame && aScrollableFrame->IsScrollingActive();

 }

 static nsresult

 WrapPreserve3DList(nsIFrame* aFrame, nsDisplayListBuilder* aBuilder, nsDisplayList *aList)

 {

   uint32_t index = 0;

   nsDisplayList temp;

   nsDisplayList output;

   nsresult rv = WrapPreserve3DListInternal(aFrame, aBuilder, aList, &output, index, &temp);

   if (!temp.IsEmpty()) {

     output.AppendToTop(new (aBuilder) nsDisplayTransform(aBuilder, aFrame, &temp, index++));

   }

   aList->AppendToTop(&output);

   return rv;

 }

 class AutoSaveRestoreBlendMode

 {

   nsDisplayListBuilder& mBuilder;

   bool                  AutoResetContainsBlendMode;

 public:

   AutoSaveRestoreBlendMode(nsDisplayListBuilder& aBuilder)

     : mBuilder(aBuilder),

       AutoResetContainsBlendMode(aBuilder.ContainsBlendMode()) {

   }

   ~AutoSaveRestoreBlendMode() {

     mBuilder.SetContainsBlendMode(AutoResetContainsBlendMode);

   }

 };

 static void

 CheckForTouchEventHandler(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame)

 {

   nsIContent* content = aFrame->GetContent();

   if (!content) {

     return;

   }

   EventListenerManager* elm = nsContentUtils::GetExistingListenerManagerForNode(content);

   if (!elm) {

     return;

   }

   if (elm->HasListenersFor(nsGkAtoms::ontouchstart) ||

       elm->HasListenersFor(nsGkAtoms::ontouchmove)) {

     aBuilder->SetAncestorHasTouchEventHandler(true);

   }

 }

 void

 nsIFrame::BuildDisplayListForStackingContext(nsDisplayListBuilder* aBuilder,

                                              const nsRect&         aDirtyRect,

                                              nsDisplayList*        aList) {

   if (GetStateBits() & NS_FRAME_TOO_DEEP_IN_FRAME_TREE)

     return;

   // Replaced elements have their visibility handled here, because

   // they're visually atomic

   if (IsFrameOfType(eReplaced) && !IsVisibleForPainting(aBuilder))

     return;

   const nsStyleDisplay* disp = StyleDisplay();

   // We can stop right away if this is a zero-opacity stacking context and

   // we're painting, and we're not animating opacity. Don't do this

   // if we're going to compute plugin geometry, since opacity-0 plugins

   // need to have display items built for them.

   if (disp->mOpacity == 0.0 && aBuilder->IsForPainting() &&

       !aBuilder->WillComputePluginGeometry() &&

       !(disp->mWillChangeBitField & NS_STYLE_WILL_CHANGE_OPACITY) &&

       !nsLayoutUtils::HasAnimations(mContent, eCSSProperty_opacity)) {

     return;

   }

   nsRect dirtyRect = aDirtyRect;

   bool inTransform = aBuilder->IsInTransform();

   bool isTransformed = IsTransformed();

   // reset blend mode so we can keep track if this stacking context needs have

   // a nsDisplayBlendContainer. Set the blend mode back when the routine exits

   // so we keep track if the parent stacking context needs a container too.

   AutoSaveRestoreBlendMode autoRestoreBlendMode(*aBuilder);

   aBuilder->SetContainsBlendMode(false);

   if (isTransformed) {

     const nsRect overflow = GetVisualOverflowRectRelativeToSelf();

     if (aBuilder->IsForPainting() &&

         nsDisplayTransform::ShouldPrerenderTransformedContent(aBuilder, this)) {

       dirtyRect = overflow;

     } else {

       if (overflow.IsEmpty() && !Preserves3DChildren()) {

         return;

       }

       nsPoint offset = aBuilder->ToReferenceFrame(this);

       dirtyRect += offset;

       nsRect untransformedDirtyRect;

       if (nsDisplayTransform::UntransformRect(dirtyRect, overflow, this, offset, &untransformedDirtyRect)) {

         dirtyRect = untransformedDirtyRect;

       } else {

         NS_WARNING("Unable to untransform dirty rect!");

         // This should only happen if the transform is singular, in which case nothing is visible anyway

         dirtyRect.SetEmpty();

       }

     }

     inTransform = true;

   }

   bool useOpacity = HasVisualOpacity() && !nsSVGUtils::CanOptimizeOpacity(this);

   bool useBlendMode = disp->mMixBlendMode != NS_STYLE_BLEND_NORMAL;

   bool usingSVGEffects = nsSVGIntegrationUtils::UsingEffectsForFrame(this);

   bool useStickyPosition = disp->mPosition == NS_STYLE_POSITION_STICKY &&

     IsScrollFrameActive(nsLayoutUtils::GetNearestScrollableFrame(GetParent(),

                         nsLayoutUtils::SCROLLABLE_SAME_DOC |

                         nsLayoutUtils::SCROLLABLE_INCLUDE_HIDDEN));

   DisplayListClipState::AutoSaveRestore clipState(aBuilder);

   if (isTransformed || useOpacity || useBlendMode || usingSVGEffects || useStickyPosition) {

     // We don't need to pass ancestor clipping down to our children;

     // everything goes inside a display item's child list, and the display

     // item itself will be clipped.

     // For transforms we also need to clear ancestor clipping because it's

     // relative to the wrong display item reference frame anyway.

     clipState.Clear();

   }

   nsDisplayListCollection set;

   {    

     nsDisplayListBuilder::AutoBuildingDisplayList rootSetter(aBuilder, true);

     DisplayListClipState::AutoSaveRestore nestedClipState(aBuilder);

     nsDisplayListBuilder::AutoInTransformSetter

       inTransformSetter(aBuilder, inTransform);

     CheckForTouchEventHandler(aBuilder, this);

     if (usingSVGEffects) {

       dirtyRect =

         nsSVGIntegrationUtils::GetRequiredSourceForInvalidArea(this, dirtyRect);

     }

     nsRect clipPropClip;

     if (ApplyClipPropClipping(aBuilder, this, disp, &clipPropClip,

                               nestedClipState)) {

       dirtyRect.IntersectRect(dirtyRect, clipPropClip);

     }

     MarkAbsoluteFramesForDisplayList(aBuilder, dirtyRect);

     // Preserve3DChildren() also guarantees that applyAbsPosClipping and usingSVGEffects are false

     // We only modify the preserve-3d rect if we are the top of a preserve-3d heirarchy

     if (Preserves3DChildren()) {

       aBuilder->MarkPreserve3DFramesForDisplayList(this, aDirtyRect);

     }

     if (aBuilder->IsBuildingLayerEventRegions()) {

       nsDisplayLayerEventRegions* eventRegions =

         new (aBuilder) nsDisplayLayerEventRegions(aBuilder, this);

       aBuilder->SetLayerEventRegions(eventRegions);

       set.BorderBackground()->AppendNewToTop(eventRegions);

     }

     BuildDisplayList(aBuilder, dirtyRect, set);

   }

   if (aBuilder->IsBackgroundOnly()) {

     set.BlockBorderBackgrounds()->DeleteAll();

     set.Floats()->DeleteAll();

     set.Content()->DeleteAll();

     set.PositionedDescendants()->DeleteAll();

     set.Outlines()->DeleteAll();

   }

   // This z-order sort also sorts secondarily by content order. We need to do

   // this so that boxes produced by the same element are placed together

   // in the sort. Consider a position:relative inline element that breaks

   // across lines and has absolutely positioned children; all the abs-pos

   // children should be z-ordered after all the boxes for the position:relative

   // element itself.

   set.PositionedDescendants()->SortByZOrder(aBuilder, GetContent());

   nsDisplayList resultList;

   // Now follow the rules of http://www.w3.org/TR/CSS21/zindex.html

   // 1,2: backgrounds and borders

   resultList.AppendToTop(set.BorderBackground());

   // 3: negative z-index children.

   for (;;) {

     nsDisplayItem* item = set.PositionedDescendants()->GetBottom();

     if (item && item->ZIndex() < 0) {

       set.PositionedDescendants()->RemoveBottom();

       resultList.AppendToTop(item);

       continue;

     }

     break;

   }

   // 4: block backgrounds

   resultList.AppendToTop(set.BlockBorderBackgrounds());

   // 5: floats

   resultList.AppendToTop(set.Floats());

   // 7: general content

   resultList.AppendToTop(set.Content());

   // 7.5: outlines, in content tree order. We need to sort by content order

   // because an element with outline that breaks and has children with outline

   // might have placed child outline items between its own outline items.

   // The element's outline items need to all come before any child outline

   // items.

   nsIContent* content = GetContent();

   if (!content) {

     content = PresContext()->Document()->GetRootElement();

   }

   if (content) {

     set.Outlines()->SortByContentOrder(aBuilder, content);

   }

 #ifdef DEBUG

   DisplayDebugBorders(aBuilder, this, set);

 #endif

   resultList.AppendToTop(set.Outlines());

   // 8, 9: non-negative z-index children

   resultList.AppendToTop(set.PositionedDescendants());

   if (!isTransformed) {

     // Restore saved clip state now so that any display items we create below

     // are clipped properly.

     clipState.Restore();

   }

   /* If there are any SVG effects, wrap the list up in an SVG effects item

    * (which also handles CSS group opacity). Note that we create an SVG effects

    * item even if resultList is empty, since a filter can produce graphical

    * output even if the element being filtered wouldn't otherwise do so.

    */

   if (usingSVGEffects) {

     /* List now emptied, so add the new list to the top. */

     resultList.AppendNewToTop(

         new (aBuilder) nsDisplaySVGEffects(aBuilder, this, &resultList));

   }

   /* Else, if the list is non-empty and there is CSS group opacity without SVG

    * effects, wrap it up in an opacity item.

    */

   else if (useOpacity && !resultList.IsEmpty()) {

     resultList.AppendNewToTop(

         new (aBuilder) nsDisplayOpacity(aBuilder, this, &resultList));

   }

   /* If we have sticky positioning, wrap it in a sticky position item.

    */

   if (useStickyPosition) {

     resultList.AppendNewToTop(

         new (aBuilder) nsDisplayStickyPosition(aBuilder, this, &resultList));

   }

   /* If we're going to apply a transformation and don't have preserve-3d set, wrap 

    * everything in an nsDisplayTransform. If there's nothing in the list, don't add 

    * anything.

    *

    * For the preserve-3d case we want to individually wrap every child in the list with

    * a separate nsDisplayTransform instead. When the child is already an nsDisplayTransform,

    * we can skip this step, as the computed transform will already include our own.

    *

    * We also traverse into sublists created by nsDisplayWrapList or nsDisplayOpacity, so that

    * we find all the correct children.

    */

   if (isTransformed && !resultList.IsEmpty()) {

     // Restore clip state now so nsDisplayTransform is clipped properly.

     clipState.Restore();

     if (Preserves3DChildren()) {

       WrapPreserve3DList(this, aBuilder, &resultList);

     } else {

       resultList.AppendNewToTop(

         new (aBuilder) nsDisplayTransform(aBuilder, this, &resultList));

     }

   }

   /* If adding both a nsDisplayBlendContainer and a nsDisplayMixBlendMode to the

    * same list, the nsDisplayBlendContainer should be added first. This only

    * happens when the element creating this stacking context has mix-blend-mode

    * and also contains a child which has mix-blend-mode.

    * The nsDisplayBlendContainer must be added to the list first, so it does not

    * isolate the containing element blending as well.

    */

   if (aBuilder->ContainsBlendMode()) {

       resultList.AppendNewToTop(

         new (aBuilder) nsDisplayBlendContainer(aBuilder, this, &resultList));

   }

   /* If there's blending, wrap up the list in a blend-mode item. Note

    * that opacity can be applied before blending as the blend color is

    * not affected by foreground opacity (only background alpha).

    */

   if (useBlendMode && !resultList.IsEmpty()) {

     resultList.AppendNewToTop(

         new (aBuilder) nsDisplayMixBlendMode(aBuilder, this, &resultList));

   }

   CreateOwnLayerIfNeeded(aBuilder, &resultList);

   aList->AppendToTop(&resultList);

 }

 static nsDisplayItem*

 WrapInWrapList(nsDisplayListBuilder* aBuilder,

                nsIFrame* aFrame, nsDisplayList* aList)

 {

   nsDisplayItem* item = aList->GetBottom();

   if (!item || item->GetAbove() || item->Frame() != aFrame) {

     return new (aBuilder) nsDisplayWrapList(aBuilder, aFrame, aList);

   }

   aList->RemoveBottom();

   return item;

 }

 void

 nsIFrame::BuildDisplayListForChild(nsDisplayListBuilder*   aBuilder,

                                    nsIFrame*               aChild,

                                    const nsRect&           aDirtyRect,

                                    const nsDisplayListSet& aLists,

                                    uint32_t                aFlags) {

   // If painting is restricted to just the background of the top level frame,

   // then we have nothing to do here.

   if (aBuilder->IsBackgroundOnly())

     return;

   nsIFrame* child = aChild;

   if (child->GetStateBits() & NS_FRAME_TOO_DEEP_IN_FRAME_TREE)

     return;

   bool isSVG = (child->GetStateBits() & NS_FRAME_SVG_LAYOUT);

   // true if this is a real or pseudo stacking context

   bool pseudoStackingContext =

     (aFlags & DISPLAY_CHILD_FORCE_PSEUDO_STACKING_CONTEXT) != 0;

   if (!isSVG &&

       (aFlags & DISPLAY_CHILD_INLINE) &&

       !child->IsFrameOfType(eLineParticipant)) {

     // child is a non-inline frame in an inline context, i.e.,

     // it acts like inline-block or inline-table. Therefore it is a

     // pseudo-stacking-context.

     pseudoStackingContext = true;

   }

   // dirty rect in child-relative coordinates

   nsRect dirty = aDirtyRect - child->GetOffsetTo(this);

   nsIAtom* childType = child->GetType();

   nsDisplayListBuilder::OutOfFlowDisplayData* savedOutOfFlowData = nullptr;

   if (childType == nsGkAtoms::placeholderFrame) {

     nsPlaceholderFrame* placeholder = static_cast<nsPlaceholderFrame*>(child);

     child = placeholder->GetOutOfFlowFrame();

     NS_ASSERTION(child, "No out of flow frame?");

     // If 'child' is a pushed float then it's owned by a block that's not an

     // ancestor of the placeholder, and it will be painted by that block and

     // should not be painted through the placeholder.

     if (!child || nsLayoutUtils::IsPopup(child) ||

         (child->GetStateBits() & NS_FRAME_IS_PUSHED_FLOAT))

       return;

     // Make sure that any attempt to use childType below is disappointed. We

     // could call GetType again but since we don't currently need it, let's

     // avoid the virtual call.

     childType = nullptr;

     // Recheck NS_FRAME_TOO_DEEP_IN_FRAME_TREE

     if (child->GetStateBits() & NS_FRAME_TOO_DEEP_IN_FRAME_TREE)

       return;

     savedOutOfFlowData = static_cast<nsDisplayListBuilder::OutOfFlowDisplayData*>

       (child->Properties().Get(nsDisplayListBuilder::OutOfFlowDisplayDataProperty()));

     if (savedOutOfFlowData) {

       dirty = savedOutOfFlowData->mDirtyRect;

     } else {

       // The out-of-flow frame did not intersect the dirty area. We may still

       // need to traverse into it, since it may contain placeholders we need

       // to enter to reach other out-of-flow frames that are visible.

       dirty.SetEmpty();

     }

     pseudoStackingContext = true;

   }

   if (child->Preserves3D()) {

     nsRect* savedDirty = static_cast<nsRect*>

       (child->Properties().Get(nsDisplayListBuilder::Preserve3DDirtyRectProperty()));

     if (savedDirty) {

       dirty = *savedDirty;

     } else {

       dirty.SetEmpty();

     }

   }

   NS_ASSERTION(childType != nsGkAtoms::placeholderFrame,

                "Should have dealt with placeholders already");

   if (aBuilder->GetSelectedFramesOnly() &&

       child->IsLeaf() &&

       !aChild->IsSelected()) {

     return;

   }

   if (aBuilder->GetIncludeAllOutOfFlows() &&

       (child->GetStateBits() & NS_FRAME_OUT_OF_FLOW)) {

     dirty = child->GetVisualOverflowRect();

   } else if (!(child->GetStateBits() & NS_FRAME_FORCE_DISPLAY_LIST_DESCEND_INTO)) {

     // No need to descend into child to catch placeholders for visible

     // positioned stuff. So see if we can short-circuit frame traversal here.

     // We can stop if child's frame subtree's intersection with the

     // dirty area is empty.

     // If the child is a scrollframe that we want to ignore, then we need

     // to descend into it because its scrolled child may intersect the dirty

     // area even if the scrollframe itself doesn't.

     // There are cases where the "ignore scroll frame" on the builder is not set

     // correctly, and so we additionally want to catch cases where the child is

     // a root scrollframe and we are ignoring scrolling on the viewport.

     nsIPresShell* shell = PresContext()->PresShell();

     bool keepDescending = child == aBuilder->GetIgnoreScrollFrame() ||

         (shell->IgnoringViewportScrolling() && child == shell->GetRootScrollFrame());

     if (!keepDescending) {

       nsRect childDirty;

       if (!childDirty.IntersectRect(dirty, child->GetVisualOverflowRect()))

         return;

       // Usually we could set dirty to childDirty now but there's no

       // benefit, and it can be confusing. It can especially confuse

       // situations where we're going to ignore a scrollframe's clipping;

       // we wouldn't want to clip the dirty area to the scrollframe's

       // bounds in that case.

     }

   }

   // XXX need to have inline-block and inline-table set pseudoStackingContext

   const nsStyleDisplay* ourDisp = StyleDisplay();

   // REVIEW: Taken from nsBoxFrame::Paint

   // Don't paint our children if the theme object is a leaf.

   if (IsThemed(ourDisp) &&

       !PresContext()->GetTheme()->WidgetIsContainer(ourDisp->mAppearance))

     return;

   // Child is composited if it's transformed, partially transparent, or has

   // SVG effects or a blend mode..

   const nsStyleDisplay* disp = child->StyleDisplay();

   const nsStylePosition* pos = child->StylePosition();

   bool isVisuallyAtomic = child->HasOpacity()

     || child->IsTransformed()

     // strictly speaking, 'perspective' doesn't require visual atomicity,

     // but the spec says it acts like the rest of these

     || disp->mChildPerspective.GetUnit() == eStyleUnit_Coord

     || disp->mMixBlendMode != NS_STYLE_BLEND_NORMAL

     || nsSVGIntegrationUtils::UsingEffectsForFrame(child);

   bool isPositioned = disp->IsPositioned(child);

   bool isStackingContext =

     (isPositioned && (disp->mPosition == NS_STYLE_POSITION_STICKY ||

                       pos->mZIndex.GetUnit() == eStyleUnit_Integer)) ||

      (disp->mWillChangeBitField & NS_STYLE_WILL_CHANGE_STACKING_CONTEXT) ||

      isVisuallyAtomic || (aFlags & DISPLAY_CHILD_FORCE_STACKING_CONTEXT);

   if (isVisuallyAtomic || isPositioned || (!isSVG && disp->IsFloating(child)) ||

       ((disp->mClipFlags & NS_STYLE_CLIP_RECT) &&

        IsSVGContentWithCSSClip(child)) ||

        (disp->mWillChangeBitField & NS_STYLE_WILL_CHANGE_STACKING_CONTEXT) ||

       (aFlags & DISPLAY_CHILD_FORCE_STACKING_CONTEXT)) {

     // If you change this, also change IsPseudoStackingContextFromStyle()

     pseudoStackingContext = true;

   }

   NS_ASSERTION(!isStackingContext || pseudoStackingContext,

                "Stacking contexts must also be pseudo-stacking-contexts");

   bool isInFixedPos = aBuilder->IsInFixedPos() ||

                         (isPositioned &&

                          disp->mPosition == NS_STYLE_POSITION_FIXED &&

                          nsLayoutUtils::IsReallyFixedPos(child));

   nsDisplayListBuilder::AutoInFixedPosSetter

     buildingInFixedPos(aBuilder, isInFixedPos);

   nsDisplayListBuilder::AutoBuildingDisplayList

     buildingForChild(aBuilder, child, pseudoStackingContext);

   DisplayListClipState::AutoClipMultiple clipState(aBuilder);

   CheckForTouchEventHandler(aBuilder, child);

   if (savedOutOfFlowData) {

     clipState.SetClipForContainingBlockDescendants(

       &savedOutOfFlowData->mContainingBlockClip);

   }

   // Setup clipping for the parent's overflow:-moz-hidden-unscrollable,

   // or overflow:hidden on elements that don't support scrolling (and therefore

   // don't create nsHTML/XULScrollFrame). This clipping needs to not clip

   // anything directly rendered by the parent, only the rendering of its

   // children.

   // Don't use overflowClip to restrict the dirty rect, since some of the

   // descendants may not be clipped by it. Even if we end up with unnecessary

   // display items, they'll be pruned during ComputeVisibility.

   nsIFrame* parent = child->GetParent();

   const nsStyleDisplay* parentDisp =

     parent == this ? ourDisp : parent->StyleDisplay();

   ApplyOverflowClipping(aBuilder, parent, parentDisp, clipState);

   nsDisplayList list;

   nsDisplayList extraPositionedDescendants;

   if (isStackingContext) {

     if (disp->mMixBlendMode != NS_STYLE_BLEND_NORMAL) {

       aBuilder->SetContainsBlendMode(true);

     }

     // True stacking context.

     // For stacking contexts, BuildDisplayListForStackingContext handles

     // clipping and MarkAbsoluteFramesForDisplayList.

     child->BuildDisplayListForStackingContext(aBuilder, dirty, &list);

     aBuilder->DisplayCaret(child, dirty, &list);

   } else {

     nsRect clipRect;

     if (ApplyClipPropClipping(aBuilder, child, disp, &clipRect, clipState)) {

       // clipRect is in builder-reference-frame coordinates,

       // dirty/clippedDirtyRect are in child coordinates

       dirty.IntersectRect(dirty, clipRect);

     }

     child->MarkAbsoluteFramesForDisplayList(aBuilder, dirty);

     if (!pseudoStackingContext) {

       // THIS IS THE COMMON CASE.

       // Not a pseudo or real stacking context. Do the simple thing and

       // return early.

       nsDisplayLayerEventRegions* eventRegions = aBuilder->GetLayerEventRegions();

       if (eventRegions) {

         eventRegions->AddFrame(aBuilder, child);

       }

       child->BuildDisplayList(aBuilder, dirty, aLists);

       aBuilder->DisplayCaret(child, dirty, aLists.Content());

 #ifdef DEBUG

       DisplayDebugBorders(aBuilder, child, aLists);

 #endif

       return;

     }

     // A pseudo-stacking context (e.g., a positioned element with z-index auto).

     // We allow positioned descendants of the child to escape to our parent

     // stacking context's positioned descendant list, because they might be

     // z-index:non-auto

     nsDisplayListCollection pseudoStack;

     if (aBuilder->IsBuildingLayerEventRegions()) {

       nsDisplayLayerEventRegions* eventRegions =

         new (aBuilder) nsDisplayLayerEventRegions(aBuilder, this);

       aBuilder->SetLayerEventRegions(eventRegions);

       pseudoStack.BorderBackground()->AppendNewToTop(eventRegions);

     }

     child->BuildDisplayList(aBuilder, dirty, pseudoStack);

     aBuilder->DisplayCaret(child, dirty, pseudoStack.Content());

     list.AppendToTop(pseudoStack.BorderBackground());

     list.AppendToTop(pseudoStack.BlockBorderBackgrounds());

     list.AppendToTop(pseudoStack.Floats());

     list.AppendToTop(pseudoStack.Content());

     list.AppendToTop(pseudoStack.Outlines());

     extraPositionedDescendants.AppendToTop(pseudoStack.PositionedDescendants());

 #ifdef DEBUG

     DisplayDebugBorders(aBuilder, child, aLists);

 #endif

   }

   // Clear clip rect for the construction of the items below. Since we're

   // clipping all their contents, they themselves don't need to be clipped.

   clipState.Clear();

   if (isPositioned || isVisuallyAtomic ||

       (aFlags & DISPLAY_CHILD_FORCE_STACKING_CONTEXT)) {

     // Genuine stacking contexts, and positioned pseudo-stacking-contexts,

     // go in this level.

     if (!list.IsEmpty()) {

       nsDisplayItem* item = WrapInWrapList(aBuilder, child, &list);

       if (isSVG) {

         aLists.Content()->AppendNewToTop(item);

       } else {

         aLists.PositionedDescendants()->AppendNewToTop(item);

       }

     }

   } else if (!isSVG && disp->IsFloating(child)) {

     if (!list.IsEmpty()) {

       aLists.Floats()->AppendNewToTop(WrapInWrapList(aBuilder, child, &list));

     }

   } else {

     aLists.Content()->AppendToTop(&list);

   }

   // We delay placing the positioned descendants of positioned frames to here,

   // because in the absence of z-index this is the correct order for them.

   // This doesn't affect correctness because the positioned descendants list

   // is sorted by z-order and content in BuildDisplayListForStackingContext,

   // but it means that sort routine needs to do less work.

   aLists.PositionedDescendants()->AppendToTop(&extraPositionedDescendants);

 }

 void

 nsIFrame::MarkAbsoluteFramesForDisplayList(nsDisplayListBuilder* aBuilder,

                                            const nsRect& aDirtyRect)

 {

   if (IsAbsoluteContainer()) {

     aBuilder->MarkFramesForDisplayList(this, GetAbsoluteContainingBlock()->GetChildList(), aDirtyRect);

   }

 }

 nsresult  

 nsFrame::GetContentForEvent(WidgetEvent* aEvent,

                             nsIContent** aContent)

 {

   nsIFrame* f = nsLayoutUtils::GetNonGeneratedAncestor(this);

   *aContent = f->GetContent();

   NS_IF_ADDREF(*aContent);

   return NS_OK;

 }

 void

 nsFrame::FireDOMEvent(const nsAString& aDOMEventName, nsIContent *aContent)

 {

   nsIContent* target = aContent ? aContent : mContent;

   if (target) {

     nsRefPtr<AsyncEventDispatcher> asyncDispatcher =

       new AsyncEventDispatcher(target, aDOMEventName, true, false);

     DebugOnly<nsresult> rv = asyncDispatcher->PostDOMEvent();

     NS_ASSERTION(NS_SUCCEEDED(rv), "AsyncEventDispatcher failed to dispatch");

   }

 }

 nsresult

 nsFrame::HandleEvent(nsPresContext* aPresContext, 

                      WidgetGUIEvent* aEvent,

                      nsEventStatus* aEventStatus)

 {

   if (aEvent->message == NS_MOUSE_MOVE) {

     // XXX If the second argument of HandleDrag() is WidgetMouseEvent,

     //     the implementation becomes simpler.

     return HandleDrag(aPresContext, aEvent, aEventStatus);

   }

   if ((aEvent->eventStructType == NS_MOUSE_EVENT &&

        aEvent->AsMouseEvent()->button == WidgetMouseEvent::eLeftButton) ||

       aEvent->eventStructType == NS_TOUCH_EVENT) {

     if (aEvent->message == NS_MOUSE_BUTTON_DOWN || aEvent->message == NS_TOUCH_START) {

       HandlePress(aPresContext, aEvent, aEventStatus);

     } else if (aEvent->message == NS_MOUSE_BUTTON_UP || aEvent->message == NS_TOUCH_END) {

       HandleRelease(aPresContext, aEvent, aEventStatus);

     }

   }

   return NS_OK;

 }

 NS_IMETHODIMP

 nsFrame::GetDataForTableSelection(const nsFrameSelection* aFrameSelection,

                                   nsIPresShell* aPresShell,

                                   WidgetMouseEvent* aMouseEvent, 

                                   nsIContent** aParentContent,

                                   int32_t* aContentOffset,

                                   int32_t* aTarget)

 {

   if (!aFrameSelection || !aPresShell || !aMouseEvent || !aParentContent || !aContentOffset || !aTarget)

     return NS_ERROR_NULL_POINTER;

   *aParentContent = nullptr;

   *aContentOffset = 0;

   *aTarget = 0;

   int16_t displaySelection = aPresShell->GetSelectionFlags();

   bool selectingTableCells = aFrameSelection->GetTableCellSelection();

   // DISPLAY_ALL means we're in an editor.

   // If already in cell selection mode, 

   //  continue selecting with mouse drag or end on mouse up,

   //  or when using shift key to extend block of cells

   //  (Mouse down does normal selection unless Ctrl/Cmd is pressed)

   bool doTableSelection =

      displaySelection == nsISelectionDisplay::DISPLAY_ALL && selectingTableCells &&

      (aMouseEvent->message == NS_MOUSE_MOVE ||

       (aMouseEvent->message == NS_MOUSE_BUTTON_UP &&

        aMouseEvent->button == WidgetMouseEvent::eLeftButton) ||

       aMouseEvent->IsShift());

   if (!doTableSelection)

   {  

     // In Browser, special 'table selection' key must be pressed for table selection

     // or when just Shift is pressed and we're already in table/cell selection mode

 #ifdef XP_MACOSX

     doTableSelection = aMouseEvent->IsMeta() || (aMouseEvent->IsShift() && selectingTableCells);

 #else

     doTableSelection = aMouseEvent->IsControl() || (aMouseEvent->IsShift() && selectingTableCells);

 #endif

   }

   if (!doTableSelection) 

     return NS_OK;

   // Get the cell frame or table frame (or parent) of the current content node

   nsIFrame *frame = this;

   bool foundCell = false;

   bool foundTable = false;

   // Get the limiting node to stop parent frame search

   nsIContent* limiter = aFrameSelection->GetLimiter();

   // If our content node is an ancestor of the limiting node,

   // we should stop the search right now.

   if (limiter && nsContentUtils::ContentIsDescendantOf(limiter, GetContent()))

     return NS_OK;

   //We don't initiate row/col selection from here now,

   //  but we may in future

   //bool selectColumn = false;

   //bool selectRow = false;

   while (frame)

   {

     // Check for a table cell by querying to a known CellFrame interface

     nsITableCellLayout *cellElement = do_QueryFrame(frame);

     if (cellElement)

     {

       foundCell = true;

       //TODO: If we want to use proximity to top or left border

       //      for row and column selection, this is the place to do it

       break;

     }

     else

     {

       // If not a cell, check for table

       // This will happen when starting frame is the table or child of a table,

       //  such as a row (we were inbetween cells or in table border)

       nsTableOuterFrame *tableFrame = do_QueryFrame(frame);

       if (tableFrame)

       {

         foundTable = true;

         //TODO: How can we select row when along left table edge

         //  or select column when along top edge?

         break;

       } else {

         frame = frame->GetParent();

         // Stop if we have hit the selection's limiting content node

         if (frame && frame->GetContent() == limiter)

           break;

       }

     }

   }

   // We aren't in a cell or table

   if (!foundCell && !foundTable) return NS_OK;

   nsIContent* tableOrCellContent = frame->GetContent();

   if (!tableOrCellContent) return NS_ERROR_FAILURE;

   nsCOMPtr<nsIContent> parentContent = tableOrCellContent->GetParent();

   if (!parentContent) return NS_ERROR_FAILURE;

   int32_t offset = parentContent->IndexOf(tableOrCellContent);

   // Not likely?

   if (offset < 0) return NS_ERROR_FAILURE;

   // Everything is OK -- set the return values

   *aParentContent = parentContent;

   NS_ADDREF(*aParentContent);

   *aContentOffset = offset;

 #if 0

   if (selectRow)

     *aTarget = nsISelectionPrivate::TABLESELECTION_ROW;

   else if (selectColumn)

     *aTarget = nsISelectionPrivate::TABLESELECTION_COLUMN;

   else 

 #endif

   if (foundCell)

     *aTarget = nsISelectionPrivate::TABLESELECTION_CELL;

   else if (foundTable)

     *aTarget = nsISelectionPrivate::TABLESELECTION_TABLE;

   return NS_OK;

 }

 nsresult

 nsFrame::IsSelectable(bool* aSelectable, uint8_t* aSelectStyle) const

 {

   if (!aSelectable) //it's ok if aSelectStyle is null

     return NS_ERROR_NULL_POINTER;

   // Like 'visibility', we must check all the parents: if a parent

   // is not selectable, none of its children is selectable.

   //

   // The -moz-all value acts similarly: if a frame has 'user-select:-moz-all',

   // all its children are selectable, even those with 'user-select:none'.

   //

   // As a result, if 'none' and '-moz-all' are not present in the frame hierarchy,

   // aSelectStyle returns the first style that is not AUTO. If these values

   // are present in the frame hierarchy, aSelectStyle returns the style of the

   // topmost parent that has either 'none' or '-moz-all'.

   //

   // For instance, if the frame hierarchy is:

   //    AUTO     -> _MOZ_ALL -> NONE -> TEXT,     the returned value is _MOZ_ALL

   //    TEXT     -> NONE     -> AUTO -> _MOZ_ALL, the returned value is TEXT

   //    _MOZ_ALL -> TEXT     -> AUTO -> AUTO,     the returned value is _MOZ_ALL

   //    AUTO     -> CELL     -> TEXT -> AUTO,     the returned value is TEXT

   //

   uint8_t selectStyle  = NS_STYLE_USER_SELECT_AUTO;

   nsIFrame* frame      = const_cast<nsFrame*>(this);

   while (frame) {

     const nsStyleUIReset* userinterface = frame->StyleUIReset();

     switch (userinterface->mUserSelect) {

       case NS_STYLE_USER_SELECT_ALL:

       case NS_STYLE_USER_SELECT_MOZ_ALL:

         // override the previous values

         selectStyle = userinterface->mUserSelect;

         break;

       default:

         // otherwise return the first value which is not 'auto'

         if (selectStyle == NS_STYLE_USER_SELECT_AUTO) {

           selectStyle = userinterface->mUserSelect;

         }