michael@0: /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
michael@0: /* This Source Code Form is subject to the terms of the Mozilla Public
michael@0:  * License, v. 2.0. If a copy of the MPL was not distributed with this
michael@0:  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
michael@0: 
michael@0: /*
michael@0:  * rendering object for replaced elements that contain a document, such
michael@0:  * as <frame>, <iframe>, and some <object>s
michael@0:  */
michael@0: 
michael@0: #include "nsSubDocumentFrame.h"
michael@0: 
michael@0: #include "mozilla/layout/RenderFrameParent.h"
michael@0: 
michael@0: #include "nsCOMPtr.h"
michael@0: #include "nsGenericHTMLElement.h"
michael@0: #include "nsGenericHTMLFrameElement.h"
michael@0: #include "nsAttrValueInlines.h"
michael@0: #include "nsIDocShell.h"
michael@0: #include "nsIContentViewer.h"
michael@0: #include "nsPresContext.h"
michael@0: #include "nsIPresShell.h"
michael@0: #include "nsIDocument.h"
michael@0: #include "nsView.h"
michael@0: #include "nsViewManager.h"
michael@0: #include "nsGkAtoms.h"
michael@0: #include "nsStyleConsts.h"
michael@0: #include "nsFrameSetFrame.h"
michael@0: #include "nsIDOMHTMLFrameElement.h"
michael@0: #include "nsIScrollable.h"
michael@0: #include "nsNameSpaceManager.h"
michael@0: #include "nsDisplayList.h"
michael@0: #include "nsIScrollableFrame.h"
michael@0: #include "nsIObjectLoadingContent.h"
michael@0: #include "nsLayoutUtils.h"
michael@0: #include "FrameLayerBuilder.h"
michael@0: #include "nsObjectFrame.h"
michael@0: #include "nsContentUtils.h"
michael@0: #include "nsIPermissionManager.h"
michael@0: #include "nsServiceManagerUtils.h"
michael@0: 
michael@0: using namespace mozilla;
michael@0: using mozilla::layout::RenderFrameParent;
michael@0: 
michael@0: static nsIDocument*
michael@0: GetDocumentFromView(nsView* aView)
michael@0: {
michael@0:   NS_PRECONDITION(aView, "");
michael@0: 
michael@0:   nsIFrame* f = aView->GetFrame();
michael@0:   nsIPresShell* ps =  f ? f->PresContext()->PresShell() : nullptr;
michael@0:   return ps ? ps->GetDocument() : nullptr;
michael@0: }
michael@0: 
michael@0: nsSubDocumentFrame::nsSubDocumentFrame(nsStyleContext* aContext)
michael@0:   : nsLeafFrame(aContext)
michael@0:   , mIsInline(false)
michael@0:   , mPostedReflowCallback(false)
michael@0:   , mDidCreateDoc(false)
michael@0:   , mCallingShow(false)
michael@0: {
michael@0: }
michael@0: 
michael@0: #ifdef ACCESSIBILITY
michael@0: a11y::AccType
michael@0: nsSubDocumentFrame::AccessibleType()
michael@0: {
michael@0:   return a11y::eOuterDocType;
michael@0: }
michael@0: #endif
michael@0: 
michael@0: NS_QUERYFRAME_HEAD(nsSubDocumentFrame)
michael@0:   NS_QUERYFRAME_ENTRY(nsSubDocumentFrame)
michael@0: NS_QUERYFRAME_TAIL_INHERITING(nsLeafFrame)
michael@0: 
michael@0: class AsyncFrameInit : public nsRunnable
michael@0: {
michael@0: public:
michael@0:   AsyncFrameInit(nsIFrame* aFrame) : mFrame(aFrame) {}
michael@0:   NS_IMETHOD Run()
michael@0:   {
michael@0:     if (mFrame.IsAlive()) {
michael@0:       static_cast<nsSubDocumentFrame*>(mFrame.GetFrame())->ShowViewer();
michael@0:     }
michael@0:     return NS_OK;
michael@0:   }
michael@0: private:
michael@0:   nsWeakFrame mFrame;
michael@0: };
michael@0: 
michael@0: static void
michael@0: InsertViewsInReverseOrder(nsView* aSibling, nsView* aParent);
michael@0: 
michael@0: static void
michael@0: EndSwapDocShellsForViews(nsView* aView);
michael@0: 
michael@0: void
michael@0: nsSubDocumentFrame::Init(nsIContent*     aContent,
michael@0:                          nsIFrame*       aParent,
michael@0:                          nsIFrame*       aPrevInFlow)
michael@0: {
michael@0:   // determine if we are a <frame> or <iframe>
michael@0:   if (aContent) {
michael@0:     nsCOMPtr<nsIDOMHTMLFrameElement> frameElem = do_QueryInterface(aContent);
michael@0:     mIsInline = frameElem ? false : true;
michael@0:   }
michael@0: 
michael@0:   nsLeafFrame::Init(aContent, aParent, aPrevInFlow);
michael@0: 
michael@0:   // We are going to create an inner view.  If we need a view for the
michael@0:   // OuterFrame but we wait for the normal view creation path in
michael@0:   // nsCSSFrameConstructor, then we will lose because the inner view's
michael@0:   // parent will already have been set to some outer view (e.g., the
michael@0:   // canvas) when it really needs to have this frame's view as its
michael@0:   // parent. So, create this frame's view right away, whether we
michael@0:   // really need it or not, and the inner view will get it as the
michael@0:   // parent.
michael@0:   if (!HasView()) {
michael@0:     nsContainerFrame::CreateViewForFrame(this, true);
michael@0:   }
michael@0:   EnsureInnerView();
michael@0: 
michael@0:   // Set the primary frame now so that nsDocumentViewer::FindContainerView
michael@0:   // called from within EndSwapDocShellsForViews below can find it if needed.
michael@0:   aContent->SetPrimaryFrame(this);
michael@0: 
michael@0:   // If we have a detached subdoc's root view on our frame loader, re-insert
michael@0:   // it into the view tree. This happens when we've been reframed, and
michael@0:   // ensures the presentation persists across reframes. If the frame element
michael@0:   // has changed documents however, we blow away the presentation.
michael@0:   nsRefPtr<nsFrameLoader> frameloader = FrameLoader();
michael@0:   if (frameloader) {
michael@0:     nsCOMPtr<nsIDocument> oldContainerDoc;
michael@0:     nsView* detachedViews =
michael@0:       frameloader->GetDetachedSubdocView(getter_AddRefs(oldContainerDoc));
michael@0:     if (detachedViews) {
michael@0:       if (oldContainerDoc == aContent->OwnerDoc()) {
michael@0:         // Restore stashed presentation.
michael@0:         ::InsertViewsInReverseOrder(detachedViews, mInnerView);
michael@0:         ::EndSwapDocShellsForViews(mInnerView->GetFirstChild());
michael@0:       } else {
michael@0:         // Presentation is for a different document, don't restore it.
michael@0:         frameloader->Hide();
michael@0:       }
michael@0:     }
michael@0:     frameloader->SetDetachedSubdocView(nullptr, nullptr);
michael@0:   }
michael@0: 
michael@0:   nsContentUtils::AddScriptRunner(new AsyncFrameInit(this));
michael@0: }
michael@0: 
michael@0: void
michael@0: nsSubDocumentFrame::ShowViewer()
michael@0: {
michael@0:   if (mCallingShow) {
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   if (!PresContext()->IsDynamic()) {
michael@0:     // We let the printing code take care of loading the document; just
michael@0:     // create the inner view for it to use.
michael@0:     (void) EnsureInnerView();
michael@0:   } else {
michael@0:     nsRefPtr<nsFrameLoader> frameloader = FrameLoader();
michael@0:     if (frameloader) {
michael@0:       nsIntSize margin = GetMarginAttributes();
michael@0:       nsWeakFrame weakThis(this);
michael@0:       mCallingShow = true;
michael@0:       const nsAttrValue* attrValue =
michael@0:         GetContent()->AsElement()->GetParsedAttr(nsGkAtoms::scrolling);
michael@0:       int32_t scrolling =
michael@0:         nsGenericHTMLFrameElement::MapScrollingAttribute(attrValue);
michael@0:       bool didCreateDoc =
michael@0:         frameloader->Show(margin.width, margin.height,
michael@0:                           scrolling, scrolling, this);
michael@0:       if (!weakThis.IsAlive()) {
michael@0:         return;
michael@0:       }
michael@0:       mCallingShow = false;
michael@0:       mDidCreateDoc = didCreateDoc;
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: nsIFrame*
michael@0: nsSubDocumentFrame::GetSubdocumentRootFrame()
michael@0: {
michael@0:   if (!mInnerView)
michael@0:     return nullptr;
michael@0:   nsView* subdocView = mInnerView->GetFirstChild();
michael@0:   return subdocView ? subdocView->GetFrame() : nullptr;
michael@0: }
michael@0: 
michael@0: nsIntSize
michael@0: nsSubDocumentFrame::GetSubdocumentSize()
michael@0: {
michael@0:   if (GetStateBits() & NS_FRAME_FIRST_REFLOW) {
michael@0:     nsRefPtr<nsFrameLoader> frameloader = FrameLoader();
michael@0:     if (frameloader) {
michael@0:       nsCOMPtr<nsIDocument> oldContainerDoc;
michael@0:       nsView* detachedViews =
michael@0:         frameloader->GetDetachedSubdocView(getter_AddRefs(oldContainerDoc));
michael@0:       if (detachedViews) {
michael@0:         nsSize size = detachedViews->GetBounds().Size();
michael@0:         nsPresContext* presContext = detachedViews->GetFrame()->PresContext();
michael@0:         return nsIntSize(presContext->AppUnitsToDevPixels(size.width),
michael@0:                          presContext->AppUnitsToDevPixels(size.height));
michael@0:       }
michael@0:     }
michael@0:     // Pick some default size for now.  Using 10x10 because that's what the
michael@0:     // code used to do.
michael@0:     return nsIntSize(10, 10);
michael@0:   } else {
michael@0:     nsSize docSizeAppUnits;
michael@0:     nsPresContext* presContext = PresContext();
michael@0:     nsCOMPtr<nsIDOMHTMLFrameElement> frameElem =
michael@0:       do_QueryInterface(GetContent());
michael@0:     if (frameElem) {
michael@0:       docSizeAppUnits = GetSize();
michael@0:     } else {
michael@0:       docSizeAppUnits = GetContentRect().Size();
michael@0:     }
michael@0:     return nsIntSize(presContext->AppUnitsToDevPixels(docSizeAppUnits.width),
michael@0:                      presContext->AppUnitsToDevPixels(docSizeAppUnits.height));
michael@0:   }
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsSubDocumentFrame::PassPointerEventsToChildren()
michael@0: {
michael@0:   // Limit use of mozpasspointerevents to documents with embedded:apps/chrome
michael@0:   // permission, because this could be used by the parent document to discover
michael@0:   // which parts of the subdocument are transparent to events (if subdocument
michael@0:   // uses pointer-events:none on its root element, which is admittedly
michael@0:   // unlikely)
michael@0:   if (mContent->HasAttr(kNameSpaceID_None, nsGkAtoms::mozpasspointerevents)) {
michael@0:       if (PresContext()->IsChrome()) {
michael@0:         return true;
michael@0:       }
michael@0: 
michael@0:       nsCOMPtr<nsIPermissionManager> permMgr =
michael@0:         do_GetService(NS_PERMISSIONMANAGER_CONTRACTID);
michael@0:       if (permMgr) {
michael@0:         uint32_t permission = nsIPermissionManager::DENY_ACTION;
michael@0:         permMgr->TestPermissionFromPrincipal(GetContent()->NodePrincipal(),
michael@0:                                              "embed-apps", &permission);
michael@0: 
michael@0:         return permission == nsIPermissionManager::ALLOW_ACTION;
michael@0:       }
michael@0:   }
michael@0: 
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: static void
michael@0: WrapBackgroundColorInOwnLayer(nsDisplayListBuilder* aBuilder,
michael@0:                               nsIFrame* aFrame,
michael@0:                               nsDisplayList* aList)
michael@0: {
michael@0:   nsDisplayList tempItems;
michael@0:   nsDisplayItem* item;
michael@0:   while ((item = aList->RemoveBottom()) != nullptr) {
michael@0:     if (item->GetType() == nsDisplayItem::TYPE_BACKGROUND_COLOR) {
michael@0:       nsDisplayList tmpList;
michael@0:       tmpList.AppendToTop(item);
michael@0:       item = new (aBuilder) nsDisplayOwnLayer(aBuilder, aFrame, &tmpList);
michael@0:     }
michael@0:     tempItems.AppendToTop(item);
michael@0:   }
michael@0:   aList->AppendToTop(&tempItems);
michael@0: }
michael@0: 
michael@0: void
michael@0: nsSubDocumentFrame::BuildDisplayList(nsDisplayListBuilder*   aBuilder,
michael@0:                                      const nsRect&           aDirtyRect,
michael@0:                                      const nsDisplayListSet& aLists)
michael@0: {
michael@0:   if (!IsVisibleForPainting(aBuilder))
michael@0:     return;
michael@0: 
michael@0:   nsFrameLoader* frameLoader = FrameLoader();
michael@0:   RenderFrameParent* rfp = nullptr;
michael@0:   if (frameLoader) {
michael@0:     rfp = frameLoader->GetCurrentRemoteFrame();
michael@0:   }
michael@0: 
michael@0:   // If we are pointer-events:none then we don't need to HitTest background
michael@0:   bool pointerEventsNone = StyleVisibility()->mPointerEvents == NS_STYLE_POINTER_EVENTS_NONE;
michael@0:   if (!aBuilder->IsForEventDelivery() || !pointerEventsNone) {
michael@0:     nsDisplayListCollection decorations;
michael@0:     DisplayBorderBackgroundOutline(aBuilder, decorations);
michael@0:     if (rfp) {
michael@0:       // Wrap background colors of <iframe>s with remote subdocuments in their
michael@0:       // own layer so we generate a ColorLayer. This is helpful for optimizing
michael@0:       // compositing; we can skip compositing the ColorLayer when the
michael@0:       // remote content is opaque.
michael@0:       WrapBackgroundColorInOwnLayer(aBuilder, this, decorations.BorderBackground());
michael@0:     }
michael@0:     decorations.MoveTo(aLists);
michael@0:   }
michael@0: 
michael@0:   bool passPointerEventsToChildren = false;
michael@0:   if (aBuilder->IsForEventDelivery()) {
michael@0:     passPointerEventsToChildren = PassPointerEventsToChildren();
michael@0:     // If mozpasspointerevents is set, then we should allow subdocument content
michael@0:     // to handle events even if we're pointer-events:none.
michael@0:     if (pointerEventsNone && !passPointerEventsToChildren) {
michael@0:       return;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // If we're passing pointer events to children then we have to descend into
michael@0:   // subdocuments no matter what, to determine which parts are transparent for
michael@0:   // elementFromPoint.
michael@0:   if (!mInnerView ||
michael@0:       (!aBuilder->GetDescendIntoSubdocuments() && !passPointerEventsToChildren)) {
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   if (rfp) {
michael@0:     rfp->BuildDisplayList(aBuilder, this, aDirtyRect, aLists);
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   nsView* subdocView = mInnerView->GetFirstChild();
michael@0:   if (!subdocView)
michael@0:     return;
michael@0: 
michael@0:   nsCOMPtr<nsIPresShell> presShell = nullptr;
michael@0: 
michael@0:   nsIFrame* subdocRootFrame = subdocView->GetFrame();
michael@0:   if (subdocRootFrame) {
michael@0:     presShell = subdocRootFrame->PresContext()->PresShell();
michael@0:   }
michael@0:   // If painting is suppressed in the presshell, we try to look for a better
michael@0:   // presshell to use.
michael@0:   if (!presShell || (presShell->IsPaintingSuppressed() &&
michael@0:                      !aBuilder->IsIgnoringPaintSuppression())) {
michael@0:     // During page transition mInnerView will sometimes have two children, the
michael@0:     // first being the new page that may not have any frame, and the second
michael@0:     // being the old page that will probably have a frame.
michael@0:     nsView* nextView = subdocView->GetNextSibling();
michael@0:     nsIFrame* frame = nullptr;
michael@0:     if (nextView) {
michael@0:       frame = nextView->GetFrame();
michael@0:     }
michael@0:     if (frame) {
michael@0:       nsIPresShell* ps = frame->PresContext()->PresShell();
michael@0:       if (!presShell || (ps && !ps->IsPaintingSuppressed())) {
michael@0:         subdocView = nextView;
michael@0:         subdocRootFrame = frame;
michael@0:         presShell = ps;
michael@0:       }
michael@0:     }
michael@0:     if (!presShell) {
michael@0:       // If we don't have a frame we use this roundabout way to get the pres shell.
michael@0:       if (!mFrameLoader)
michael@0:         return;
michael@0:       nsCOMPtr<nsIDocShell> docShell;
michael@0:       mFrameLoader->GetDocShell(getter_AddRefs(docShell));
michael@0:       if (!docShell)
michael@0:         return;
michael@0:       presShell = docShell->GetPresShell();
michael@0:       if (!presShell)
michael@0:         return;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   nsPresContext* presContext = presShell->GetPresContext();
michael@0: 
michael@0:   int32_t parentAPD = PresContext()->AppUnitsPerDevPixel();
michael@0:   int32_t subdocAPD = presContext->AppUnitsPerDevPixel();
michael@0: 
michael@0:   nsRect dirty;
michael@0:   bool haveDisplayPort = false;
michael@0:   bool ignoreViewportScrolling = false;
michael@0:   nsIFrame* savedIgnoreScrollFrame = nullptr;
michael@0:   if (subdocRootFrame) {
michael@0:     // get the dirty rect relative to the root frame of the subdoc
michael@0:     dirty = aDirtyRect + GetOffsetToCrossDoc(subdocRootFrame);
michael@0:     // and convert into the appunits of the subdoc
michael@0:     dirty = dirty.ConvertAppUnitsRoundOut(parentAPD, subdocAPD);
michael@0: 
michael@0:     if (nsIFrame* rootScrollFrame = presShell->GetRootScrollFrame()) {
michael@0:       // for root content documents we want the base to be the composition bounds
michael@0:       nsRect displayportBase = presContext->IsRootContentDocument() ?
michael@0:           nsRect(nsPoint(0,0), nsLayoutUtils::CalculateCompositionSizeForFrame(rootScrollFrame)) :
michael@0:           dirty.Intersect(nsRect(nsPoint(0,0), subdocRootFrame->GetSize()));
michael@0:       nsRect displayPort;
michael@0:       if (nsLayoutUtils::GetOrMaybeCreateDisplayPort(
michael@0:             *aBuilder, rootScrollFrame, displayportBase, &displayPort)) {
michael@0:         haveDisplayPort = true;
michael@0:         dirty = displayPort;
michael@0:       }
michael@0: 
michael@0:       ignoreViewportScrolling = presShell->IgnoringViewportScrolling();
michael@0:       if (ignoreViewportScrolling) {
michael@0:         savedIgnoreScrollFrame = aBuilder->GetIgnoreScrollFrame();
michael@0:         aBuilder->SetIgnoreScrollFrame(rootScrollFrame);
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     aBuilder->EnterPresShell(subdocRootFrame, dirty);
michael@0:   }
michael@0: 
michael@0:   DisplayListClipState::AutoSaveRestore clipState(aBuilder);
michael@0:   if (ShouldClipSubdocument()) {
michael@0:     clipState.ClipContainingBlockDescendantsToContentBox(aBuilder, this);
michael@0:   }
michael@0: 
michael@0:   nsIScrollableFrame *sf = presShell->GetRootScrollFrameAsScrollable();
michael@0:   bool constructResolutionItem = subdocRootFrame &&
michael@0:     (presShell->GetXResolution() != 1.0 || presShell->GetYResolution() != 1.0);
michael@0:   bool constructZoomItem = subdocRootFrame && parentAPD != subdocAPD;
michael@0:   bool needsOwnLayer = constructResolutionItem || constructZoomItem ||
michael@0:     haveDisplayPort ||
michael@0:     presContext->IsRootContentDocument() || (sf && sf->IsScrollingActive());
michael@0: 
michael@0:   // Don't let in fixed pos propagate down to child documents. This makes
michael@0:   // it a little less effective but doesn't regress an important case of a
michael@0:   // child document being in a fixed pos element where we would do no occlusion
michael@0:   // at all if we let it propagate down.
michael@0:   nsDisplayListBuilder::AutoInFixedPosSetter
michael@0:     buildingInFixedPos(aBuilder, false);
michael@0: 
michael@0:   nsDisplayList childItems;
michael@0: 
michael@0:   {
michael@0:     DisplayListClipState::AutoSaveRestore nestedClipState(aBuilder);
michael@0:     if (needsOwnLayer) {
michael@0:       // Clear current clip. There's no point in propagating it down, since
michael@0:       // the layer we will construct will be clipped by the current clip.
michael@0:       // In fact for nsDisplayZoom propagating it down would be incorrect since
michael@0:       // nsDisplayZoom changes the meaning of appunits.
michael@0:       nestedClipState.Clear();
michael@0:     }
michael@0: 
michael@0:     if (subdocRootFrame) {
michael@0:       nsDisplayListBuilder::AutoCurrentScrollParentIdSetter idSetter(
michael@0:           aBuilder,
michael@0:           ignoreViewportScrolling && subdocRootFrame->GetContent()
michael@0:               ? nsLayoutUtils::FindOrCreateIDFor(subdocRootFrame->GetContent())
michael@0:               : aBuilder->GetCurrentScrollParentId());
michael@0: 
michael@0:       aBuilder->SetAncestorHasTouchEventHandler(false);
michael@0:       subdocRootFrame->
michael@0:         BuildDisplayListForStackingContext(aBuilder, dirty, &childItems);
michael@0:     }
michael@0: 
michael@0:     if (!aBuilder->IsForEventDelivery()) {
michael@0:       // If we are going to use a displayzoom below then any items we put under
michael@0:       // it need to have underlying frames from the subdocument. So we need to
michael@0:       // calculate the bounds based on which frame will be the underlying frame
michael@0:       // for the canvas background color item.
michael@0:       nsRect bounds = GetContentRectRelativeToSelf() +
michael@0:         aBuilder->ToReferenceFrame(this);
michael@0:       if (subdocRootFrame) {
michael@0:         bounds = bounds.ConvertAppUnitsRoundOut(parentAPD, subdocAPD);
michael@0:       }
michael@0: 
michael@0:       // If we are in print preview/page layout we want to paint the grey
michael@0:       // background behind the page, not the canvas color. The canvas color gets
michael@0:       // painted on the page itself.
michael@0:       if (nsLayoutUtils::NeedsPrintPreviewBackground(presContext)) {
michael@0:         presShell->AddPrintPreviewBackgroundItem(
michael@0:           *aBuilder, childItems, subdocRootFrame ? subdocRootFrame : this,
michael@0:           bounds);
michael@0:       } else {
michael@0:         // Add the canvas background color to the bottom of the list. This
michael@0:         // happens after we've built the list so that AddCanvasBackgroundColorItem
michael@0:         // can monkey with the contents if necessary.
michael@0:         uint32_t flags = nsIPresShell::FORCE_DRAW;
michael@0:         presShell->AddCanvasBackgroundColorItem(
michael@0:           *aBuilder, childItems, subdocRootFrame ? subdocRootFrame : this,
michael@0:           bounds, NS_RGBA(0,0,0,0), flags);
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // Generate a resolution and/or zoom item if needed. If one or both of those is
michael@0:   // created, we don't need to create a separate nsDisplaySubDocument.
michael@0: 
michael@0:   uint32_t flags = nsDisplayOwnLayer::GENERATE_SUBDOC_INVALIDATIONS;
michael@0:   // If ignoreViewportScrolling is true then the top most layer we create here
michael@0:   // is going to become the scrollable layer for the root scroll frame, so we
michael@0:   // want to add nsDisplayOwnLayer::GENERATE_SCROLLABLE_LAYER to whatever layer
michael@0:   // becomes the topmost. We do this below.
michael@0:   if (constructZoomItem) {
michael@0:     uint32_t zoomFlags = flags;
michael@0:     if (ignoreViewportScrolling && !constructResolutionItem) {
michael@0:       zoomFlags |= nsDisplayOwnLayer::GENERATE_SCROLLABLE_LAYER;
michael@0:     }
michael@0:     nsDisplayZoom* zoomItem =
michael@0:       new (aBuilder) nsDisplayZoom(aBuilder, subdocRootFrame, &childItems,
michael@0:                                    subdocAPD, parentAPD, zoomFlags);
michael@0:     childItems.AppendToTop(zoomItem);
michael@0:     needsOwnLayer = false;
michael@0:   }
michael@0:   // Wrap the zoom item in the resolution item if we have both because we want the
michael@0:   // resolution scale applied on top of the app units per dev pixel conversion.
michael@0:   if (ignoreViewportScrolling) {
michael@0:     flags |= nsDisplayOwnLayer::GENERATE_SCROLLABLE_LAYER;
michael@0:   }
michael@0:   if (constructResolutionItem) {
michael@0:     nsDisplayResolution* resolutionItem =
michael@0:       new (aBuilder) nsDisplayResolution(aBuilder, subdocRootFrame, &childItems,
michael@0:                                          flags);
michael@0:     childItems.AppendToTop(resolutionItem);
michael@0:     needsOwnLayer = false;
michael@0:   }
michael@0:   if (needsOwnLayer) {
michael@0:     // We always want top level content documents to be in their own layer.
michael@0:     nsDisplaySubDocument* layerItem = new (aBuilder) nsDisplaySubDocument(
michael@0:       aBuilder, subdocRootFrame ? subdocRootFrame : this,
michael@0:       &childItems, flags);
michael@0:     childItems.AppendToTop(layerItem);
michael@0:   }
michael@0: 
michael@0:   if (subdocRootFrame) {
michael@0:     aBuilder->LeavePresShell(subdocRootFrame, dirty);
michael@0: 
michael@0:     if (ignoreViewportScrolling) {
michael@0:       aBuilder->SetIgnoreScrollFrame(savedIgnoreScrollFrame);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   if (aBuilder->IsForImageVisibility()) {
michael@0:     // We don't add the childItems to the return list as we're dealing with them here.
michael@0:     presShell->RebuildImageVisibility(childItems);
michael@0:     childItems.DeleteAll();
michael@0:   } else {
michael@0:     aLists.Content()->AppendToTop(&childItems);
michael@0:   }
michael@0: }
michael@0: 
michael@0: nscoord
michael@0: nsSubDocumentFrame::GetIntrinsicWidth()
michael@0: {
michael@0:   if (!IsInline()) {
michael@0:     return 0;  // HTML <frame> has no useful intrinsic width
michael@0:   }
michael@0: 
michael@0:   if (mContent->IsXUL()) {
michael@0:     return 0;  // XUL <iframe> and <browser> have no useful intrinsic width
michael@0:   }
michael@0: 
michael@0:   NS_ASSERTION(ObtainIntrinsicSizeFrame() == nullptr,
michael@0:                "Intrinsic width should come from the embedded document.");
michael@0: 
michael@0:   // We must be an HTML <iframe>.  Default to a width of 300, for IE
michael@0:   // compat (and per CSS2.1 draft).
michael@0:   return nsPresContext::CSSPixelsToAppUnits(300);
michael@0: }
michael@0: 
michael@0: nscoord
michael@0: nsSubDocumentFrame::GetIntrinsicHeight()
michael@0: {
michael@0:   // <frame> processing does not use this routine, only <iframe>
michael@0:   NS_ASSERTION(IsInline(), "Shouldn't have been called");
michael@0: 
michael@0:   if (mContent->IsXUL()) {
michael@0:     return 0;
michael@0:   }
michael@0: 
michael@0:   NS_ASSERTION(ObtainIntrinsicSizeFrame() == nullptr,
michael@0:                "Intrinsic height should come from the embedded document.");
michael@0: 
michael@0:   // Use 150px, for compatibility with IE, and per CSS2.1 draft.
michael@0:   return nsPresContext::CSSPixelsToAppUnits(150);
michael@0: }
michael@0: 
michael@0: #ifdef DEBUG_FRAME_DUMP
michael@0: void
michael@0: nsSubDocumentFrame::List(FILE* out, const char* aPrefix, uint32_t aFlags) const
michael@0: {
michael@0:   nsCString str;
michael@0:   ListGeneric(str, aPrefix, aFlags);
michael@0:   fprintf_stderr(out, "%s\n", str.get());
michael@0: 
michael@0:   if (aFlags & TRAVERSE_SUBDOCUMENT_FRAMES) {
michael@0:     nsSubDocumentFrame* f = const_cast<nsSubDocumentFrame*>(this);
michael@0:     nsIFrame* subdocRootFrame = f->GetSubdocumentRootFrame();
michael@0:     if (subdocRootFrame) {
michael@0:       nsCString pfx(aPrefix);
michael@0:       pfx += "  ";
michael@0:       subdocRootFrame->List(out, pfx.get(), aFlags);
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: nsresult nsSubDocumentFrame::GetFrameName(nsAString& aResult) const
michael@0: {
michael@0:   return MakeFrameName(NS_LITERAL_STRING("FrameOuter"), aResult);
michael@0: }
michael@0: #endif
michael@0: 
michael@0: nsIAtom*
michael@0: nsSubDocumentFrame::GetType() const
michael@0: {
michael@0:   return nsGkAtoms::subDocumentFrame;
michael@0: }
michael@0: 
michael@0: /* virtual */ nscoord
michael@0: nsSubDocumentFrame::GetMinWidth(nsRenderingContext *aRenderingContext)
michael@0: {
michael@0:   nscoord result;
michael@0:   DISPLAY_MIN_WIDTH(this, result);
michael@0: 
michael@0:   nsIFrame* subDocRoot = ObtainIntrinsicSizeFrame();
michael@0:   if (subDocRoot) {
michael@0:     result = subDocRoot->GetMinWidth(aRenderingContext);
michael@0:   } else {
michael@0:     result = GetIntrinsicWidth();
michael@0:   }
michael@0: 
michael@0:   return result;
michael@0: }
michael@0: 
michael@0: /* virtual */ nscoord
michael@0: nsSubDocumentFrame::GetPrefWidth(nsRenderingContext *aRenderingContext)
michael@0: {
michael@0:   nscoord result;
michael@0:   DISPLAY_PREF_WIDTH(this, result);
michael@0: 
michael@0:   nsIFrame* subDocRoot = ObtainIntrinsicSizeFrame();
michael@0:   if (subDocRoot) {
michael@0:     result = subDocRoot->GetPrefWidth(aRenderingContext);
michael@0:   } else {
michael@0:     result = GetIntrinsicWidth();
michael@0:   }
michael@0: 
michael@0:   return result;
michael@0: }
michael@0: 
michael@0: /* virtual */ IntrinsicSize
michael@0: nsSubDocumentFrame::GetIntrinsicSize()
michael@0: {
michael@0:   nsIFrame* subDocRoot = ObtainIntrinsicSizeFrame();
michael@0:   if (subDocRoot) {
michael@0:     return subDocRoot->GetIntrinsicSize();
michael@0:   }
michael@0:   return nsLeafFrame::GetIntrinsicSize();
michael@0: }
michael@0: 
michael@0: /* virtual */ nsSize
michael@0: nsSubDocumentFrame::GetIntrinsicRatio()
michael@0: {
michael@0:   nsIFrame* subDocRoot = ObtainIntrinsicSizeFrame();
michael@0:   if (subDocRoot) {
michael@0:     return subDocRoot->GetIntrinsicRatio();
michael@0:   }
michael@0:   return nsLeafFrame::GetIntrinsicRatio();
michael@0: }
michael@0: 
michael@0: /* virtual */ nsSize
michael@0: nsSubDocumentFrame::ComputeAutoSize(nsRenderingContext *aRenderingContext,
michael@0:                                     nsSize aCBSize, nscoord aAvailableWidth,
michael@0:                                     nsSize aMargin, nsSize aBorder,
michael@0:                                     nsSize aPadding, bool aShrinkWrap)
michael@0: {
michael@0:   if (!IsInline()) {
michael@0:     return nsFrame::ComputeAutoSize(aRenderingContext, aCBSize,
michael@0:                                     aAvailableWidth, aMargin, aBorder,
michael@0:                                     aPadding, aShrinkWrap);
michael@0:   }
michael@0: 
michael@0:   return nsLeafFrame::ComputeAutoSize(aRenderingContext, aCBSize,
michael@0:                                       aAvailableWidth, aMargin, aBorder,
michael@0:                                       aPadding, aShrinkWrap);  
michael@0: }
michael@0: 
michael@0: 
michael@0: /* virtual */ nsSize
michael@0: nsSubDocumentFrame::ComputeSize(nsRenderingContext *aRenderingContext,
michael@0:                                 nsSize aCBSize, nscoord aAvailableWidth,
michael@0:                                 nsSize aMargin, nsSize aBorder, nsSize aPadding,
michael@0:                                 uint32_t aFlags)
michael@0: {
michael@0:   nsIFrame* subDocRoot = ObtainIntrinsicSizeFrame();
michael@0:   if (subDocRoot) {
michael@0:     return nsLayoutUtils::ComputeSizeWithIntrinsicDimensions(
michael@0:                             aRenderingContext, this,
michael@0:                             subDocRoot->GetIntrinsicSize(),
michael@0:                             subDocRoot->GetIntrinsicRatio(),
michael@0:                             aCBSize, aMargin, aBorder, aPadding);
michael@0:   }
michael@0:   return nsLeafFrame::ComputeSize(aRenderingContext, aCBSize, aAvailableWidth,
michael@0:                                   aMargin, aBorder, aPadding, aFlags);
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsSubDocumentFrame::Reflow(nsPresContext*           aPresContext,
michael@0:                            nsHTMLReflowMetrics&     aDesiredSize,
michael@0:                            const nsHTMLReflowState& aReflowState,
michael@0:                            nsReflowStatus&          aStatus)
michael@0: {
michael@0:   DO_GLOBAL_REFLOW_COUNT("nsSubDocumentFrame");
michael@0:   DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
michael@0:   // printf("OuterFrame::Reflow %X (%d,%d) \n", this, aReflowState.AvailableWidth(), aReflowState.AvailableHeight());
michael@0:   NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS,
michael@0:      ("enter nsSubDocumentFrame::Reflow: maxSize=%d,%d",
michael@0:       aReflowState.AvailableWidth(), aReflowState.AvailableHeight()));
michael@0: 
michael@0:   aStatus = NS_FRAME_COMPLETE;
michael@0: 
michael@0:   NS_ASSERTION(mContent->GetPrimaryFrame() == this,
michael@0:                "Shouldn't happen");
michael@0: 
michael@0:   // XUL <iframe> or <browser>, or HTML <iframe>, <object> or <embed>
michael@0:   nsresult rv = nsLeafFrame::DoReflow(aPresContext, aDesiredSize, aReflowState,
michael@0:                                       aStatus);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   // "offset" is the offset of our content area from our frame's
michael@0:   // top-left corner.
michael@0:   nsPoint offset = nsPoint(aReflowState.ComputedPhysicalBorderPadding().left,
michael@0:                            aReflowState.ComputedPhysicalBorderPadding().top);
michael@0: 
michael@0:   nsSize innerSize(aDesiredSize.Width(), aDesiredSize.Height());
michael@0:   innerSize.width  -= aReflowState.ComputedPhysicalBorderPadding().LeftRight();
michael@0:   innerSize.height -= aReflowState.ComputedPhysicalBorderPadding().TopBottom();
michael@0: 
michael@0:   if (mInnerView) {
michael@0:     nsViewManager* vm = mInnerView->GetViewManager();
michael@0:     vm->MoveViewTo(mInnerView, offset.x, offset.y);
michael@0:     vm->ResizeView(mInnerView, nsRect(nsPoint(0, 0), innerSize), true);
michael@0:   }
michael@0: 
michael@0:   aDesiredSize.SetOverflowAreasToDesiredBounds();
michael@0:   if (!ShouldClipSubdocument()) {
michael@0:     nsIFrame* subdocRootFrame = GetSubdocumentRootFrame();
michael@0:     if (subdocRootFrame) {
michael@0:       aDesiredSize.mOverflowAreas.UnionWith(subdocRootFrame->GetOverflowAreas() + offset);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   FinishAndStoreOverflow(&aDesiredSize);
michael@0: 
michael@0:   if (!aPresContext->IsPaginated() && !mPostedReflowCallback) {
michael@0:     PresContext()->PresShell()->PostReflowCallback(this);
michael@0:     mPostedReflowCallback = true;
michael@0:   }
michael@0: 
michael@0:   // printf("OuterFrame::Reflow DONE %X (%d,%d)\n", this,
michael@0:   //        aDesiredSize.Width(), aDesiredSize.Height());
michael@0: 
michael@0:   NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS,
michael@0:      ("exit nsSubDocumentFrame::Reflow: size=%d,%d status=%x",
michael@0:       aDesiredSize.Width(), aDesiredSize.Height(), aStatus));
michael@0: 
michael@0:   NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsSubDocumentFrame::ReflowFinished()
michael@0: {
michael@0:   if (mFrameLoader) {
michael@0:     nsWeakFrame weakFrame(this);
michael@0: 
michael@0:     mFrameLoader->UpdatePositionAndSize(this);
michael@0: 
michael@0:     if (weakFrame.IsAlive()) {
michael@0:       // Make sure that we can post a reflow callback in the future.
michael@0:       mPostedReflowCallback = false;
michael@0:     }
michael@0:   } else {
michael@0:     mPostedReflowCallback = false;
michael@0:   }
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsSubDocumentFrame::ReflowCallbackCanceled()
michael@0: {
michael@0:   mPostedReflowCallback = false;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsSubDocumentFrame::AttributeChanged(int32_t aNameSpaceID,
michael@0:                                      nsIAtom* aAttribute,
michael@0:                                      int32_t aModType)
michael@0: {
michael@0:   if (aNameSpaceID != kNameSpaceID_None) {
michael@0:     return NS_OK;
michael@0:   }
michael@0:   
michael@0:   // If the noResize attribute changes, dis/allow frame to be resized
michael@0:   if (aAttribute == nsGkAtoms::noresize) {
michael@0:     // Note that we're not doing content type checks, but that's ok -- if
michael@0:     // they'd fail we will just end up with a null framesetFrame.
michael@0:     if (mContent->GetParent()->Tag() == nsGkAtoms::frameset) {
michael@0:       nsIFrame* parentFrame = GetParent();
michael@0: 
michael@0:       if (parentFrame) {
michael@0:         // There is no interface for nsHTMLFramesetFrame so QI'ing to
michael@0:         // concrete class, yay!
michael@0:         nsHTMLFramesetFrame* framesetFrame = do_QueryFrame(parentFrame);
michael@0:         if (framesetFrame) {
michael@0:           framesetFrame->RecalculateBorderResize();
michael@0:         }
michael@0:       }
michael@0:     }
michael@0:   }
michael@0:   else if (aAttribute == nsGkAtoms::showresizer) {
michael@0:     nsIFrame* rootFrame = GetSubdocumentRootFrame();
michael@0:     if (rootFrame) {
michael@0:       rootFrame->PresContext()->PresShell()->
michael@0:         FrameNeedsReflow(rootFrame, nsIPresShell::eResize, NS_FRAME_IS_DIRTY);
michael@0:     }
michael@0:   }
michael@0:   else if (aAttribute == nsGkAtoms::marginwidth ||
michael@0:            aAttribute == nsGkAtoms::marginheight) {
michael@0: 
michael@0:     // Retrieve the attributes
michael@0:     nsIntSize margins = GetMarginAttributes();
michael@0: 
michael@0:     // Notify the frameloader
michael@0:     nsRefPtr<nsFrameLoader> frameloader = FrameLoader();
michael@0:     if (frameloader)
michael@0:       frameloader->MarginsChanged(margins.width, margins.height);
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: nsIFrame*
michael@0: NS_NewSubDocumentFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
michael@0: {
michael@0:   return new (aPresShell) nsSubDocumentFrame(aContext);
michael@0: }
michael@0: 
michael@0: NS_IMPL_FRAMEARENA_HELPERS(nsSubDocumentFrame)
michael@0: 
michael@0: class nsHideViewer : public nsRunnable {
michael@0: public:
michael@0:   nsHideViewer(nsIContent* aFrameElement,
michael@0:                nsFrameLoader* aFrameLoader,
michael@0:                nsIPresShell* aPresShell,
michael@0:                bool aHideViewerIfFrameless)
michael@0:     : mFrameElement(aFrameElement),
michael@0:       mFrameLoader(aFrameLoader),
michael@0:       mPresShell(aPresShell),
michael@0:       mHideViewerIfFrameless(aHideViewerIfFrameless)
michael@0:   {
michael@0:     NS_ASSERTION(mFrameElement, "Must have a frame element");
michael@0:     NS_ASSERTION(mFrameLoader, "Must have a frame loader");
michael@0:     NS_ASSERTION(mPresShell, "Must have a presshell");
michael@0:   }
michael@0: 
michael@0:   NS_IMETHOD Run()
michael@0:   {
michael@0:     // Flush frames, to ensure any pending display:none changes are made.
michael@0:     // Note it can be unsafe to flush if we've destroyed the presentation
michael@0:     // for some other reason, like if we're shutting down.
michael@0:     if (!mPresShell->IsDestroying()) {
michael@0:       mPresShell->FlushPendingNotifications(Flush_Frames);
michael@0:     }
michael@0:     nsIFrame* frame = mFrameElement->GetPrimaryFrame();
michael@0:     if ((!frame && mHideViewerIfFrameless) ||
michael@0:         mPresShell->IsDestroying()) {
michael@0:       // Either the frame element has no nsIFrame or the presshell is being
michael@0:       // destroyed. Hide the nsFrameLoader, which destroys the presentation,
michael@0:       // and clear our references to the stashed presentation.
michael@0:       mFrameLoader->SetDetachedSubdocView(nullptr, nullptr);
michael@0:       mFrameLoader->Hide();
michael@0:     }
michael@0:     return NS_OK;
michael@0:   }
michael@0: private:
michael@0:   nsCOMPtr<nsIContent> mFrameElement;
michael@0:   nsRefPtr<nsFrameLoader> mFrameLoader;
michael@0:   nsCOMPtr<nsIPresShell> mPresShell;
michael@0:   bool mHideViewerIfFrameless;
michael@0: };
michael@0: 
michael@0: static nsView*
michael@0: BeginSwapDocShellsForViews(nsView* aSibling);
michael@0: 
michael@0: void
michael@0: nsSubDocumentFrame::DestroyFrom(nsIFrame* aDestructRoot)
michael@0: {
michael@0:   if (mPostedReflowCallback) {
michael@0:     PresContext()->PresShell()->CancelReflowCallback(this);
michael@0:     mPostedReflowCallback = false;
michael@0:   }
michael@0: 
michael@0:   // Detach the subdocument's views and stash them in the frame loader.
michael@0:   // We can then reattach them if we're being reframed (for example if
michael@0:   // the frame has been made position:fixed).
michael@0:   nsFrameLoader* frameloader = FrameLoader();
michael@0:   if (frameloader) {
michael@0:     nsView* detachedViews = ::BeginSwapDocShellsForViews(mInnerView->GetFirstChild());
michael@0:     frameloader->SetDetachedSubdocView(detachedViews, mContent->OwnerDoc());
michael@0: 
michael@0:     // We call nsFrameLoader::HideViewer() in a script runner so that we can
michael@0:     // safely determine whether the frame is being reframed or destroyed.
michael@0:     nsContentUtils::AddScriptRunner(
michael@0:       new nsHideViewer(mContent,
michael@0:                        mFrameLoader,
michael@0:                        PresContext()->PresShell(),
michael@0:                        (mDidCreateDoc || mCallingShow)));
michael@0:   }
michael@0: 
michael@0:   nsLeafFrame::DestroyFrom(aDestructRoot);
michael@0: }
michael@0: 
michael@0: nsIntSize
michael@0: nsSubDocumentFrame::GetMarginAttributes()
michael@0: {
michael@0:   nsIntSize result(-1, -1);
michael@0:   nsGenericHTMLElement *content = nsGenericHTMLElement::FromContent(mContent);
michael@0:   if (content) {
michael@0:     const nsAttrValue* attr = content->GetParsedAttr(nsGkAtoms::marginwidth);
michael@0:     if (attr && attr->Type() == nsAttrValue::eInteger)
michael@0:       result.width = attr->GetIntegerValue();
michael@0:     attr = content->GetParsedAttr(nsGkAtoms::marginheight);
michael@0:     if (attr && attr->Type() == nsAttrValue::eInteger)
michael@0:       result.height = attr->GetIntegerValue();
michael@0:   }
michael@0:   return result;
michael@0: }
michael@0: 
michael@0: nsFrameLoader*
michael@0: nsSubDocumentFrame::FrameLoader()
michael@0: {
michael@0:   nsIContent* content = GetContent();
michael@0:   if (!content)
michael@0:     return nullptr;
michael@0: 
michael@0:   if (!mFrameLoader) {
michael@0:     nsCOMPtr<nsIFrameLoaderOwner> loaderOwner = do_QueryInterface(content);
michael@0:     if (loaderOwner) {
michael@0:       nsCOMPtr<nsIFrameLoader> loader;
michael@0:       loaderOwner->GetFrameLoader(getter_AddRefs(loader));
michael@0:       mFrameLoader = static_cast<nsFrameLoader*>(loader.get());
michael@0:     }
michael@0:   }
michael@0:   return mFrameLoader;
michael@0: }
michael@0: 
michael@0: // XXX this should be called ObtainDocShell or something like that,
michael@0: // to indicate that it could have side effects
michael@0: nsresult
michael@0: nsSubDocumentFrame::GetDocShell(nsIDocShell **aDocShell)
michael@0: {
michael@0:   *aDocShell = nullptr;
michael@0: 
michael@0:   NS_ENSURE_STATE(FrameLoader());
michael@0:   return mFrameLoader->GetDocShell(aDocShell);
michael@0: }
michael@0: 
michael@0: static void
michael@0: DestroyDisplayItemDataForFrames(nsIFrame* aFrame)
michael@0: {
michael@0:   FrameLayerBuilder::DestroyDisplayItemDataFor(aFrame);
michael@0: 
michael@0:   nsIFrame::ChildListIterator lists(aFrame);
michael@0:   for (; !lists.IsDone(); lists.Next()) {
michael@0:     nsFrameList::Enumerator childFrames(lists.CurrentList());
michael@0:     for (; !childFrames.AtEnd(); childFrames.Next()) {
michael@0:       DestroyDisplayItemDataForFrames(childFrames.get());
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: static bool
michael@0: BeginSwapDocShellsForDocument(nsIDocument* aDocument, void*)
michael@0: {
michael@0:   NS_PRECONDITION(aDocument, "");
michael@0: 
michael@0:   nsIPresShell* shell = aDocument->GetShell();
michael@0:   if (shell) {
michael@0:     // Disable painting while the views are detached, see bug 946929.
michael@0:     shell->SetNeverPainting(true);
michael@0: 
michael@0:     nsIFrame* rootFrame = shell->GetRootFrame();
michael@0:     if (rootFrame) {
michael@0:       ::DestroyDisplayItemDataForFrames(rootFrame);
michael@0:     }
michael@0:   }
michael@0:   aDocument->EnumerateFreezableElements(
michael@0:     nsObjectFrame::BeginSwapDocShells, nullptr);
michael@0:   aDocument->EnumerateSubDocuments(BeginSwapDocShellsForDocument, nullptr);
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: static nsView*
michael@0: BeginSwapDocShellsForViews(nsView* aSibling)
michael@0: {
michael@0:   // Collect the removed sibling views in reverse order in 'removedViews'.
michael@0:   nsView* removedViews = nullptr;
michael@0:   while (aSibling) {
michael@0:     nsIDocument* doc = ::GetDocumentFromView(aSibling);
michael@0:     if (doc) {
michael@0:       ::BeginSwapDocShellsForDocument(doc, nullptr);
michael@0:     }
michael@0:     nsView* next = aSibling->GetNextSibling();
michael@0:     aSibling->GetViewManager()->RemoveChild(aSibling);
michael@0:     aSibling->SetNextSibling(removedViews);
michael@0:     removedViews = aSibling;
michael@0:     aSibling = next;
michael@0:   }
michael@0:   return removedViews;
michael@0: }
michael@0: 
michael@0: static void
michael@0: InsertViewsInReverseOrder(nsView* aSibling, nsView* aParent)
michael@0: {
michael@0:   NS_PRECONDITION(aParent, "");
michael@0:   NS_PRECONDITION(!aParent->GetFirstChild(), "inserting into non-empty list");
michael@0: 
michael@0:   nsViewManager* vm = aParent->GetViewManager();
michael@0:   while (aSibling) {
michael@0:     nsView* next = aSibling->GetNextSibling();
michael@0:     aSibling->SetNextSibling(nullptr);
michael@0:     // true means 'after' in document order which is 'before' in view order,
michael@0:     // so this call prepends the child, thus reversing the siblings as we go.
michael@0:     vm->InsertChild(aParent, aSibling, nullptr, true);
michael@0:     aSibling = next;
michael@0:   }
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsSubDocumentFrame::BeginSwapDocShells(nsIFrame* aOther)
michael@0: {
michael@0:   if (!aOther || aOther->GetType() != nsGkAtoms::subDocumentFrame) {
michael@0:     return NS_ERROR_NOT_IMPLEMENTED;
michael@0:   }
michael@0: 
michael@0:   nsSubDocumentFrame* other = static_cast<nsSubDocumentFrame*>(aOther);
michael@0:   if (!mFrameLoader || !mDidCreateDoc || mCallingShow ||
michael@0:       !other->mFrameLoader || !other->mDidCreateDoc) {
michael@0:     return NS_ERROR_NOT_IMPLEMENTED;
michael@0:   }
michael@0: 
michael@0:   if (mInnerView && other->mInnerView) {
michael@0:     nsView* ourSubdocViews = mInnerView->GetFirstChild();
michael@0:     nsView* ourRemovedViews = ::BeginSwapDocShellsForViews(ourSubdocViews);
michael@0:     nsView* otherSubdocViews = other->mInnerView->GetFirstChild();
michael@0:     nsView* otherRemovedViews = ::BeginSwapDocShellsForViews(otherSubdocViews);
michael@0: 
michael@0:     ::InsertViewsInReverseOrder(ourRemovedViews, other->mInnerView);
michael@0:     ::InsertViewsInReverseOrder(otherRemovedViews, mInnerView);
michael@0:   }
michael@0:   mFrameLoader.swap(other->mFrameLoader);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: EndSwapDocShellsForDocument(nsIDocument* aDocument, void*)
michael@0: {
michael@0:   NS_PRECONDITION(aDocument, "");
michael@0: 
michael@0:   // Our docshell and view trees have been updated for the new hierarchy.
michael@0:   // Now also update all nsDeviceContext::mWidget to that of the
michael@0:   // container view in the new hierarchy.
michael@0:   nsCOMPtr<nsIDocShell> ds = aDocument->GetDocShell();
michael@0:   if (ds) {
michael@0:     nsCOMPtr<nsIContentViewer> cv;
michael@0:     ds->GetContentViewer(getter_AddRefs(cv));
michael@0:     while (cv) {
michael@0:       nsRefPtr<nsPresContext> pc;
michael@0:       cv->GetPresContext(getter_AddRefs(pc));
michael@0:       if (pc && pc->GetPresShell()) {
michael@0:         pc->GetPresShell()->SetNeverPainting(ds->IsInvisible());
michael@0:       }
michael@0:       nsDeviceContext* dc = pc ? pc->DeviceContext() : nullptr;
michael@0:       if (dc) {
michael@0:         nsView* v = cv->FindContainerView();
michael@0:         dc->Init(v ? v->GetNearestWidget(nullptr) : nullptr);
michael@0:       }
michael@0:       nsCOMPtr<nsIContentViewer> prev;
michael@0:       cv->GetPreviousViewer(getter_AddRefs(prev));
michael@0:       cv = prev;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   aDocument->EnumerateFreezableElements(
michael@0:     nsObjectFrame::EndSwapDocShells, nullptr);
michael@0:   aDocument->EnumerateSubDocuments(EndSwapDocShellsForDocument, nullptr);
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: static void
michael@0: EndSwapDocShellsForViews(nsView* aSibling)
michael@0: {
michael@0:   for ( ; aSibling; aSibling = aSibling->GetNextSibling()) {
michael@0:     nsIDocument* doc = ::GetDocumentFromView(aSibling);
michael@0:     if (doc) {
michael@0:       ::EndSwapDocShellsForDocument(doc, nullptr);
michael@0:     }
michael@0:     nsIFrame *frame = aSibling->GetFrame();
michael@0:     if (frame) {
michael@0:       nsIFrame* parent = nsLayoutUtils::GetCrossDocParentFrame(frame);
michael@0:       if (parent->HasAnyStateBits(NS_FRAME_IN_POPUP)) {
michael@0:         nsIFrame::AddInPopupStateBitToDescendants(frame);
michael@0:       } else {
michael@0:         nsIFrame::RemoveInPopupStateBitFromDescendants(frame);
michael@0:       }
michael@0:       if (frame->HasInvalidFrameInSubtree()) {
michael@0:         while (parent && !parent->HasAnyStateBits(NS_FRAME_DESCENDANT_NEEDS_PAINT)) {
michael@0:           parent->AddStateBits(NS_FRAME_DESCENDANT_NEEDS_PAINT);
michael@0:           parent = nsLayoutUtils::GetCrossDocParentFrame(parent);
michael@0:         }
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: nsSubDocumentFrame::EndSwapDocShells(nsIFrame* aOther)
michael@0: {
michael@0:   nsSubDocumentFrame* other = static_cast<nsSubDocumentFrame*>(aOther);
michael@0:   nsWeakFrame weakThis(this);
michael@0:   nsWeakFrame weakOther(aOther);
michael@0: 
michael@0:   if (mInnerView) {
michael@0:     ::EndSwapDocShellsForViews(mInnerView->GetFirstChild());
michael@0:   }
michael@0:   if (other->mInnerView) {
michael@0:     ::EndSwapDocShellsForViews(other->mInnerView->GetFirstChild());
michael@0:   }
michael@0: 
michael@0:   // Now make sure we reflow both frames, in case their contents
michael@0:   // determine their size.
michael@0:   // And repaint them, for good measure, in case there's nothing
michael@0:   // interesting that happens during reflow.
michael@0:   if (weakThis.IsAlive()) {
michael@0:     PresContext()->PresShell()->
michael@0:       FrameNeedsReflow(this, nsIPresShell::eTreeChange, NS_FRAME_IS_DIRTY);
michael@0:     InvalidateFrameSubtree();
michael@0:   }
michael@0:   if (weakOther.IsAlive()) {
michael@0:     other->PresContext()->PresShell()->
michael@0:       FrameNeedsReflow(other, nsIPresShell::eTreeChange, NS_FRAME_IS_DIRTY);
michael@0:     other->InvalidateFrameSubtree();
michael@0:   }
michael@0: }
michael@0: 
michael@0: nsView*
michael@0: nsSubDocumentFrame::EnsureInnerView()
michael@0: {
michael@0:   if (mInnerView) {
michael@0:     return mInnerView;
michael@0:   }
michael@0: 
michael@0:   // create, init, set the parent of the view
michael@0:   nsView* outerView = GetView();
michael@0:   NS_ASSERTION(outerView, "Must have an outer view already");
michael@0:   nsRect viewBounds(0, 0, 0, 0); // size will be fixed during reflow
michael@0: 
michael@0:   nsViewManager* viewMan = outerView->GetViewManager();
michael@0:   nsView* innerView = viewMan->CreateView(viewBounds, outerView);
michael@0:   if (!innerView) {
michael@0:     NS_ERROR("Could not create inner view");
michael@0:     return nullptr;
michael@0:   }
michael@0:   mInnerView = innerView;
michael@0:   viewMan->InsertChild(outerView, innerView, nullptr, true);
michael@0: 
michael@0:   return mInnerView;
michael@0: }
michael@0: 
michael@0: nsIFrame*
michael@0: nsSubDocumentFrame::ObtainIntrinsicSizeFrame()
michael@0: {
michael@0:   nsCOMPtr<nsIObjectLoadingContent> olc = do_QueryInterface(GetContent());
michael@0:   if (olc) {
michael@0:     // We are an HTML <object>, <embed> or <applet> (a replaced element).
michael@0: 
michael@0:     // Try to get an nsIFrame for our sub-document's document element
michael@0:     nsIFrame* subDocRoot = nullptr;
michael@0: 
michael@0:     nsCOMPtr<nsIDocShell> docShell;
michael@0:     GetDocShell(getter_AddRefs(docShell));
michael@0:     if (docShell) {
michael@0:       nsCOMPtr<nsIPresShell> presShell = docShell->GetPresShell();
michael@0:       if (presShell) {
michael@0:         nsIScrollableFrame* scrollable = presShell->GetRootScrollFrameAsScrollable();
michael@0:         if (scrollable) {
michael@0:           nsIFrame* scrolled = scrollable->GetScrolledFrame();
michael@0:           if (scrolled) {
michael@0:             subDocRoot = scrolled->GetFirstPrincipalChild();
michael@0:           }
michael@0:         }
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     if (subDocRoot && subDocRoot->GetContent() &&
michael@0:         subDocRoot->GetContent()->NodeInfo()->Equals(nsGkAtoms::svg, kNameSpaceID_SVG)) {
michael@0:       return subDocRoot; // SVG documents have an intrinsic size
michael@0:     }
michael@0:   }
michael@0:   return nullptr;
michael@0: }