The Tor Browser / file revision

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

  * vim: set ts=2 sw=2 et tw=78:

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

  *

  * This Original Code has been modified by IBM Corporation.

  * Modifications made by IBM described herein are

  * Copyright (c) International Business Machines

  * Corporation, 2000

  *

  * Modifications to Mozilla code or documentation

  * identified per MPL Section 3.3

  *

  * Date         Modified by     Description of modification

  * 05/03/2000   IBM Corp.       Observer events for reflow states

  */

 /* a presentation of a document, part 2 */

 #ifdef MOZ_LOGGING

 #define FORCE_PR_LOG /* Allow logging in the release build */

 #endif

 #include "prlog.h"

 #include "mozilla/ArrayUtils.h"

 #include "mozilla/EventDispatcher.h"

 #include "mozilla/EventStateManager.h"

 #include "mozilla/EventStates.h"

 #include "mozilla/IMEStateManager.h"

 #include "mozilla/MemoryReporting.h"

 #include "mozilla/dom/TabChild.h"

 #include "mozilla/Likely.h"

 #include "mozilla/MouseEvents.h"

 #include "mozilla/TextEvents.h"

 #include "mozilla/TouchEvents.h"

 #include <algorithm>

 #ifdef XP_WIN

 #include "winuser.h"

 #endif

 #include "nsPresShell.h"

 #include "nsPresContext.h"

 #include "nsIContent.h"

 #include "mozilla/dom/Element.h"

 #include "mozilla/dom/Event.h" // for Event::GetEventPopupControlState()

 #include "mozilla/dom/ShadowRoot.h"

 #include "mozilla/dom/PointerEvent.h"

 #include "nsIDocument.h"

 #include "nsCSSStyleSheet.h"

 #include "nsAnimationManager.h"

 #include "nsNameSpaceManager.h"  // for Pref-related rule management (bugs 22963,20760,31816)

 #include "nsFrame.h"

 #include "FrameLayerBuilder.h"

 #include "nsViewManager.h"

 #include "nsView.h"

 #include "nsCRTGlue.h"

 #include "prprf.h"

 #include "prinrval.h"

 #include "nsTArray.h"

 #include "nsCOMArray.h"

 #include "nsContainerFrame.h"

 #include "nsISelection.h"

 #include "mozilla/dom/Selection.h"

 #include "nsGkAtoms.h"

 #include "nsIDOMRange.h"

 #include "nsIDOMDocument.h"

 #include "nsIDOMNode.h"

 #include "nsIDOMNodeList.h"

 #include "nsIDOMElement.h"

 #include "nsRange.h"

 #include "nsCOMPtr.h"

 #include "nsAutoPtr.h"

 #include "nsReadableUtils.h"

 #include "nsIPageSequenceFrame.h"

 #include "nsCaret.h"

 #include "nsIDOMHTMLDocument.h"

 #include "nsFrameManager.h"

 #include "nsXPCOM.h"

 #include "nsILayoutHistoryState.h"

 #include "nsILineIterator.h" // for ScrollContentIntoView

 #include "pldhash.h"

 #include "mozilla/dom/Touch.h"

 #include "mozilla/dom/PointerEventBinding.h"

 #include "nsIObserverService.h"

 #include "nsDocShell.h"        // for reflow observation

 #include "nsIBaseWindow.h"

 #include "nsError.h"

 #include "nsLayoutUtils.h"

 #include "nsViewportInfo.h"

 #include "nsCSSRendering.h"

   // for |#ifdef DEBUG| code

 #include "prenv.h"

 #include "nsDisplayList.h"

 #include "nsRegion.h"

 #include "nsRenderingContext.h"

 #include "nsAutoLayoutPhase.h"

 #ifdef MOZ_REFLOW_PERF

 #include "nsFontMetrics.h"

 #endif

 #include "PositionedEventTargeting.h"

 #include "nsIReflowCallback.h"

 #include "nsPIDOMWindow.h"

 #include "nsFocusManager.h"

 #include "nsIObjectFrame.h"

 #include "nsIObjectLoadingContent.h"

 #include "nsNetUtil.h"

 #include "nsThreadUtils.h"

 #include "nsStyleSheetService.h"

 #include "gfxImageSurface.h"

 #include "gfxContext.h"

 #include "nsSMILAnimationController.h"

 #include "SVGContentUtils.h"

 #include "nsSVGEffects.h"

 #include "SVGFragmentIdentifier.h"

 #include "nsArenaMemoryStats.h"

 #include "nsPerformance.h"

 #include "nsRefreshDriver.h"

 #include "nsDOMNavigationTiming.h"

 // Drag & Drop, Clipboard

 #include "nsIDocShellTreeItem.h"

 #include "nsIURI.h"

 #include "nsIScrollableFrame.h"

 #include "nsITimer.h"

 #ifdef ACCESSIBILITY

 #include "nsAccessibilityService.h"

 #include "mozilla/a11y/DocAccessible.h"

 #ifdef DEBUG

 #include "mozilla/a11y/Logging.h"

 #endif

 #endif

 // For style data reconstruction

 #include "nsStyleChangeList.h"

 #include "nsCSSFrameConstructor.h"

 #ifdef MOZ_XUL

 #include "nsMenuFrame.h"

 #include "nsTreeBodyFrame.h"

 #include "nsIBoxObject.h"

 #include "nsITreeBoxObject.h"

 #include "nsMenuPopupFrame.h"

 #include "nsITreeColumns.h"

 #include "nsIDOMXULMultSelectCntrlEl.h"

 #include "nsIDOMXULSelectCntrlItemEl.h"

 #include "nsIDOMXULMenuListElement.h"

 #endif

 #include "GeckoProfiler.h"

 #include "gfxPlatform.h"

 #include "Layers.h"

 #include "LayerTreeInvalidation.h"

 #include "mozilla/css/ImageLoader.h"

 #include "mozilla/Preferences.h"

 #include "mozilla/Telemetry.h"

 #include "nsCanvasFrame.h"

 #include "nsIImageLoadingContent.h"

 #include "nsIScreen.h"

 #include "nsIScreenManager.h"

 #include "nsPlaceholderFrame.h"

 #include "nsTransitionManager.h"

 #include "ChildIterator.h"

 #include "RestyleManager.h"

 #include "nsIDOMHTMLElement.h"

 #include "nsIDragSession.h"

 #include "nsIFrameInlines.h"

 #include "mozilla/gfx/2D.h"

 #ifdef ANDROID

 #include "nsIDocShellTreeOwner.h"

 #endif

 #ifdef MOZ_TASK_TRACER

 #include "GeckoTaskTracer.h"

 using namespace mozilla::tasktracer;

 #endif

 #define ANCHOR_SCROLL_FLAGS \

   (nsIPresShell::SCROLL_OVERFLOW_HIDDEN | nsIPresShell::SCROLL_NO_PARENT_FRAMES)

 using namespace mozilla;

 using namespace mozilla::css;

 using namespace mozilla::dom;

 using namespace mozilla::gfx;

 using namespace mozilla::layers;

 using namespace mozilla::gfx;

 CapturingContentInfo nsIPresShell::gCaptureInfo =

   { false /* mAllowed */, false /* mPointerLock */, false /* mRetargetToElement */,

     false /* mPreventDrag */, nullptr /* mContent */ };

 nsIContent* nsIPresShell::gKeyDownTarget;

 nsRefPtrHashtable<nsUint32HashKey, dom::Touch>* nsIPresShell::gCaptureTouchList;

 nsRefPtrHashtable<nsUint32HashKey, nsIContent>* nsIPresShell::gPointerCaptureList;

 nsClassHashtable<nsUint32HashKey, nsIPresShell::PointerInfo>* nsIPresShell::gActivePointersIds;

 bool nsIPresShell::gPreventMouseEvents = false;

 // convert a color value to a string, in the CSS format #RRGGBB

 // *  - initially created for bugs 31816, 20760, 22963

 static void ColorToString(nscolor aColor, nsAutoString &aString);

 // RangePaintInfo is used to paint ranges to offscreen buffers

 struct RangePaintInfo {

   nsRefPtr<nsRange> mRange;

   nsDisplayListBuilder mBuilder;

   nsDisplayList mList;

   // offset of builder's reference frame to the root frame

   nsPoint mRootOffset;

   RangePaintInfo(nsRange* aRange, nsIFrame* aFrame)

     : mRange(aRange), mBuilder(aFrame, nsDisplayListBuilder::PAINTING, false)

   {

     MOZ_COUNT_CTOR(RangePaintInfo);

   }

   ~RangePaintInfo()

   {

     mList.DeleteAll();

     MOZ_COUNT_DTOR(RangePaintInfo);

   }

 };

 #undef NOISY

 // ----------------------------------------------------------------------

 #ifdef DEBUG

 // Set the environment variable GECKO_VERIFY_REFLOW_FLAGS to one or

 // more of the following flags (comma separated) for handy debug

 // output.

 static uint32_t gVerifyReflowFlags;

 struct VerifyReflowFlags {

   const char*    name;

   uint32_t bit;

 };

 static const VerifyReflowFlags gFlags[] = {

   { "verify",                VERIFY_REFLOW_ON },

   { "reflow",                VERIFY_REFLOW_NOISY },

   { "all",                   VERIFY_REFLOW_ALL },

   { "list-commands",         VERIFY_REFLOW_DUMP_COMMANDS },

   { "noisy-commands",        VERIFY_REFLOW_NOISY_RC },

   { "really-noisy-commands", VERIFY_REFLOW_REALLY_NOISY_RC },

   { "resize",                VERIFY_REFLOW_DURING_RESIZE_REFLOW },

 };

 #define NUM_VERIFY_REFLOW_FLAGS (sizeof(gFlags) / sizeof(gFlags[0]))

 static void

 ShowVerifyReflowFlags()

 {

   printf("Here are the available GECKO_VERIFY_REFLOW_FLAGS:\n");

   const VerifyReflowFlags* flag = gFlags;

   const VerifyReflowFlags* limit = gFlags + NUM_VERIFY_REFLOW_FLAGS;

   while (flag < limit) {

     printf("  %s\n", flag->name);

     ++flag;

   }

   printf("Note: GECKO_VERIFY_REFLOW_FLAGS is a comma separated list of flag\n");

   printf("names (no whitespace)\n");

 }

 #endif

 //========================================================================

 //========================================================================

 //========================================================================

 #ifdef MOZ_REFLOW_PERF

 class ReflowCountMgr;

 static const char kGrandTotalsStr[] = "Grand Totals";

 // Counting Class

 class ReflowCounter {

 public:

   ReflowCounter(ReflowCountMgr * aMgr = nullptr);

   ~ReflowCounter();

   void ClearTotals();

   void DisplayTotals(const char * aStr);

   void DisplayDiffTotals(const char * aStr);

   void DisplayHTMLTotals(const char * aStr);

   void Add()                { mTotal++;         }

   void Add(uint32_t aTotal) { mTotal += aTotal; }

   void CalcDiffInTotals();

   void SetTotalsCache();

   void SetMgr(ReflowCountMgr * aMgr) { mMgr = aMgr; }

   uint32_t GetTotal() { return mTotal; }

 protected:

   void DisplayTotals(uint32_t aTotal, const char * aTitle);

   void DisplayHTMLTotals(uint32_t aTotal, const char * aTitle);

   uint32_t mTotal;

   uint32_t mCacheTotal;

   ReflowCountMgr * mMgr; // weak reference (don't delete)

 };

 // Counting Class

 class IndiReflowCounter {

 public:

   IndiReflowCounter(ReflowCountMgr * aMgr = nullptr)

     : mFrame(nullptr),

       mCount(0),

       mMgr(aMgr),

       mCounter(aMgr),

       mHasBeenOutput(false)

     {}

   virtual ~IndiReflowCounter() {}

   nsAutoString mName;

   nsIFrame *   mFrame;   // weak reference (don't delete)

   int32_t      mCount;

   ReflowCountMgr * mMgr; // weak reference (don't delete)

   ReflowCounter mCounter;

   bool          mHasBeenOutput;

 };

 //--------------------

 // Manager Class

 //--------------------

 class ReflowCountMgr {

 public:

   ReflowCountMgr();

   virtual ~ReflowCountMgr();

   void ClearTotals();

   void ClearGrandTotals();

   void DisplayTotals(const char * aStr);

   void DisplayHTMLTotals(const char * aStr);

   void DisplayDiffsInTotals(const char * aStr);

   void Add(const char * aName, nsIFrame * aFrame);

   ReflowCounter * LookUp(const char * aName);

   void PaintCount(const char *aName, nsRenderingContext* aRenderingContext,

                   nsPresContext *aPresContext, nsIFrame *aFrame,

                   const nsPoint &aOffset, uint32_t aColor);

   FILE * GetOutFile() { return mFD; }

   PLHashTable * GetIndiFrameHT() { return mIndiFrameCounts; }

   void SetPresContext(nsPresContext * aPresContext) { mPresContext = aPresContext; } // weak reference

   void SetPresShell(nsIPresShell* aPresShell) { mPresShell= aPresShell; } // weak reference

   void SetDumpFrameCounts(bool aVal)         { mDumpFrameCounts = aVal; }

   void SetDumpFrameByFrameCounts(bool aVal)  { mDumpFrameByFrameCounts = aVal; }

   void SetPaintFrameCounts(bool aVal)        { mPaintFrameByFrameCounts = aVal; }

   bool IsPaintingFrameCounts() { return mPaintFrameByFrameCounts; }

 protected:

   void DisplayTotals(uint32_t aTotal, uint32_t * aDupArray, char * aTitle);

   void DisplayHTMLTotals(uint32_t aTotal, uint32_t * aDupArray, char * aTitle);

   static int RemoveItems(PLHashEntry *he, int i, void *arg);

   static int RemoveIndiItems(PLHashEntry *he, int i, void *arg);

   void CleanUp();

   // stdout Output Methods

   static int DoSingleTotal(PLHashEntry *he, int i, void *arg);

   static int DoSingleIndi(PLHashEntry *he, int i, void *arg);

   void DoGrandTotals();

   void DoIndiTotalsTree();

   // HTML Output Methods

   static int DoSingleHTMLTotal(PLHashEntry *he, int i, void *arg);

   void DoGrandHTMLTotals();

   // Zero Out the Totals

   static int DoClearTotals(PLHashEntry *he, int i, void *arg);

   // Displays the Diff Totals

   static int DoDisplayDiffTotals(PLHashEntry *he, int i, void *arg);

   PLHashTable * mCounts;

   PLHashTable * mIndiFrameCounts;

   FILE * mFD;

   bool mDumpFrameCounts;

   bool mDumpFrameByFrameCounts;

   bool mPaintFrameByFrameCounts;

   bool mCycledOnce;

   // Root Frame for Individual Tracking

   nsPresContext * mPresContext;

   nsIPresShell*    mPresShell;

   // ReflowCountMgr gReflowCountMgr;

 };

 #endif

 //========================================================================

 // comment out to hide caret

 #define SHOW_CARET

 // The upper bound on the amount of time to spend reflowing, in

 // microseconds.  When this bound is exceeded and reflow commands are

 // still queued up, a reflow event is posted.  The idea is for reflow

 // to not hog the processor beyond the time specifed in

 // gMaxRCProcessingTime.  This data member is initialized from the

 // layout.reflow.timeslice pref.

 #define NS_MAX_REFLOW_TIME    1000000

 static int32_t gMaxRCProcessingTime = -1;

 struct nsCallbackEventRequest

 {

   nsIReflowCallback* callback;

   nsCallbackEventRequest* next;

 };

 // ----------------------------------------------------------------------------

 #define ASSERT_REFLOW_SCHEDULED_STATE()                                       \

   NS_ASSERTION(mReflowScheduled ==                                            \

                  GetPresContext()->RefreshDriver()->                          \

                    IsLayoutFlushObserver(this), "Unexpected state")

 class nsAutoCauseReflowNotifier

 {

 public:

   nsAutoCauseReflowNotifier(PresShell* aShell)

     : mShell(aShell)

   {

     mShell->WillCauseReflow();

   }

   ~nsAutoCauseReflowNotifier()

   {

     // This check should not be needed. Currently the only place that seem

     // to need it is the code that deals with bug 337586.

     if (!mShell->mHaveShutDown) {

       mShell->DidCauseReflow();

     }

     else {

       nsContentUtils::RemoveScriptBlocker();

     }

   }

   PresShell* mShell;

 };

 class MOZ_STACK_CLASS nsPresShellEventCB : public EventDispatchingCallback

 {

 public:

   nsPresShellEventCB(PresShell* aPresShell) : mPresShell(aPresShell) {}

   virtual void HandleEvent(EventChainPostVisitor& aVisitor) MOZ_OVERRIDE

   {

     if (aVisitor.mPresContext && aVisitor.mEvent->eventStructType != NS_EVENT) {

       if (aVisitor.mEvent->message == NS_MOUSE_BUTTON_DOWN ||

           aVisitor.mEvent->message == NS_MOUSE_BUTTON_UP) {

         // Mouse-up and mouse-down events call nsFrame::HandlePress/Release

         // which call GetContentOffsetsFromPoint which requires up-to-date layout.

         // Bring layout up-to-date now so that GetCurrentEventFrame() below

         // will return a real frame and we don't have to worry about

         // destroying it by flushing later.

         mPresShell->FlushPendingNotifications(Flush_Layout);

       } else if (aVisitor.mEvent->message == NS_WHEEL_WHEEL &&

                  aVisitor.mEventStatus != nsEventStatus_eConsumeNoDefault) {

         nsIFrame* frame = mPresShell->GetCurrentEventFrame();

         if (frame) {

           // chrome (including addons) should be able to know if content

           // handles both D3E "wheel" event and legacy mouse scroll events.

           // We should dispatch legacy mouse events before dispatching the

           // "wheel" event into system group.

           nsRefPtr<EventStateManager> esm =

             aVisitor.mPresContext->EventStateManager();

           esm->DispatchLegacyMouseScrollEvents(frame,

                                                aVisitor.mEvent->AsWheelEvent(),

                                                &aVisitor.mEventStatus);

         }

       }

       nsIFrame* frame = mPresShell->GetCurrentEventFrame();

       if (!frame &&

           (aVisitor.mEvent->message == NS_MOUSE_BUTTON_UP ||

            aVisitor.mEvent->message == NS_TOUCH_END)) {

         // Redirect BUTTON_UP and TOUCH_END events to the root frame to ensure

         // that capturing is released.

         frame = mPresShell->GetRootFrame();

       }

       if (frame) {

         frame->HandleEvent(aVisitor.mPresContext,

                            aVisitor.mEvent->AsGUIEvent(),

                            &aVisitor.mEventStatus);

       }

     }

   }

   nsRefPtr<PresShell> mPresShell;

 };

 class nsBeforeFirstPaintDispatcher : public nsRunnable

 {

 public:

   nsBeforeFirstPaintDispatcher(nsIDocument* aDocument)

   : mDocument(aDocument) {}

   // Fires the "before-first-paint" event so that interested parties (right now, the

   // mobile browser) are aware of it.

   NS_IMETHOD Run() MOZ_OVERRIDE

   {

     nsCOMPtr<nsIObserverService> observerService =

       mozilla::services::GetObserverService();

     if (observerService) {

       observerService->NotifyObservers(mDocument, "before-first-paint",

                                        nullptr);

     }

     return NS_OK;

   }

 private:

   nsCOMPtr<nsIDocument> mDocument;

 };

 bool PresShell::sDisableNonTestMouseEvents = false;

 #ifdef PR_LOGGING

 PRLogModuleInfo* PresShell::gLog;

 #endif

 #ifdef DEBUG

 static void

 VerifyStyleTree(nsPresContext* aPresContext, nsFrameManager* aFrameManager)

 {

   if (nsFrame::GetVerifyStyleTreeEnable()) {

     nsIFrame* rootFrame = aFrameManager->GetRootFrame();

     aPresContext->RestyleManager()->DebugVerifyStyleTree(rootFrame);

   }

 }

 #define VERIFY_STYLE_TREE ::VerifyStyleTree(mPresContext, mFrameConstructor)

 #else

 #define VERIFY_STYLE_TREE

 #endif

 static bool gVerifyReflowEnabled;

 bool

 nsIPresShell::GetVerifyReflowEnable()

 {

 #ifdef DEBUG

   static bool firstTime = true;

   if (firstTime) {

     firstTime = false;

     char* flags = PR_GetEnv("GECKO_VERIFY_REFLOW_FLAGS");

     if (flags) {

       bool error = false;

       for (;;) {

         char* comma = PL_strchr(flags, ',');

         if (comma)

           *comma = '\0';

         bool found = false;

         const VerifyReflowFlags* flag = gFlags;

         const VerifyReflowFlags* limit = gFlags + NUM_VERIFY_REFLOW_FLAGS;

         while (flag < limit) {

           if (PL_strcasecmp(flag->name, flags) == 0) {

             gVerifyReflowFlags |= flag->bit;

             found = true;

             break;

           }

           ++flag;

         }

         if (! found)

           error = true;

         if (! comma)

           break;

         *comma = ',';

         flags = comma + 1;

       }

       if (error)

         ShowVerifyReflowFlags();

     }

     if (VERIFY_REFLOW_ON & gVerifyReflowFlags) {

       gVerifyReflowEnabled = true;

       printf("Note: verifyreflow is enabled");

       if (VERIFY_REFLOW_NOISY & gVerifyReflowFlags) {

         printf(" (noisy)");

       }

       if (VERIFY_REFLOW_ALL & gVerifyReflowFlags) {

         printf(" (all)");

       }

       if (VERIFY_REFLOW_DUMP_COMMANDS & gVerifyReflowFlags) {

         printf(" (show reflow commands)");

       }

       if (VERIFY_REFLOW_NOISY_RC & gVerifyReflowFlags) {

         printf(" (noisy reflow commands)");

         if (VERIFY_REFLOW_REALLY_NOISY_RC & gVerifyReflowFlags) {

           printf(" (REALLY noisy reflow commands)");

         }

       }

       printf("\n");

     }

   }

 #endif

   return gVerifyReflowEnabled;

 }

 void

 PresShell::AddInvalidateHiddenPresShellObserver(nsRefreshDriver *aDriver)

 {

   if (!mHiddenInvalidationObserverRefreshDriver && !mIsDestroying && !mHaveShutDown) {

     aDriver->AddPresShellToInvalidateIfHidden(this);

     mHiddenInvalidationObserverRefreshDriver = aDriver;

   }

 }

 void

 nsIPresShell::InvalidatePresShellIfHidden()

 {

   if (!IsVisible() && mPresContext) {

     mPresContext->NotifyInvalidation(0);

   }

   mHiddenInvalidationObserverRefreshDriver = nullptr;

 }

 void

 nsIPresShell::CancelInvalidatePresShellIfHidden()

 {

   if (mHiddenInvalidationObserverRefreshDriver) {

     mHiddenInvalidationObserverRefreshDriver->RemovePresShellToInvalidateIfHidden(this);

     mHiddenInvalidationObserverRefreshDriver = nullptr;

   }

 }

 void

 nsIPresShell::SetVerifyReflowEnable(bool aEnabled)

 {

   gVerifyReflowEnabled = aEnabled;

 }

 /* virtual */ void

 nsIPresShell::AddWeakFrameExternal(nsWeakFrame* aWeakFrame)

 {

   AddWeakFrameInternal(aWeakFrame);

 }

 void

 nsIPresShell::AddWeakFrameInternal(nsWeakFrame* aWeakFrame)

 {

   if (aWeakFrame->GetFrame()) {

     aWeakFrame->GetFrame()->AddStateBits(NS_FRAME_EXTERNAL_REFERENCE);

   }

   aWeakFrame->SetPreviousWeakFrame(mWeakFrames);

   mWeakFrames = aWeakFrame;

 }

 /* virtual */ void

 nsIPresShell::RemoveWeakFrameExternal(nsWeakFrame* aWeakFrame)

 {

   RemoveWeakFrameInternal(aWeakFrame);

 }

 void

 nsIPresShell::RemoveWeakFrameInternal(nsWeakFrame* aWeakFrame)

 {

   if (mWeakFrames == aWeakFrame) {

     mWeakFrames = aWeakFrame->GetPreviousWeakFrame();

     return;

   }

   nsWeakFrame* nextWeak = mWeakFrames;

   while (nextWeak && nextWeak->GetPreviousWeakFrame() != aWeakFrame) {

     nextWeak = nextWeak->GetPreviousWeakFrame();

   }

   if (nextWeak) {

     nextWeak->SetPreviousWeakFrame(aWeakFrame->GetPreviousWeakFrame());

   }

 }

 already_AddRefed<nsFrameSelection>

 nsIPresShell::FrameSelection()

 {

   nsRefPtr<nsFrameSelection> ret = mSelection;

   return ret.forget();

 }

 //----------------------------------------------------------------------

 static bool sSynthMouseMove = true;

 static uint32_t sNextPresShellId;

 static bool sPointerEventEnabled = true;

 PresShell::PresShell()

   : mMouseLocation(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE)

 {

   mSelection = nullptr;

 #ifdef MOZ_REFLOW_PERF

   mReflowCountMgr = new ReflowCountMgr();

   mReflowCountMgr->SetPresContext(mPresContext);

   mReflowCountMgr->SetPresShell(this);

 #endif

 #ifdef PR_LOGGING

   mLoadBegin = TimeStamp::Now();

   if (!gLog) {

     gLog = PR_NewLogModule("PresShell");

   }

 #endif

   mSelectionFlags = nsISelectionDisplay::DISPLAY_TEXT | nsISelectionDisplay::DISPLAY_IMAGES;

   mIsThemeSupportDisabled = false;

   mIsActive = true;

   // FIXME/bug 735029: find a better solution to this problem

 #ifdef MOZ_ANDROID_OMTC

   // The java pan/zoom code uses this to mean approximately "request a

   // reset of pan/zoom state" which doesn't necessarily correspond

   // with the first paint of content.

   mIsFirstPaint = false;

 #else

   mIsFirstPaint = true;

 #endif

   mPresShellId = sNextPresShellId++;

   mFrozen = false;

 #ifdef DEBUG

   mPresArenaAllocCount = 0;

 #endif

   mRenderFlags = 0;

   mXResolution = 1.0;

   mYResolution = 1.0;

   mViewportOverridden = false;

   mScrollPositionClampingScrollPortSizeSet = false;

   mMaxLineBoxWidth = 0;

   static bool addedSynthMouseMove = false;

   if (!addedSynthMouseMove) {

     Preferences::AddBoolVarCache(&sSynthMouseMove,

                                  "layout.reflow.synthMouseMove", true);

     addedSynthMouseMove = true;

   }

   static bool addedPointerEventEnabled = false;

   if (!addedPointerEventEnabled) {

     Preferences::AddBoolVarCache(&sPointerEventEnabled,

                                  "dom.w3c_pointer_events.enabled", true);

     addedPointerEventEnabled = true;

   }

   mPaintingIsFrozen = false;

 }

 NS_IMPL_ISUPPORTS(PresShell, nsIPresShell, nsIDocumentObserver,

                   nsISelectionController,

                   nsISelectionDisplay, nsIObserver, nsISupportsWeakReference,

                   nsIMutationObserver)

 PresShell::~PresShell()

 {

   if (!mHaveShutDown) {

     NS_NOTREACHED("Someone did not call nsIPresShell::destroy");

     Destroy();

   }

   NS_ASSERTION(mCurrentEventContentStack.Count() == 0,

                "Huh, event content left on the stack in pres shell dtor!");

   NS_ASSERTION(mFirstCallbackEventRequest == nullptr &&

                mLastCallbackEventRequest == nullptr,

                "post-reflow queues not empty.  This means we're leaking");

   // Verify that if painting was frozen, but we're being removed from the tree,

   // that we now re-enable painting on our refresh driver, since it may need to

   // be re-used by another presentation.

   if (mPaintingIsFrozen) {

     mPresContext->RefreshDriver()->Thaw();

   }

 #ifdef DEBUG

   MOZ_ASSERT(mPresArenaAllocCount == 0,

              "Some pres arena objects were not freed");

 #endif

   delete mStyleSet;

   delete mFrameConstructor;

   mCurrentEventContent = nullptr;

   NS_IF_RELEASE(mPresContext);

   NS_IF_RELEASE(mDocument);

   NS_IF_RELEASE(mSelection);

 }

 /**

  * Initialize the presentation shell. Create view manager and style

  * manager.

  * Note this can't be merged into our constructor because caret initialization

  * calls AddRef() on us.

  */

 void

 PresShell::Init(nsIDocument* aDocument,

                 nsPresContext* aPresContext,

                 nsViewManager* aViewManager,

                 nsStyleSet* aStyleSet,

                 nsCompatibility aCompatMode)

 {

   NS_PRECONDITION(aDocument, "null ptr");

   NS_PRECONDITION(aPresContext, "null ptr");

   NS_PRECONDITION(aViewManager, "null ptr");

   NS_PRECONDITION(!mDocument, "already initialized");

   if (!aDocument || !aPresContext || !aViewManager || mDocument) {

     return;

   }

   mDocument = aDocument;

   NS_ADDREF(mDocument);

   mViewManager = aViewManager;

   // Create our frame constructor.

   mFrameConstructor = new nsCSSFrameConstructor(mDocument, this, aStyleSet);

   mFrameManager = mFrameConstructor;

   // The document viewer owns both view manager and pres shell.

   mViewManager->SetPresShell(this);

   // Bind the context to the presentation shell.

   mPresContext = aPresContext;

   NS_ADDREF(mPresContext);

   aPresContext->SetShell(this);

   // Now we can initialize the style set.

   aStyleSet->Init(aPresContext);

   mStyleSet = aStyleSet;

   // Notify our prescontext that it now has a compatibility mode.  Note that

   // this MUST happen after we set up our style set but before we create any

   // frames.

   mPresContext->CompatibilityModeChanged();

   // setup the preference style rules (no forced reflow), and do it

   // before creating any frames.

   SetPreferenceStyleRules(false);

   NS_ADDREF(mSelection = new nsFrameSelection());

   mSelection->Init(this, nullptr);

   // Important: this has to happen after the selection has been set up

 #ifdef SHOW_CARET

   // make the caret

   mCaret = new nsCaret();

   mCaret->Init(this);

   mOriginalCaret = mCaret;

   //SetCaretEnabled(true);       // make it show in browser windows

 #endif

   //set up selection to be displayed in document

   // Don't enable selection for print media

   nsPresContext::nsPresContextType type = aPresContext->Type();

   if (type != nsPresContext::eContext_PrintPreview &&

       type != nsPresContext::eContext_Print)

     SetDisplaySelection(nsISelectionController::SELECTION_DISABLED);

   if (gMaxRCProcessingTime == -1) {

     gMaxRCProcessingTime =

       Preferences::GetInt("layout.reflow.timeslice", NS_MAX_REFLOW_TIME);

   }

   {

     nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();

     if (os) {

       os->AddObserver(this, "agent-sheet-added", false);

       os->AddObserver(this, "user-sheet-added", false);

       os->AddObserver(this, "author-sheet-added", false);

       os->AddObserver(this, "agent-sheet-removed", false);

       os->AddObserver(this, "user-sheet-removed", false);

       os->AddObserver(this, "author-sheet-removed", false);

 #ifdef MOZ_XUL

       os->AddObserver(this, "chrome-flush-skin-caches", false);

 #endif

     }

   }

 #ifdef MOZ_REFLOW_PERF

     if (mReflowCountMgr) {

       bool paintFrameCounts =

         Preferences::GetBool("layout.reflow.showframecounts");

       bool dumpFrameCounts =

         Preferences::GetBool("layout.reflow.dumpframecounts");

       bool dumpFrameByFrameCounts =

         Preferences::GetBool("layout.reflow.dumpframebyframecounts");

       mReflowCountMgr->SetDumpFrameCounts(dumpFrameCounts);

       mReflowCountMgr->SetDumpFrameByFrameCounts(dumpFrameByFrameCounts);

       mReflowCountMgr->SetPaintFrameCounts(paintFrameCounts);

     }

 #endif

   if (mDocument->HasAnimationController()) {

     nsSMILAnimationController* animCtrl = mDocument->GetAnimationController();

     animCtrl->NotifyRefreshDriverCreated(GetPresContext()->RefreshDriver());

   }

   // Get our activeness from the docShell.

   QueryIsActive();

   // Setup our font inflation preferences.

   SetupFontInflation();

 }

 #ifdef PR_LOGGING

 enum TextPerfLogType {

   eLog_reflow,

   eLog_loaddone,

   eLog_totals

 };

 static void

 LogTextPerfStats(gfxTextPerfMetrics* aTextPerf,

                  PresShell* aPresShell,

                  const gfxTextPerfMetrics::TextCounts& aCounts,

                  float aTime, TextPerfLogType aLogType, const char* aURL)

 {

   char prefix[256];

   switch (aLogType) {

     case eLog_reflow:

       sprintf(prefix, "(textperf-reflow) %p time-ms: %7.0f", aPresShell, aTime);

       break;

     case eLog_loaddone:

       sprintf(prefix, "(textperf-loaddone) %p time-ms: %7.0f", aPresShell, aTime);

       break;

     default:

       MOZ_ASSERT(aLogType == eLog_totals, "unknown textperf log type");

       sprintf(prefix, "(textperf-totals) %p", aPresShell);

   }

   PRLogModuleInfo* tpLog = gfxPlatform::GetLog(eGfxLog_textperf);

   // ignore XUL contexts unless at debug level

   PRLogModuleLevel logLevel = PR_LOG_WARNING;

   if (aCounts.numContentTextRuns == 0) {

     logLevel = PR_LOG_DEBUG;

   }

   double hitRatio = 0.0;

   uint32_t lookups = aCounts.wordCacheHit + aCounts.wordCacheMiss;

   if (lookups) {

     hitRatio = double(aCounts.wordCacheHit) / double(lookups);

   }

   if (aLogType == eLog_loaddone) {

     PR_LOG(tpLog, logLevel,

            ("%s reflow: %d chars: %d "

             "[%s] "

             "content-textruns: %d chrome-textruns: %d "

             "max-textrun-len: %d "

             "word-cache-lookups: %d word-cache-hit-ratio: %4.3f "

             "word-cache-space: %d word-cache-long: %d "

             "pref-fallbacks: %d system-fallbacks: %d "

             "textruns-const: %d textruns-destr: %d "

             "cumulative-textruns-destr: %d\n",

             prefix, aTextPerf->reflowCount, aCounts.numChars,

             (aURL ? aURL : ""),

             aCounts.numContentTextRuns, aCounts.numChromeTextRuns,

             aCounts.maxTextRunLen,

             lookups, hitRatio,

             aCounts.wordCacheSpaceRules, aCounts.wordCacheLong,

             aCounts.fallbackPrefs, aCounts.fallbackSystem,

             aCounts.textrunConst, aCounts.textrunDestr,

             aTextPerf->cumulative.textrunDestr));

   } else {

     PR_LOG(tpLog, logLevel,

            ("%s reflow: %d chars: %d "

             "content-textruns: %d chrome-textruns: %d "

             "max-textrun-len: %d "

             "word-cache-lookups: %d word-cache-hit-ratio: %4.3f "

             "word-cache-space: %d word-cache-long: %d "

             "pref-fallbacks: %d system-fallbacks: %d "

             "textruns-const: %d textruns-destr: %d "

             "cumulative-textruns-destr: %d\n",

             prefix, aTextPerf->reflowCount, aCounts.numChars,

             aCounts.numContentTextRuns, aCounts.numChromeTextRuns,

             aCounts.maxTextRunLen,

             lookups, hitRatio,

             aCounts.wordCacheSpaceRules, aCounts.wordCacheLong,

             aCounts.fallbackPrefs, aCounts.fallbackSystem,

             aCounts.textrunConst, aCounts.textrunDestr,

             aTextPerf->cumulative.textrunDestr));

   }

 }

 #endif

 void

 PresShell::Destroy()

 {

   NS_ASSERTION(!nsContentUtils::IsSafeToRunScript(),

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

   // dump out cumulative text perf metrics

 #ifdef PR_LOGGING

   gfxTextPerfMetrics* tp;

   if (mPresContext && (tp = mPresContext->GetTextPerfMetrics())) {

     tp->Accumulate();

     if (tp->cumulative.numChars > 0) {

       LogTextPerfStats(tp, this, tp->cumulative, 0.0, eLog_totals, nullptr);

     }

   }

 #endif

 #ifdef MOZ_REFLOW_PERF

   DumpReflows();

   if (mReflowCountMgr) {

     delete mReflowCountMgr;

     mReflowCountMgr = nullptr;

   }

 #endif

   if (mHaveShutDown)

     return;

 #ifdef ACCESSIBILITY

   if (mDocAccessible) {

 #ifdef DEBUG

     if (a11y::logging::IsEnabled(a11y::logging::eDocDestroy))

       a11y::logging::DocDestroy("presshell destroyed", mDocument);

 #endif

     mDocAccessible->Shutdown();

     mDocAccessible = nullptr;

   }

 #endif // ACCESSIBILITY

   MaybeReleaseCapturingContent();

   if (gKeyDownTarget && gKeyDownTarget->OwnerDoc() == mDocument) {

     NS_RELEASE(gKeyDownTarget);

   }

   if (mContentToScrollTo) {

     mContentToScrollTo->DeleteProperty(nsGkAtoms::scrolling);

     mContentToScrollTo = nullptr;

   }

   if (mPresContext) {

     // We need to notify the destroying the nsPresContext to ESM for

     // suppressing to use from ESM.

     mPresContext->EventStateManager()->NotifyDestroyPresContext(mPresContext);

   }

   {

     nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();

     if (os) {

       os->RemoveObserver(this, "agent-sheet-added");

       os->RemoveObserver(this, "user-sheet-added");

       os->RemoveObserver(this, "author-sheet-added");

       os->RemoveObserver(this, "agent-sheet-removed");

       os->RemoveObserver(this, "user-sheet-removed");

       os->RemoveObserver(this, "author-sheet-removed");

 #ifdef MOZ_XUL

       os->RemoveObserver(this, "chrome-flush-skin-caches");

 #endif

     }

   }

   // If our paint suppression timer is still active, kill it.

   if (mPaintSuppressionTimer) {

     mPaintSuppressionTimer->Cancel();

     mPaintSuppressionTimer = nullptr;

   }

   // Same for our reflow continuation timer

   if (mReflowContinueTimer) {

     mReflowContinueTimer->Cancel();

     mReflowContinueTimer = nullptr;

   }

   if (mDelayedPaintTimer) {

     mDelayedPaintTimer->Cancel();

     mDelayedPaintTimer = nullptr;

   }

   mSynthMouseMoveEvent.Revoke();

   mUpdateImageVisibilityEvent.Revoke();

   ClearVisibleImagesList();

   if (mCaret) {

     mCaret->Terminate();

     mCaret = nullptr;

   }

   if (mSelection) {

     mSelection->DisconnectFromPresShell();

   }

   // release our pref style sheet, if we have one still

   ClearPreferenceStyleRules();

   mIsDestroying = true;

   // We can't release all the event content in

   // mCurrentEventContentStack here since there might be code on the

   // stack that will release the event content too. Double release

   // bad!

   // The frames will be torn down, so remove them from the current

   // event frame stack (since they'd be dangling references if we'd

   // leave them in) and null out the mCurrentEventFrame pointer as

   // well.

   mCurrentEventFrame = nullptr;

   int32_t i, count = mCurrentEventFrameStack.Length();

   for (i = 0; i < count; i++) {

     mCurrentEventFrameStack[i] = nullptr;

   }

   mFramesToDirty.Clear();

   if (mViewManager) {

     // Clear the view manager's weak pointer back to |this| in case it

     // was leaked.

     mViewManager->SetPresShell(nullptr);

     mViewManager = nullptr;

   }

   mStyleSet->BeginShutdown(mPresContext);

   nsRefreshDriver* rd = GetPresContext()->RefreshDriver();

   // This shell must be removed from the document before the frame

   // hierarchy is torn down to avoid finding deleted frames through

   // this presshell while the frames are being torn down

   if (mDocument) {

     NS_ASSERTION(mDocument->GetShell() == this, "Wrong shell?");

     mDocument->DeleteShell();

     if (mDocument->HasAnimationController()) {

       mDocument->GetAnimationController()->NotifyRefreshDriverDestroying(rd);

     }

   }

   // Revoke any pending events.  We need to do this and cancel pending reflows

   // before we destroy the frame manager, since apparently frame destruction

   // sometimes spins the event queue when plug-ins are involved(!).

   rd->RemoveLayoutFlushObserver(this);

   if (mHiddenInvalidationObserverRefreshDriver) {

     mHiddenInvalidationObserverRefreshDriver->RemovePresShellToInvalidateIfHidden(this);

   }

   if (rd->PresContext() == GetPresContext()) {

     rd->RevokeViewManagerFlush();

   }

   mResizeEvent.Revoke();

   if (mAsyncResizeTimerIsActive) {

     mAsyncResizeEventTimer->Cancel();

     mAsyncResizeTimerIsActive = false;

   }

   CancelAllPendingReflows();

   CancelPostedReflowCallbacks();

   // Destroy the frame manager. This will destroy the frame hierarchy

   mFrameConstructor->WillDestroyFrameTree();

   // Destroy all frame properties (whose destruction was suppressed

   // while destroying the frame tree, but which might contain more

   // frames within the properties.

   if (mPresContext) {

     // Clear out the prescontext's property table -- since our frame tree is

     // now dead, we shouldn't be looking up any more properties in that table.

     // We want to do this before we call SetShell() on the prescontext, so

     // property destructors can usefully call GetPresShell() on the

     // prescontext.

     mPresContext->PropertyTable()->DeleteAll();

   }

   NS_WARN_IF_FALSE(!mWeakFrames, "Weak frames alive after destroying FrameManager");

   while (mWeakFrames) {

     mWeakFrames->Clear(this);

   }

   // Let the style set do its cleanup.

   mStyleSet->Shutdown(mPresContext);

   if (mPresContext) {

     // We hold a reference to the pres context, and it holds a weak link back

     // to us. To avoid the pres context having a dangling reference, set its

     // pres shell to nullptr

     mPresContext->SetShell(nullptr);

     // Clear the link handler (weak reference) as well

     mPresContext->SetLinkHandler(nullptr);

   }

   mHaveShutDown = true;

   EvictTouches();

 }

 void

 PresShell::MakeZombie()

 {

   mIsZombie = true;

   CancelAllPendingReflows();

 }

 void

 nsIPresShell::SetAuthorStyleDisabled(bool aStyleDisabled)

 {

   if (aStyleDisabled != mStyleSet->GetAuthorStyleDisabled()) {

     mStyleSet->SetAuthorStyleDisabled(aStyleDisabled);

     ReconstructStyleData();

     nsCOMPtr<nsIObserverService> observerService =

       mozilla::services::GetObserverService();

     if (observerService) {

       observerService->NotifyObservers(mDocument,

                                        "author-style-disabled-changed",

                                        nullptr);

     }

   }

 }

 bool

 nsIPresShell::GetAuthorStyleDisabled() const

 {

   return mStyleSet->GetAuthorStyleDisabled();

 }

 nsresult

 PresShell::SetPreferenceStyleRules(bool aForceReflow)

 {

   if (!mDocument) {

     return NS_ERROR_NULL_POINTER;

   }

   nsPIDOMWindow *window = mDocument->GetWindow();

   // If the document doesn't have a window there's no need to notify

   // its presshell about changes to preferences since the document is

   // in a state where it doesn't matter any more (see

   // nsDocumentViewer::Close()).

   if (!window) {

     return NS_ERROR_NULL_POINTER;

   }

   NS_PRECONDITION(mPresContext, "presContext cannot be null");

   if (mPresContext) {

     // first, make sure this is not a chrome shell

     if (nsContentUtils::IsInChromeDocshell(mDocument)) {

       return NS_OK;

     }

 #ifdef DEBUG_attinasi

     printf("Setting Preference Style Rules:\n");

 #endif

     // if here, we need to create rules for the prefs

     // - this includes the background-color, the text-color,

     //   the link color, the visited link color and the link-underlining

     // first clear any exising rules

     nsresult result = ClearPreferenceStyleRules();

     // now the link rules (must come after the color rules, or links will not be correct color!)

     // XXX - when there is both an override and agent pref stylesheet this won't matter,

     //       as the color rules will be overrides and the links rules will be agent

     if (NS_SUCCEEDED(result)) {

       result = SetPrefLinkRules();

     }

     if (NS_SUCCEEDED(result)) {

       result = SetPrefFocusRules();

     }

     if (NS_SUCCEEDED(result)) {

       result = SetPrefNoScriptRule();

     }

     if (NS_SUCCEEDED(result)) {

       result = SetPrefNoFramesRule();

     }

 #ifdef DEBUG_attinasi

     printf( "Preference Style Rules set: error=%ld\n", (long)result);

 #endif

     // Note that this method never needs to force any calculation; the caller

     // will recalculate style if needed

     return result;

   }

   return NS_ERROR_NULL_POINTER;

 }

 nsresult PresShell::ClearPreferenceStyleRules(void)

 {

   nsresult result = NS_OK;

   if (mPrefStyleSheet) {

     NS_ASSERTION(mStyleSet, "null styleset entirely unexpected!");

     if (mStyleSet) {

       // remove the sheet from the styleset:

       // - note that we have to check for success by comparing the count before and after...

 #ifdef DEBUG

       int32_t numBefore = mStyleSet->SheetCount(nsStyleSet::eUserSheet);

       NS_ASSERTION(numBefore > 0, "no user stylesheets in styleset, but we have one!");

 #endif

       mStyleSet->RemoveStyleSheet(nsStyleSet::eUserSheet, mPrefStyleSheet);

 #ifdef DEBUG_attinasi

       NS_ASSERTION((numBefore - 1) == mStyleSet->GetNumberOfUserStyleSheets(),

                    "Pref stylesheet was not removed");

       printf("PrefStyleSheet removed\n");

 #endif

       // clear the sheet pointer: it is strictly historical now

       mPrefStyleSheet = nullptr;

     }

   }

   return result;

 }

 nsresult

 PresShell::CreatePreferenceStyleSheet()

 {

   NS_ASSERTION(!mPrefStyleSheet, "prefStyleSheet already exists");

   mPrefStyleSheet = new nsCSSStyleSheet(CORS_NONE);

   nsCOMPtr<nsIURI> uri;

   nsresult rv = NS_NewURI(getter_AddRefs(uri), "about:PreferenceStyleSheet", nullptr);

   if (NS_FAILED(rv)) {

     mPrefStyleSheet = nullptr;

     return rv;

   }

   NS_ASSERTION(uri, "null but no error");

   mPrefStyleSheet->SetURIs(uri, uri, uri);

   mPrefStyleSheet->SetComplete();

   uint32_t index;

   rv =

     mPrefStyleSheet->InsertRuleInternal(NS_LITERAL_STRING("@namespace svg url(http://www.w3.org/2000/svg);"),

                                         0, &index);

   if (NS_FAILED(rv)) {

     mPrefStyleSheet = nullptr;

     return rv;

   }

   rv =

     mPrefStyleSheet->InsertRuleInternal(NS_LITERAL_STRING("@namespace url(http://www.w3.org/1999/xhtml);"),

                                         0, &index);

   if (NS_FAILED(rv)) {

     mPrefStyleSheet = nullptr;

     return rv;

   }

   mStyleSet->AppendStyleSheet(nsStyleSet::eUserSheet, mPrefStyleSheet);

   return NS_OK;

 }

 // XXX We want these after the @namespace rules.  Does order matter

 // for these rules, or can we call StyleRule::StyleRuleCount()

 // and just "append"?

 static uint32_t sInsertPrefSheetRulesAt = 2;

 nsresult

 PresShell::SetPrefNoScriptRule()

 {

   nsresult rv = NS_OK;

   // also handle the case where print is done from print preview

   // see bug #342439 for more details

   nsIDocument* doc = mDocument;

   if (doc->IsStaticDocument()) {

     doc = doc->GetOriginalDocument();

   }

   bool scriptEnabled = doc->IsScriptEnabled();

   if (scriptEnabled) {

     if (!mPrefStyleSheet) {

       rv = CreatePreferenceStyleSheet();

       NS_ENSURE_SUCCESS(rv, rv);

     }

     uint32_t index = 0;

     mPrefStyleSheet->

       InsertRuleInternal(NS_LITERAL_STRING("noscript{display:none!important}"),

                          sInsertPrefSheetRulesAt, &index);

   }

   return rv;

 }

 nsresult PresShell::SetPrefNoFramesRule(void)

 {

   NS_ASSERTION(mPresContext,"null prescontext not allowed");

   if (!mPresContext) {

     return NS_ERROR_FAILURE;

   }

   nsresult rv = NS_OK;

   if (!mPrefStyleSheet) {

     rv = CreatePreferenceStyleSheet();

     NS_ENSURE_SUCCESS(rv, rv);

   }

   NS_ASSERTION(mPrefStyleSheet, "prefstylesheet should not be null");

   bool allowSubframes = true;

   nsCOMPtr<nsIDocShell> docShell(mPresContext->GetDocShell());

   if (docShell) {

     docShell->GetAllowSubframes(&allowSubframes);

   }

   if (!allowSubframes) {

     uint32_t index = 0;

     rv = mPrefStyleSheet->

       InsertRuleInternal(NS_LITERAL_STRING("noframes{display:block}"),

                          sInsertPrefSheetRulesAt, &index);

     NS_ENSURE_SUCCESS(rv, rv);

     rv = mPrefStyleSheet->

       InsertRuleInternal(NS_LITERAL_STRING("frame, frameset, iframe {display:none!important}"),

                          sInsertPrefSheetRulesAt, &index);

   }

   return rv;

 }

 nsresult PresShell::SetPrefLinkRules(void)

 {

   NS_ASSERTION(mPresContext,"null prescontext not allowed");

   if (!mPresContext) {

     return NS_ERROR_FAILURE;

   }

   nsresult rv = NS_OK;

   if (!mPrefStyleSheet) {

     rv = CreatePreferenceStyleSheet();

     NS_ENSURE_SUCCESS(rv, rv);

   }

   NS_ASSERTION(mPrefStyleSheet, "prefstylesheet should not be null");

   // support default link colors:

   //   this means the link colors need to be overridable,

   //   which they are if we put them in the agent stylesheet,

   //   though if using an override sheet this will cause authors grief still

   //   In the agent stylesheet, they are !important when we are ignoring document colors

   nscolor linkColor(mPresContext->DefaultLinkColor());

   nscolor activeColor(mPresContext->DefaultActiveLinkColor());

   nscolor visitedColor(mPresContext->DefaultVisitedLinkColor());

   NS_NAMED_LITERAL_STRING(ruleClose, "}");

   uint32_t index = 0;

   nsAutoString strColor;

   // insert a rule to color links: '*|*:link {color: #RRGGBB [!important];}'

   ColorToString(linkColor, strColor);

   rv = mPrefStyleSheet->

     InsertRuleInternal(NS_LITERAL_STRING("*|*:link{color:") +

                        strColor + ruleClose,

                        sInsertPrefSheetRulesAt, &index);

   NS_ENSURE_SUCCESS(rv, rv);

   // - visited links: '*|*:visited {color: #RRGGBB [!important];}'

   ColorToString(visitedColor, strColor);

   rv = mPrefStyleSheet->

     InsertRuleInternal(NS_LITERAL_STRING("*|*:visited{color:") +

                        strColor + ruleClose,

                        sInsertPrefSheetRulesAt, &index);

   NS_ENSURE_SUCCESS(rv, rv);

   // - active links: '*|*:-moz-any-link:active {color: #RRGGBB [!important];}'

   ColorToString(activeColor, strColor);

   rv = mPrefStyleSheet->

     InsertRuleInternal(NS_LITERAL_STRING("*|*:-moz-any-link:active{color:") +

                        strColor + ruleClose,

                        sInsertPrefSheetRulesAt, &index);

   NS_ENSURE_SUCCESS(rv, rv);

   bool underlineLinks =

     mPresContext->GetCachedBoolPref(kPresContext_UnderlineLinks);

   if (underlineLinks) {

     // create a rule to make underlining happen

     //  '*|*:-moz-any-link {text-decoration:[underline|none];}'

     // no need for important, we want these to be overridable

     // NOTE: these must go in the agent stylesheet or they cannot be

     //       overridden by authors

     rv = mPrefStyleSheet->

       InsertRuleInternal(NS_LITERAL_STRING("*|*:-moz-any-link:not(svg|a){text-decoration:underline}"),

                          sInsertPrefSheetRulesAt, &index);

   } else {

     rv = mPrefStyleSheet->

       InsertRuleInternal(NS_LITERAL_STRING("*|*:-moz-any-link{text-decoration:none}"),

                          sInsertPrefSheetRulesAt, &index);

   }

   return rv;

 }

 nsresult PresShell::SetPrefFocusRules(void)

 {

   NS_ASSERTION(mPresContext,"null prescontext not allowed");

   nsresult result = NS_OK;

   if (!mPresContext)

     result = NS_ERROR_FAILURE;

   if (NS_SUCCEEDED(result) && !mPrefStyleSheet)

     result = CreatePreferenceStyleSheet();

   if (NS_SUCCEEDED(result)) {

     NS_ASSERTION(mPrefStyleSheet, "prefstylesheet should not be null");

     if (mPresContext->GetUseFocusColors()) {

       nscolor focusBackground(mPresContext->FocusBackgroundColor());

       nscolor focusText(mPresContext->FocusTextColor());

       // insert a rule to make focus the preferred color

       uint32_t index = 0;

       nsAutoString strRule, strColor;

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

       // - focus: '*:focus

       ColorToString(focusText,strColor);

       strRule.AppendLiteral("*:focus,*:focus>font {color: ");

       strRule.Append(strColor);

       strRule.AppendLiteral(" !important; background-color: ");

       ColorToString(focusBackground,strColor);

       strRule.Append(strColor);

       strRule.AppendLiteral(" !important; } ");

       // insert the rules

       result = mPrefStyleSheet->

         InsertRuleInternal(strRule, sInsertPrefSheetRulesAt, &index);

     }

     uint8_t focusRingWidth = mPresContext->FocusRingWidth();

     bool focusRingOnAnything = mPresContext->GetFocusRingOnAnything();

     uint8_t focusRingStyle = mPresContext->GetFocusRingStyle();

     if ((NS_SUCCEEDED(result) && focusRingWidth != 1 && focusRingWidth <= 4 ) || focusRingOnAnything) {

       uint32_t index = 0;

       nsAutoString strRule;

       if (!focusRingOnAnything)

         strRule.AppendLiteral("*|*:link:focus, *|*:visited");    // If we only want focus rings on the normal things like links

       strRule.AppendLiteral(":focus {outline: ");     // For example 3px dotted WindowText (maximum 4)

       strRule.AppendInt(focusRingWidth);

       if (focusRingStyle == 0) // solid

         strRule.AppendLiteral("px solid -moz-mac-focusring !important; -moz-outline-radius: 3px; outline-offset: 1px; } ");

       else // dotted

         strRule.AppendLiteral("px dotted WindowText !important; } ");

       // insert the rules

       result = mPrefStyleSheet->

         InsertRuleInternal(strRule, sInsertPrefSheetRulesAt, &index);

       NS_ENSURE_SUCCESS(result, result);

       if (focusRingWidth != 1) {

         // If the focus ring width is different from the default, fix buttons with rings

         strRule.AssignLiteral("button::-moz-focus-inner, input[type=\"reset\"]::-moz-focus-inner,");

         strRule.AppendLiteral("input[type=\"button\"]::-moz-focus-inner, ");

         strRule.AppendLiteral("input[type=\"submit\"]::-moz-focus-inner { padding: 1px 2px 1px 2px; border: ");

         strRule.AppendInt(focusRingWidth);

         if (focusRingStyle == 0) // solid

           strRule.AppendLiteral("px solid transparent !important; } ");

         else

           strRule.AppendLiteral("px dotted transparent !important; } ");

         result = mPrefStyleSheet->

           InsertRuleInternal(strRule, sInsertPrefSheetRulesAt, &index);

         NS_ENSURE_SUCCESS(result, result);

         strRule.AssignLiteral("button:focus::-moz-focus-inner, input[type=\"reset\"]:focus::-moz-focus-inner,");

         strRule.AppendLiteral("input[type=\"button\"]:focus::-moz-focus-inner, input[type=\"submit\"]:focus::-moz-focus-inner {");

         strRule.AppendLiteral("border-color: ButtonText !important; }");

         result = mPrefStyleSheet->

           InsertRuleInternal(strRule, sInsertPrefSheetRulesAt, &index);

       }

     }

   }

   return result;

 }

 void

 PresShell::AddUserSheet(nsISupports* aSheet)

 {

   // Make sure this does what nsDocumentViewer::CreateStyleSet does wrt

   // ordering. We want this new sheet to come after all the existing stylesheet

   // service sheets, but before other user sheets; see nsIStyleSheetService.idl

   // for the ordering.  Just remove and readd all the nsStyleSheetService

   // sheets.

   nsCOMPtr<nsIStyleSheetService> dummy =

     do_GetService(NS_STYLESHEETSERVICE_CONTRACTID);

   mStyleSet->BeginUpdate();

   nsStyleSheetService *sheetService = nsStyleSheetService::gInstance;

   nsCOMArray<nsIStyleSheet> & userSheets = *sheetService->UserStyleSheets();

   int32_t i;

   // Iterate forwards when removing so the searches for RemoveStyleSheet are as

   // short as possible.

   for (i = 0; i < userSheets.Count(); ++i) {

     mStyleSet->RemoveStyleSheet(nsStyleSet::eUserSheet, userSheets[i]);

   }

   // Now iterate backwards, so that the order of userSheets will be the same as

   // the order of sheets from it in the style set.

   for (i = userSheets.Count() - 1; i >= 0; --i) {

     mStyleSet->PrependStyleSheet(nsStyleSet::eUserSheet, userSheets[i]);

   }

   mStyleSet->EndUpdate();

   ReconstructStyleData();

 }

 void

 PresShell::AddAgentSheet(nsISupports* aSheet)

 {

   // Make sure this does what nsDocumentViewer::CreateStyleSet does

   // wrt ordering.

   nsCOMPtr<nsIStyleSheet> sheet = do_QueryInterface(aSheet);

   if (!sheet) {

     return;

   }

   mStyleSet->AppendStyleSheet(nsStyleSet::eAgentSheet, sheet);

   ReconstructStyleData();

 }

 void

 PresShell::AddAuthorSheet(nsISupports* aSheet)

 {

   nsCOMPtr<nsIStyleSheet> sheet = do_QueryInterface(aSheet);

   if (!sheet) {

     return;

   }

   // Document specific "additional" Author sheets should be stronger than the ones

   // added with the StyleSheetService.

   nsIStyleSheet* firstAuthorSheet = mDocument->FirstAdditionalAuthorSheet();

   if (firstAuthorSheet) {

     mStyleSet->InsertStyleSheetBefore(nsStyleSet::eDocSheet, sheet, firstAuthorSheet);

   } else {

     mStyleSet->AppendStyleSheet(nsStyleSet::eDocSheet, sheet);

   }

   ReconstructStyleData();

 }

 void

 PresShell::RemoveSheet(nsStyleSet::sheetType aType, nsISupports* aSheet)

 {

   nsCOMPtr<nsIStyleSheet> sheet = do_QueryInterface(aSheet);

   if (!sheet) {

     return;

   }

   mStyleSet->RemoveStyleSheet(aType, sheet);

   ReconstructStyleData();

 }

 NS_IMETHODIMP

 PresShell::SetDisplaySelection(int16_t aToggle)

 {

   mSelection->SetDisplaySelection(aToggle);

   return NS_OK;

 }

 NS_IMETHODIMP

 PresShell::GetDisplaySelection(int16_t *aToggle)

 {

   *aToggle = mSelection->GetDisplaySelection();

   return NS_OK;

 }

 NS_IMETHODIMP

 PresShell::GetSelection(SelectionType aType, nsISelection **aSelection)

 {

   if (!aSelection || !mSelection)

     return NS_ERROR_NULL_POINTER;

   *aSelection = mSelection->GetSelection(aType);

   if (!(*aSelection))

     return NS_ERROR_INVALID_ARG;

   NS_ADDREF(*aSelection);

   return NS_OK;

 }

 Selection*

 PresShell::GetCurrentSelection(SelectionType aType)

 {

   if (!mSelection)

     return nullptr;

   return mSelection->GetSelection(aType);

 }

 NS_IMETHODIMP

 PresShell::ScrollSelectionIntoView(SelectionType aType, SelectionRegion aRegion,

                                    int16_t aFlags)

 {

   if (!mSelection)

     return NS_ERROR_NULL_POINTER;

   return mSelection->ScrollSelectionIntoView(aType, aRegion, aFlags);

 }

 NS_IMETHODIMP

 PresShell::RepaintSelection(SelectionType aType)

 {

   if (!mSelection)

     return NS_ERROR_NULL_POINTER;

   return mSelection->RepaintSelection(aType);

 }

 // Make shell be a document observer

 void

 PresShell::BeginObservingDocument()

 {

   if (mDocument && !mIsDestroying) {

     mDocument->AddObserver(this);

     if (mIsDocumentGone) {

       NS_WARNING("Adding a presshell that was disconnected from the document "

                  "as a document observer?  Sounds wrong...");

       mIsDocumentGone = false;

     }

   }

 }

 // Make shell stop being a document observer

 void

 PresShell::EndObservingDocument()

 {

   // XXXbz do we need to tell the frame constructor that the document

   // is gone, perhaps?  Except for printing it's NOT gone, sometimes.

   mIsDocumentGone = true;

   if (mDocument) {

     mDocument->RemoveObserver(this);

   }

 }

 #ifdef DEBUG_kipp

 char* nsPresShell_ReflowStackPointerTop;

 #endif

 nsresult

 PresShell::Initialize(nscoord aWidth, nscoord aHeight)

 {

   if (mIsDestroying) {

     return NS_OK;

   }

   if (!mDocument) {

     // Nothing to do

     return NS_OK;

   }

   mozilla::TimeStamp timerStart = mozilla::TimeStamp::Now();

   NS_ASSERTION(!mDidInitialize, "Why are we being called?");

   nsCOMPtr<nsIPresShell> kungFuDeathGrip(this);

   mDidInitialize = true;

 #ifdef DEBUG

   if (VERIFY_REFLOW_NOISY_RC & gVerifyReflowFlags) {

     if (mDocument) {

       nsIURI *uri = mDocument->GetDocumentURI();

       if (uri) {

         nsAutoCString url;

         uri->GetSpec(url);

         printf("*** PresShell::Initialize (this=%p, url='%s')\n", (void*)this, url.get());

       }

     }

   }

 #endif

   if (mCaret)

     mCaret->EraseCaret();

   // XXX Do a full invalidate at the beginning so that invalidates along

   // the way don't have region accumulation issues?

   mPresContext->SetVisibleArea(nsRect(0, 0, aWidth, aHeight));

   // Get the root frame from the frame manager

   // XXXbz it would be nice to move this somewhere else... like frame manager

   // Init(), say.  But we need to make sure our views are all set up by the

   // time we do this!

   nsIFrame* rootFrame = mFrameConstructor->GetRootFrame();

   NS_ASSERTION(!rootFrame, "How did that happen, exactly?");

   if (!rootFrame) {

     nsAutoScriptBlocker scriptBlocker;

     mFrameConstructor->BeginUpdate();

     rootFrame = mFrameConstructor->ConstructRootFrame();

     mFrameConstructor->SetRootFrame(rootFrame);

     mFrameConstructor->EndUpdate();

   }

   NS_ENSURE_STATE(!mHaveShutDown);

   if (!rootFrame) {

     return NS_ERROR_OUT_OF_MEMORY;

   }

   for (nsIFrame* f = rootFrame; f; f = nsLayoutUtils::GetCrossDocParentFrame(f)) {

     if (f->GetStateBits() & NS_FRAME_NO_COMPONENT_ALPHA) {

       f->InvalidateFrameSubtree();

       f->RemoveStateBits(NS_FRAME_NO_COMPONENT_ALPHA);

     }

   }

   Element *root = mDocument->GetRootElement();

   if (root) {

     {

       nsAutoCauseReflowNotifier reflowNotifier(this);

       mFrameConstructor->BeginUpdate();

       // Have the style sheet processor construct frame for the root

       // content object down

       mFrameConstructor->ContentInserted(nullptr, root, nullptr, false);

       VERIFY_STYLE_TREE;

       // Something in mFrameConstructor->ContentInserted may have caused

       // Destroy() to get called, bug 337586.

       NS_ENSURE_STATE(!mHaveShutDown);

       mFrameConstructor->EndUpdate();

     }

     // nsAutoScriptBlocker going out of scope may have killed us too

     NS_ENSURE_STATE(!mHaveShutDown);

     // Run the XBL binding constructors for any new frames we've constructed

     mDocument->BindingManager()->ProcessAttachedQueue();

     // Constructors may have killed us too

     NS_ENSURE_STATE(!mHaveShutDown);

     // Now flush out pending restyles before we actually reflow, in

     // case XBL constructors changed styles somewhere.

     {

       nsAutoScriptBlocker scriptBlocker;

       mPresContext->RestyleManager()->ProcessPendingRestyles();

     }

     // And that might have run _more_ XBL constructors

     NS_ENSURE_STATE(!mHaveShutDown);

   }

   NS_ASSERTION(rootFrame, "How did that happen?");

   // Note: when the frame was created above it had the NS_FRAME_IS_DIRTY bit

   // set, but XBL processing could have caused a reflow which clears it.

   if (MOZ_LIKELY(rootFrame->GetStateBits() & NS_FRAME_IS_DIRTY)) {

     // Unset the DIRTY bits so that FrameNeedsReflow() will work right.

     rootFrame->RemoveStateBits(NS_FRAME_IS_DIRTY |

                                NS_FRAME_HAS_DIRTY_CHILDREN);

     NS_ASSERTION(!mDirtyRoots.Contains(rootFrame),

                  "Why is the root in mDirtyRoots already?");

     FrameNeedsReflow(rootFrame, eResize, NS_FRAME_IS_DIRTY);

     NS_ASSERTION(mDirtyRoots.Contains(rootFrame),

                  "Should be in mDirtyRoots now");

     NS_ASSERTION(mReflowScheduled, "Why no reflow scheduled?");

   }

   // Restore our root scroll position now if we're getting here after EndLoad

   // got called, since this is our one chance to do it.  Note that we need not

   // have reflowed for this to work; when the scrollframe is finally reflowed

   // it'll pick up the position we store in it here.

   if (!mDocumentLoading) {

     RestoreRootScrollPosition();

   }

   // For printing, we just immediately unsuppress.

   if (!mPresContext->IsPaginated()) {

     // Kick off a one-shot timer based off our pref value.  When this timer

     // fires, if painting is still locked down, then we will go ahead and

     // trigger a full invalidate and allow painting to proceed normally.

     mPaintingSuppressed = true;

     // Don't suppress painting if the document isn't loading.

     nsIDocument::ReadyState readyState = mDocument->GetReadyStateEnum();

     if (readyState != nsIDocument::READYSTATE_COMPLETE) {

       mPaintSuppressionTimer = do_CreateInstance("@mozilla.org/timer;1");

     }

     if (!mPaintSuppressionTimer) {

       mPaintingSuppressed = false;

     } else {

       // Initialize the timer.

       // Default to PAINTLOCK_EVENT_DELAY if we can't get the pref value.

       int32_t delay =

         Preferences::GetInt("nglayout.initialpaint.delay",

                             PAINTLOCK_EVENT_DELAY);

       mPaintSuppressionTimer->InitWithFuncCallback(sPaintSuppressionCallback,

                                                    this, delay,

                                                    nsITimer::TYPE_ONE_SHOT);

     }

   }

   if (root && root->IsXUL()) {

     mozilla::Telemetry::AccumulateTimeDelta(Telemetry::XUL_INITIAL_FRAME_CONSTRUCTION,

                                             timerStart);

   }

   return NS_OK; //XXX this needs to be real. MMP

 }

 void

 PresShell::sPaintSuppressionCallback(nsITimer *aTimer, void* aPresShell)

 {

   nsRefPtr<PresShell> self = static_cast<PresShell*>(aPresShell);

   if (self)

     self->UnsuppressPainting();

 }

 void

 PresShell::AsyncResizeEventCallback(nsITimer* aTimer, void* aPresShell)

 {

   static_cast<PresShell*>(aPresShell)->FireResizeEvent();

 }

 nsresult

 PresShell::ResizeReflowOverride(nscoord aWidth, nscoord aHeight)

 {

   mViewportOverridden = true;

   return ResizeReflowIgnoreOverride(aWidth, aHeight);

 }

 nsresult

 PresShell::ResizeReflow(nscoord aWidth, nscoord aHeight)

 {

   if (mViewportOverridden) {

     // The viewport has been overridden, and this reflow request

     // didn't ask to ignore the override.  Pretend it didn't happen.

     return NS_OK;

   }

   return ResizeReflowIgnoreOverride(aWidth, aHeight);

 }

 nsresult

 PresShell::ResizeReflowIgnoreOverride(nscoord aWidth, nscoord aHeight)

 {

   NS_PRECONDITION(!mIsReflowing, "Shouldn't be in reflow here!");

   NS_PRECONDITION(aWidth != NS_UNCONSTRAINEDSIZE,

                   "shouldn't use unconstrained widths anymore");

   // If we don't have a root frame yet, that means we haven't had our initial

   // reflow... If that's the case, and aWidth or aHeight is unconstrained,

   // ignore them altogether.

   nsIFrame* rootFrame = mFrameConstructor->GetRootFrame();

   if (!rootFrame && aHeight == NS_UNCONSTRAINEDSIZE) {

     // We can't do the work needed for SizeToContent without a root

     // frame, and we want to return before setting the visible area.

     return NS_ERROR_NOT_AVAILABLE;

   }

   mPresContext->SetVisibleArea(nsRect(0, 0, aWidth, aHeight));

   // There isn't anything useful we can do if the initial reflow hasn't happened.

   if (!rootFrame) {

     return NS_OK;

   }

   nsRefPtr<nsViewManager> viewManagerDeathGrip = mViewManager;

   // Take this ref after viewManager so it'll make sure to go away first.

   nsCOMPtr<nsIPresShell> kungFuDeathGrip(this);

   if (!GetPresContext()->SupressingResizeReflow()) {

     // Have to make sure that the content notifications are flushed before we

     // start messing with the frame model; otherwise we can get content doubling.

     mDocument->FlushPendingNotifications(Flush_ContentAndNotify);

     // Make sure style is up to date

     {

       nsAutoScriptBlocker scriptBlocker;

       mPresContext->RestyleManager()->ProcessPendingRestyles();

     }

     rootFrame = mFrameConstructor->GetRootFrame();

     if (!mIsDestroying && rootFrame) {

       // XXX Do a full invalidate at the beginning so that invalidates along

       // the way don't have region accumulation issues?

       {

         nsAutoCauseReflowNotifier crNotifier(this);

         WillDoReflow();

         // Kick off a top-down reflow

         AUTO_LAYOUT_PHASE_ENTRY_POINT(GetPresContext(), Reflow);

         nsViewManager::AutoDisableRefresh refreshBlocker(mViewManager);

         mDirtyRoots.RemoveElement(rootFrame);

         DoReflow(rootFrame, true);

       }

       DidDoReflow(true, false);

     }

   }

   rootFrame = mFrameConstructor->GetRootFrame();

   if (aHeight == NS_UNCONSTRAINEDSIZE && rootFrame) {

     mPresContext->SetVisibleArea(

       nsRect(0, 0, aWidth, rootFrame->GetRect().height));

   }

   if (!mIsDestroying && !mResizeEvent.IsPending() &&

       !mAsyncResizeTimerIsActive) {

     if (mInResize) {

       if (!mAsyncResizeEventTimer) {

         mAsyncResizeEventTimer = do_CreateInstance("@mozilla.org/timer;1");

       }

       if (mAsyncResizeEventTimer) {

         mAsyncResizeTimerIsActive = true;

         mAsyncResizeEventTimer->InitWithFuncCallback(AsyncResizeEventCallback,

                                                      this, 15,

                                                      nsITimer::TYPE_ONE_SHOT);

       }

     } else {

       nsRefPtr<nsRunnableMethod<PresShell> > resizeEvent =

         NS_NewRunnableMethod(this, &PresShell::FireResizeEvent);

       if (NS_SUCCEEDED(NS_DispatchToCurrentThread(resizeEvent))) {

         mResizeEvent = resizeEvent;

         mDocument->SetNeedStyleFlush();

       }

     }

   }

   return NS_OK; //XXX this needs to be real. MMP

 }

 void

 PresShell::FireResizeEvent()

 {

   if (mAsyncResizeTimerIsActive) {

     mAsyncResizeTimerIsActive = false;

     mAsyncResizeEventTimer->Cancel();

   }

   mResizeEvent.Revoke();

   if (mIsDocumentGone)

     return;

   //Send resize event from here.

   WidgetEvent event(true, NS_RESIZE_EVENT);

   nsEventStatus status = nsEventStatus_eIgnore;

   nsPIDOMWindow *window = mDocument->GetWindow();

   if (window) {

     nsCOMPtr<nsIPresShell> kungFuDeathGrip(this);

     mInResize = true;

     EventDispatcher::Dispatch(window, mPresContext, &event, nullptr, &status);

     mInResize = false;

   }

 }

 void

 PresShell::SetIgnoreFrameDestruction(bool aIgnore)

 {

   if (mDocument) {

     // We need to tell the ImageLoader to drop all its references to frames

     // because they're about to go away and it won't get notifications of that.

     mDocument->StyleImageLoader()->ClearFrames();

   }

   mIgnoreFrameDestruction = aIgnore;

 }

 void

 PresShell::NotifyDestroyingFrame(nsIFrame* aFrame)

 {

   if (!mIgnoreFrameDestruction) {

     mDocument->StyleImageLoader()->DropRequestsForFrame(aFrame);

     mFrameConstructor->NotifyDestroyingFrame(aFrame);

     for (int32_t idx = mDirtyRoots.Length(); idx; ) {

       --idx;

       if (mDirtyRoots[idx] == aFrame) {

         mDirtyRoots.RemoveElementAt(idx);

       }

     }

     // Remove frame properties

     mPresContext->NotifyDestroyingFrame(aFrame);

     if (aFrame == mCurrentEventFrame) {

       mCurrentEventContent = aFrame->GetContent();

       mCurrentEventFrame = nullptr;

     }

   #ifdef DEBUG

     if (aFrame == mDrawEventTargetFrame) {

       mDrawEventTargetFrame = nullptr;

     }

   #endif

     for (unsigned int i=0; i < mCurrentEventFrameStack.Length(); i++) {

       if (aFrame == mCurrentEventFrameStack.ElementAt(i)) {

         //One of our stack frames was deleted.  Get its content so that when we

         //pop it we can still get its new frame from its content

         nsIContent *currentEventContent = aFrame->GetContent();

         mCurrentEventContentStack.ReplaceObjectAt(currentEventContent, i);

         mCurrentEventFrameStack[i] = nullptr;

       }

     }

     mFramesToDirty.RemoveEntry(aFrame);

   } else {

     // We must delete this property in situ so that its destructor removes the

     // frame from FrameLayerBuilder::DisplayItemData::mFrameList -- otherwise

     // the DisplayItemData destructor will use the destroyed frame when it

     // tries to remove it from the (array) value of this property.

     mPresContext->PropertyTable()->

       Delete(aFrame, FrameLayerBuilder::LayerManagerDataProperty());

   }

 }

 already_AddRefed<nsCaret> PresShell::GetCaret() const

 {

   nsRefPtr<nsCaret> caret = mCaret;

   return caret.forget();

 }

 void PresShell::MaybeInvalidateCaretPosition()

 {

   if (mCaret) {

     mCaret->InvalidateOutsideCaret();

   }

 }

 void PresShell::SetCaret(nsCaret *aNewCaret)

 {

   mCaret = aNewCaret;

 }

 void PresShell::RestoreCaret()

 {

   mCaret = mOriginalCaret;

 }

 NS_IMETHODIMP PresShell::SetCaretEnabled(bool aInEnable)

 {

   bool oldEnabled = mCaretEnabled;

   mCaretEnabled = aInEnable;

   if (mCaret && (mCaretEnabled != oldEnabled))

   {

 /*  Don't change the caret's selection here! This was an evil side-effect of SetCaretEnabled()

     nsCOMPtr<nsIDOMSelection> domSel;

     if (NS_SUCCEEDED(GetSelection(nsISelectionController::SELECTION_NORMAL, getter_AddRefs(domSel))) && domSel)

       mCaret->SetCaretDOMSelection(domSel);

 */

     mCaret->SetCaretVisible(mCaretEnabled);

   }

   return NS_OK;

 }

 NS_IMETHODIMP PresShell::SetCaretReadOnly(bool aReadOnly)

 {

   if (mCaret)

     mCaret->SetCaretReadOnly(aReadOnly);

   return NS_OK;

 }

 NS_IMETHODIMP PresShell::GetCaretEnabled(bool *aOutEnabled)

 {

   NS_ENSURE_ARG_POINTER(aOutEnabled);

   *aOutEnabled = mCaretEnabled;

   return NS_OK;

 }

 NS_IMETHODIMP PresShell::SetCaretVisibilityDuringSelection(bool aVisibility)

 {

   if (mCaret)

     mCaret->SetVisibilityDuringSelection(aVisibility);

   return NS_OK;

 }

 NS_IMETHODIMP PresShell::GetCaretVisible(bool *aOutIsVisible)

 {

   *aOutIsVisible = false;

   if (mCaret) {

     nsresult rv = mCaret->GetCaretVisible(aOutIsVisible);

     NS_ENSURE_SUCCESS(rv,rv);

   }

   return NS_OK;

 }

 NS_IMETHODIMP PresShell::SetSelectionFlags(int16_t aInEnable)

 {

   mSelectionFlags = aInEnable;

   return NS_OK;

 }

 NS_IMETHODIMP PresShell::GetSelectionFlags(int16_t *aOutEnable)

 {

   if (!aOutEnable)

     return NS_ERROR_INVALID_ARG;

   *aOutEnable = mSelectionFlags;

   return NS_OK;

 }

 //implementation of nsISelectionController

 NS_IMETHODIMP

 PresShell::CharacterMove(bool aForward, bool aExtend)

 {

   return mSelection->CharacterMove(aForward, aExtend);

 }

 NS_IMETHODIMP

 PresShell::CharacterExtendForDelete()

 {

   return mSelection->CharacterExtendForDelete();

 }

 NS_IMETHODIMP

 PresShell::CharacterExtendForBackspace()

 {

   return mSelection->CharacterExtendForBackspace();

 }

 NS_IMETHODIMP

 PresShell::WordMove(bool aForward, bool aExtend)

 {

   nsresult result = mSelection->WordMove(aForward, aExtend);

 // if we can't go down/up any more we must then move caret completely to

 // end/beginning respectively.

   if (NS_FAILED(result))

     result = CompleteMove(aForward, aExtend);

   return result;

 }

 NS_IMETHODIMP

 PresShell::WordExtendForDelete(bool aForward)

 {

   return mSelection->WordExtendForDelete(aForward);

 }

 NS_IMETHODIMP

 PresShell::LineMove(bool aForward, bool aExtend)

 {

   nsresult result = mSelection->LineMove(aForward, aExtend);

 // if we can't go down/up any more we must then move caret completely to

 // end/beginning respectively.

   if (NS_FAILED(result))

     result = CompleteMove(aForward,aExtend);

   return result;

 }

 NS_IMETHODIMP

 PresShell::IntraLineMove(bool aForward, bool aExtend)

 {

   return mSelection->IntraLineMove(aForward, aExtend);

 }

 NS_IMETHODIMP

 PresShell::PageMove(bool aForward, bool aExtend)

 {

   nsIScrollableFrame *scrollableFrame =

     GetFrameToScrollAsScrollable(nsIPresShell::eVertical);

   if (!scrollableFrame)

     return NS_OK;

   mSelection->CommonPageMove(aForward, aExtend, scrollableFrame);

   // After ScrollSelectionIntoView(), the pending notifications might be

   // flushed and PresShell/PresContext/Frames may be dead. See bug 418470.

   return ScrollSelectionIntoView(nsISelectionController::SELECTION_NORMAL,

                                  nsISelectionController::SELECTION_FOCUS_REGION,

                                  nsISelectionController::SCROLL_SYNCHRONOUS);

 }

 NS_IMETHODIMP

 PresShell::ScrollPage(bool aForward)

 {

   nsIScrollableFrame* scrollFrame =

     GetFrameToScrollAsScrollable(nsIPresShell::eVertical);

   if (scrollFrame) {

     scrollFrame->ScrollBy(nsIntPoint(0, aForward ? 1 : -1),

                           nsIScrollableFrame::PAGES,

                           nsIScrollableFrame::SMOOTH);

   }

   return NS_OK;

 }

 NS_IMETHODIMP

 PresShell::ScrollLine(bool aForward)

 {

   nsIScrollableFrame* scrollFrame =

     GetFrameToScrollAsScrollable(nsIPresShell::eVertical);

   if (scrollFrame) {

     int32_t lineCount = Preferences::GetInt("toolkit.scrollbox.verticalScrollDistance",

                                             NS_DEFAULT_VERTICAL_SCROLL_DISTANCE);

     scrollFrame->ScrollBy(nsIntPoint(0, aForward ? lineCount : -lineCount),

                           nsIScrollableFrame::LINES,

                           nsIScrollableFrame::SMOOTH);

   }

   return NS_OK;

 }

 NS_IMETHODIMP

 PresShell::ScrollCharacter(bool aRight)

 {

   nsIScrollableFrame* scrollFrame =

     GetFrameToScrollAsScrollable(nsIPresShell::eHorizontal);

   if (scrollFrame) {

     int32_t h = Preferences::GetInt("toolkit.scrollbox.horizontalScrollDistance",

                                     NS_DEFAULT_HORIZONTAL_SCROLL_DISTANCE);

     scrollFrame->ScrollBy(nsIntPoint(aRight ? h : -h, 0),

                           nsIScrollableFrame::LINES,

                           nsIScrollableFrame::SMOOTH);

   }

   return NS_OK;

 }

 NS_IMETHODIMP

 PresShell::CompleteScroll(bool aForward)

 {

   nsIScrollableFrame* scrollFrame =

     GetFrameToScrollAsScrollable(nsIPresShell::eVertical);

   if (scrollFrame) {

     scrollFrame->ScrollBy(nsIntPoint(0, aForward ? 1 : -1),

                           nsIScrollableFrame::WHOLE,

                           nsIScrollableFrame::SMOOTH);

   }

   return NS_OK;

 }

 NS_IMETHODIMP

 PresShell::CompleteMove(bool aForward, bool aExtend)

 {

   // Beware! This may flush notifications via synchronous

   // ScrollSelectionIntoView.

   nsIContent* limiter = mSelection->GetAncestorLimiter();

   nsIFrame* frame = limiter ? limiter->GetPrimaryFrame()

                             : FrameConstructor()->GetRootElementFrame();

   if (!frame)

     return NS_ERROR_FAILURE;

   nsIFrame::CaretPosition pos =

     frame->GetExtremeCaretPosition(!aForward);

   mSelection->HandleClick(pos.mResultContent, pos.mContentOffset,

                           pos.mContentOffset, aExtend, false, aForward);

   if (limiter) {

     // HandleClick resets ancestorLimiter, so set it again.

     mSelection->SetAncestorLimiter(limiter);

   }

   // After ScrollSelectionIntoView(), the pending notifications might be

   // flushed and PresShell/PresContext/Frames may be dead. See bug 418470.

   return ScrollSelectionIntoView(nsISelectionController::SELECTION_NORMAL,

                                  nsISelectionController::SELECTION_FOCUS_REGION,

                                  nsISelectionController::SCROLL_SYNCHRONOUS);

 }

 NS_IMETHODIMP

 PresShell::SelectAll()

 {

   return mSelection->SelectAll();

 }

 static void

 DoCheckVisibility(nsPresContext* aPresContext,

                   nsIContent* aNode,

                   int16_t aStartOffset,

                   int16_t aEndOffset,

                   bool* aRetval)

 {

   nsIFrame* frame = aNode->GetPrimaryFrame();

   if (!frame) {

     // No frame to look at so it must not be visible.

     return;

   }

   // Start process now to go through all frames to find startOffset. Then check

   // chars after that to see if anything until EndOffset is visible.

   bool finished = false;

   frame->CheckVisibility(aPresContext, aStartOffset, aEndOffset, true,

                          &finished, aRetval);

   // Don't worry about other return value.

 }

 NS_IMETHODIMP

 PresShell::CheckVisibility(nsIDOMNode *node, int16_t startOffset, int16_t EndOffset, bool *_retval)

 {

   if (!node || startOffset>EndOffset || !_retval || startOffset<0 || EndOffset<0)

     return NS_ERROR_INVALID_ARG;

   *_retval = false; //initialize return parameter

   nsCOMPtr<nsIContent> content(do_QueryInterface(node));

   if (!content)

     return NS_ERROR_FAILURE;

   DoCheckVisibility(mPresContext, content, startOffset, EndOffset, _retval);

   return NS_OK;

 }

 nsresult

 PresShell::CheckVisibilityContent(nsIContent* aNode, int16_t aStartOffset,

                                   int16_t aEndOffset, bool* aRetval)

 {

   if (!aNode || aStartOffset > aEndOffset || !aRetval ||

       aStartOffset < 0 || aEndOffset < 0) {

     return NS_ERROR_INVALID_ARG;

   }

   *aRetval = false;

   DoCheckVisibility(mPresContext, aNode, aStartOffset, aEndOffset, aRetval);

   return NS_OK;

 }

 //end implementations nsISelectionController

 nsIFrame*

 nsIPresShell::GetRootFrameExternal() const

 {

   return mFrameConstructor->GetRootFrame();

 }

 nsIFrame*

 nsIPresShell::GetRootScrollFrame() const

 {

   nsIFrame* rootFrame = mFrameConstructor->GetRootFrame();

   // Ensure root frame is a viewport frame

   if (!rootFrame || nsGkAtoms::viewportFrame != rootFrame->GetType())

     return nullptr;

   nsIFrame* theFrame = rootFrame->GetFirstPrincipalChild();

   if (!theFrame || nsGkAtoms::scrollFrame != theFrame->GetType())

     return nullptr;

   return theFrame;

 }

 nsIScrollableFrame*

 nsIPresShell::GetRootScrollFrameAsScrollable() const

 {

   nsIFrame* frame = GetRootScrollFrame();

   if (!frame)

     return nullptr;

   nsIScrollableFrame* scrollableFrame = do_QueryFrame(frame);

   NS_ASSERTION(scrollableFrame,

                "All scroll frames must implement nsIScrollableFrame");

   return scrollableFrame;

 }

 nsIScrollableFrame*

 nsIPresShell::GetRootScrollFrameAsScrollableExternal() const

 {

   return GetRootScrollFrameAsScrollable();

 }

 nsIPageSequenceFrame*

 PresShell::GetPageSequenceFrame() const

 {

   nsIFrame* frame = mFrameConstructor->GetPageSequenceFrame();

   return do_QueryFrame(frame);

 }

 void

 PresShell::BeginUpdate(nsIDocument *aDocument, nsUpdateType aUpdateType)

 {

 #ifdef DEBUG

   mUpdateCount++;

 #endif

   mFrameConstructor->BeginUpdate();

   if (aUpdateType & UPDATE_STYLE)

     mStyleSet->BeginUpdate();

 }

 void

 PresShell::EndUpdate(nsIDocument *aDocument, nsUpdateType aUpdateType)

 {

 #ifdef DEBUG

   NS_PRECONDITION(0 != mUpdateCount, "too many EndUpdate's");

   --mUpdateCount;

 #endif

   if (aUpdateType & UPDATE_STYLE) {

     mStyleSet->EndUpdate();

     if (mStylesHaveChanged || !mChangedScopeStyleRoots.IsEmpty())

       ReconstructStyleData();

   }

   mFrameConstructor->EndUpdate();

 }

 void

 PresShell::RestoreRootScrollPosition()

 {

   nsIScrollableFrame* scrollableFrame = GetRootScrollFrameAsScrollable();

   if (scrollableFrame) {

     scrollableFrame->ScrollToRestoredPosition();

   }

 }

 void

 PresShell::BeginLoad(nsIDocument *aDocument)

 {

   mDocumentLoading = true;

 #ifdef PR_LOGGING

   gfxTextPerfMetrics *tp = nullptr;

   if (mPresContext) {

     tp = mPresContext->GetTextPerfMetrics();

   }

   bool shouldLog = gLog && PR_LOG_TEST(gLog, PR_LOG_DEBUG);

   if (shouldLog || tp) {

     mLoadBegin = TimeStamp::Now();

   }

   if (shouldLog) {

     nsIURI* uri = mDocument->GetDocumentURI();

     nsAutoCString spec;

     if (uri) {

       uri->GetSpec(spec);

     }

     PR_LOG(gLog, PR_LOG_DEBUG,

            ("(presshell) %p load begin [%s]\n",

             this, spec.get()));

   }

 #endif

 }

 void

 PresShell::EndLoad(nsIDocument *aDocument)

 {

   NS_PRECONDITION(aDocument == mDocument, "Wrong document");

   RestoreRootScrollPosition();

   mDocumentLoading = false;

 }

 void

 PresShell::LoadComplete()

 {

 #ifdef PR_LOGGING

   gfxTextPerfMetrics *tp = nullptr;

   if (mPresContext) {

     tp = mPresContext->GetTextPerfMetrics();

   }

   // log load

   bool shouldLog = gLog && PR_LOG_TEST(gLog, PR_LOG_DEBUG);

   if (shouldLog || tp) {

     TimeDuration loadTime = TimeStamp::Now() - mLoadBegin;

     nsIURI* uri = mDocument->GetDocumentURI();

     nsAutoCString spec;

     if (uri) {

       uri->GetSpec(spec);

     }

     if (shouldLog) {

       PR_LOG(gLog, PR_LOG_DEBUG,

              ("(presshell) %p load done time-ms: %9.2f [%s]\n",

               this, loadTime.ToMilliseconds(), spec.get()));

     }

     if (tp) {

       tp->Accumulate();

       if (tp->cumulative.numChars > 0) {

         LogTextPerfStats(tp, this, tp->cumulative, loadTime.ToMilliseconds(),

                          eLog_loaddone, spec.get());

       }

     }

   }

 #endif

 }

 #ifdef DEBUG

 void

 PresShell::VerifyHasDirtyRootAncestor(nsIFrame* aFrame)

 {

   // XXXbz due to bug 372769, can't actually assert anything here...

   return;

   // XXXbz shouldn't need this part; remove it once FrameNeedsReflow

   // handles the root frame correctly.

   if (!aFrame->GetParent()) {

     return;

   }

   // Make sure that there is a reflow root ancestor of |aFrame| that's

   // in mDirtyRoots already.

   while (aFrame && (aFrame->GetStateBits() & NS_FRAME_HAS_DIRTY_CHILDREN)) {

     if (((aFrame->GetStateBits() & NS_FRAME_REFLOW_ROOT) ||

          !aFrame->GetParent()) &&

         mDirtyRoots.Contains(aFrame)) {

       return;

     }

     aFrame = aFrame->GetParent();

   }

   NS_NOTREACHED("Frame has dirty bits set but isn't scheduled to be "

                 "reflowed?");

 }

 #endif

 void

 PresShell::FrameNeedsReflow(nsIFrame *aFrame, IntrinsicDirty aIntrinsicDirty,

                             nsFrameState aBitToAdd)

 {

   NS_PRECONDITION(aBitToAdd == NS_FRAME_IS_DIRTY ||

                   aBitToAdd == NS_FRAME_HAS_DIRTY_CHILDREN ||

                   !aBitToAdd,

                   "Unexpected bits being added");

   NS_PRECONDITION(!(aIntrinsicDirty == eStyleChange &&

                     aBitToAdd == NS_FRAME_HAS_DIRTY_CHILDREN),

                   "bits don't correspond to style change reason");

   NS_ASSERTION(!mIsReflowing, "can't mark frame dirty during reflow");

   // If we've not yet done the initial reflow, then don't bother

   // enqueuing a reflow command yet.

   if (! mDidInitialize)

     return;

   // If we're already destroying, don't bother with this either.

   if (mIsDestroying)

     return;

 #ifdef DEBUG

   //printf("gShellCounter: %d\n", gShellCounter++);

   if (mInVerifyReflow)

     return;

   if (VERIFY_REFLOW_NOISY_RC & gVerifyReflowFlags) {

     printf("\nPresShell@%p: frame %p needs reflow\n", (void*)this, (void*)aFrame);

     if (VERIFY_REFLOW_REALLY_NOISY_RC & gVerifyReflowFlags) {

       printf("Current content model:\n");

       Element *rootElement = mDocument->GetRootElement();

       if (rootElement) {