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

/* vim: set ts=8 sts=2 et sw=2 tw=80: */

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

/* rendering object that goes directly inside the document's scrollbars */

#include "nsCanvasFrame.h"

#include "gfxContext.h"

#include "gfxUtils.h"

#include "nsContainerFrame.h"

#include "nsContentCreatorFunctions.h"

#include "nsCSSRendering.h"

#include "nsPresContext.h"

#include "nsPopupSetFrame.h"

#include "nsGkAtoms.h"

#include "nsIFrameInlines.h"

#include "nsIPresShell.h"

#include "nsDisplayList.h"

#include "nsCSSFrameConstructor.h"

#include "nsFrameManager.h"

#include "gfxPlatform.h"

#include "nsPrintfCString.h"

#include "mozilla/AccessibleCaretEventHub.h"

#include "mozilla/ComputedStyle.h"

#include "mozilla/dom/AnonymousContent.h"

#include "mozilla/layers/StackingContextHelper.h"

#include "mozilla/layers/WebRenderLayerManager.h"

#include "mozilla/PresShell.h"

// for focus

#include "nsIScrollableFrame.h"

#ifdef DEBUG_CANVAS_FOCUS

#include "nsIDocShell.h"

#endif

//#define DEBUG_CANVAS_FOCUS

using namespace mozilla;

using namespace mozilla::dom;

using namespace mozilla::layout;

using namespace mozilla::gfx;

using namespace mozilla::layers;

nsCanvasFrame*

NS_NewCanvasFrame(nsIPresShell* aPresShell, ComputedStyle* aStyle)

{

  return new (aPresShell) nsCanvasFrame(aStyle);

}

NS_IMPL_FRAMEARENA_HELPERS(nsCanvasFrame)

NS_QUERYFRAME_HEAD(nsCanvasFrame)

  NS_QUERYFRAME_ENTRY(nsCanvasFrame)

  NS_QUERYFRAME_ENTRY(nsIAnonymousContentCreator)

  NS_QUERYFRAME_ENTRY(nsIPopupContainer)

NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)

void

nsCanvasFrame::ShowCustomContentContainer()

{

  if (mCustomContentContainer) {

    mCustomContentContainer->UnsetAttr(kNameSpaceID_None, nsGkAtoms::hidden, true);

  }

}

void

nsCanvasFrame::HideCustomContentContainer()

{

  if (mCustomContentContainer) {

    mCustomContentContainer->SetAttr(kNameSpaceID_None, nsGkAtoms::hidden,

                                     NS_LITERAL_STRING("true"),

                                     true);

  }

}

nsresult

nsCanvasFrame::CreateAnonymousContent(nsTArray<ContentInfo>& aElements)

{

  MOZ_ASSERT(!mCustomContentContainer);

  if (!mContent) {

    return NS_OK;

  }

  nsCOMPtr<nsIDocument> doc = mContent->OwnerDoc();

  RefPtr<AccessibleCaretEventHub> eventHub =

    PresShell()->GetAccessibleCaretEventHub();

  // This will go through InsertAnonymousContent and such, and we don't really

  // want it to end up inserting into our content container.

  //

  // FIXME(emilio): The fact that this enters into InsertAnonymousContent is a

  // bit nasty, can we avoid it, maybe doing this off a scriptrunner?

  if (eventHub) {

    eventHub->Init();

  }

  // Create the custom content container.

  mCustomContentContainer = doc->CreateHTMLElement(nsGkAtoms::div);

#ifdef DEBUG

  // We restyle our mCustomContentContainer, even though it's root anonymous

  // content.  Normally that's not OK because the frame constructor doesn't know

  // how to order the frame tree in such cases, but we make this work for this

  // particular case, so it's OK.

  mCustomContentContainer->SetProperty(nsGkAtoms::restylableAnonymousNode,

                                       reinterpret_cast<void*>(true));

#endif // DEBUG

  mCustomContentContainer->SetProperty(nsGkAtoms::docLevelNativeAnonymousContent,

                                       reinterpret_cast<void*>(true));

  // This will usually be done by the caller, but in this case we do it here,

  // since we reuse the document's AnoymousContent list, and those survive

  // across reframes and thus may already be flagged as being in an anonymous

  // subtree. We don't really want to have this semi-broken state where

  // anonymous nodes have a non-anonymous.

  mCustomContentContainer->SetIsNativeAnonymousRoot();

  aElements.AppendElement(mCustomContentContainer);

  // Do not create an accessible object for the container.

  mCustomContentContainer->SetAttr(kNameSpaceID_None, nsGkAtoms::role,

                                   NS_LITERAL_STRING("presentation"), false);

  mCustomContentContainer->SetAttr(kNameSpaceID_None, nsGkAtoms::_class,

                                   NS_LITERAL_STRING("moz-custom-content-container"),

                                   false);

  // Only create a frame for mCustomContentContainer if it has some children.

  if (doc->GetAnonymousContents().IsEmpty()) {

    HideCustomContentContainer();

  }

  for (RefPtr<AnonymousContent>& anonContent : doc->GetAnonymousContents()) {

    if (nsCOMPtr<nsINode> parent = anonContent->ContentNode().GetParentNode()) {

      // Parent had better be an old custom content container already removed

      // from a reframe. Forget about it since we're about to get inserted in a

      // new one.

      //

      // TODO(emilio): Maybe we should extend PostDestroyData and do this stuff

      // there instead, or something...

      MOZ_ASSERT(parent != mCustomContentContainer);

      MOZ_ASSERT(parent->IsElement());

      MOZ_ASSERT(parent->AsElement()->IsRootOfNativeAnonymousSubtree());

      MOZ_ASSERT(!parent->IsInComposedDoc());

      MOZ_ASSERT(!parent->GetParentNode());

      parent->RemoveChildNode(&anonContent->ContentNode(), false);

    }

    mCustomContentContainer->AppendChildTo(&anonContent->ContentNode(), false);

  }

  // Create a popupgroup element for chrome privileged top level non-XUL

  // documents to support context menus and tooltips.

  if (PresContext()->IsChrome() && PresContext()->IsRoot() &&

      doc->AllowXULXBL() && !doc->IsXULDocument()) {

    nsNodeInfoManager* nodeInfoManager = doc->NodeInfoManager();

    RefPtr<NodeInfo> nodeInfo =

      nodeInfoManager->GetNodeInfo(nsGkAtoms::popupgroup,

                                   nullptr, kNameSpaceID_XUL,

                                   nsINode::ELEMENT_NODE);

    nsresult rv = NS_NewXULElement(getter_AddRefs(mPopupgroupContent),

                                   nodeInfo.forget(),

                                   dom::NOT_FROM_PARSER);

    NS_ENSURE_SUCCESS(rv, rv);

    aElements.AppendElement(mPopupgroupContent);

    nodeInfo = nodeInfoManager->GetNodeInfo(nsGkAtoms::tooltip, nullptr,

                                          kNameSpaceID_XUL,

                                          nsINode::ELEMENT_NODE);

    rv = NS_NewXULElement(getter_AddRefs(mTooltipContent), nodeInfo.forget(),

                          dom::NOT_FROM_PARSER);

    NS_ENSURE_SUCCESS(rv, rv);

    mTooltipContent->SetAttr(kNameSpaceID_None, nsGkAtoms::_default,

                             NS_LITERAL_STRING("true"), false);

    // Set the page attribute so the XBL binding will find the text for the

    // tooltip from the currently hovered element.

    mTooltipContent->SetAttr(kNameSpaceID_None, nsGkAtoms::page,

                             NS_LITERAL_STRING("true"), false);

    aElements.AppendElement(mTooltipContent);

  }

  return NS_OK;

}

void

nsCanvasFrame::AppendAnonymousContentTo(nsTArray<nsIContent*>& aElements, uint32_t aFilter)

{

  if (mCustomContentContainer) {

    aElements.AppendElement(mCustomContentContainer);

  }

  if (mPopupgroupContent) {

    aElements.AppendElement(mPopupgroupContent);

  }

  if (mTooltipContent) {

    aElements.AppendElement(mTooltipContent);

  }

}

void

nsCanvasFrame::DestroyFrom(nsIFrame* aDestructRoot, PostDestroyData& aPostDestroyData)

{

  nsIScrollableFrame* sf =

    PresContext()->GetPresShell()->GetRootScrollFrameAsScrollable();

  if (sf) {

    sf->RemoveScrollPositionListener(this);

  }

  aPostDestroyData.AddAnonymousContent(mCustomContentContainer.forget());

  if (mPopupgroupContent) {

    aPostDestroyData.AddAnonymousContent(mPopupgroupContent.forget());

  }

  if (mTooltipContent) {

    aPostDestroyData.AddAnonymousContent(mTooltipContent.forget());

  }

  MOZ_ASSERT(!mPopupSetFrame ||

             nsLayoutUtils::IsProperAncestorFrame(this, mPopupSetFrame),

             "Someone forgot to clear popup set frame");

  nsContainerFrame::DestroyFrom(aDestructRoot, aPostDestroyData);

}

void

nsCanvasFrame::ScrollPositionWillChange(nscoord aX, nscoord aY)

{

  if (mDoPaintFocus) {

    mDoPaintFocus = false;

    PresShell()->GetRootFrame()->InvalidateFrameSubtree();

  }

}

NS_IMETHODIMP

nsCanvasFrame::SetHasFocus(bool aHasFocus)

{

  if (mDoPaintFocus != aHasFocus) {

    mDoPaintFocus = aHasFocus;

    PresShell()->GetRootFrame()->InvalidateFrameSubtree();

    if (!mAddedScrollPositionListener) {

      nsIScrollableFrame* sf =

        PresContext()->GetPresShell()->GetRootScrollFrameAsScrollable();

      if (sf) {

        sf->AddScrollPositionListener(this);

        mAddedScrollPositionListener = true;

      }

    }

  }

  return NS_OK;

}

void

nsCanvasFrame::SetInitialChildList(ChildListID     aListID,

                                   nsFrameList&    aChildList)

{

  NS_ASSERTION(aListID != kPrincipalList ||

               aChildList.IsEmpty() || aChildList.OnlyChild(),

               "Primary child list can have at most one frame in it");

  nsContainerFrame::SetInitialChildList(aListID, aChildList);

  MaybePropagateRootElementWritingMode();

}

void

nsCanvasFrame::AppendFrames(ChildListID     aListID,

                            nsFrameList&    aFrameList)

{

#ifdef DEBUG

  MOZ_ASSERT(aListID == kPrincipalList, "unexpected child list");

  if (!mFrames.IsEmpty()) {

    for (nsFrameList::Enumerator e(aFrameList); !e.AtEnd(); e.Next()) {

      // We only allow native anonymous child frames to be in principal child

      // list in canvas frame.

      MOZ_ASSERT(e.get()->GetContent()->IsInNativeAnonymousSubtree(),

                 "invalid child list");

    }

  }

  nsFrame::VerifyDirtyBitSet(aFrameList);

#endif

  nsContainerFrame::AppendFrames(aListID, aFrameList);

  MaybePropagateRootElementWritingMode();

}

void

nsCanvasFrame::InsertFrames(ChildListID     aListID,

                            nsIFrame*       aPrevFrame,

                            nsFrameList&    aFrameList)

{

  // Because we only support a single child frame inserting is the same

  // as appending

  MOZ_ASSERT(!aPrevFrame, "unexpected previous sibling frame");

  AppendFrames(aListID, aFrameList);

  MaybePropagateRootElementWritingMode();

}

#ifdef DEBUG

void

nsCanvasFrame::RemoveFrame(ChildListID     aListID,

                           nsIFrame*       aOldFrame)

{

  MOZ_ASSERT(aListID == kPrincipalList, "unexpected child list");

  nsContainerFrame::RemoveFrame(aListID, aOldFrame);

}

#endif

nsRect nsCanvasFrame::CanvasArea() const

{

  // Not clear which overflow rect we want here, but it probably doesn't

  // matter.

  nsRect result(GetVisualOverflowRect());

  nsIScrollableFrame *scrollableFrame = do_QueryFrame(GetParent());

  if (scrollableFrame) {

    nsRect portRect = scrollableFrame->GetScrollPortRect();

    result.UnionRect(result, nsRect(nsPoint(0, 0), portRect.Size()));

  }

  return result;

}

nsPopupSetFrame*

nsCanvasFrame::GetPopupSetFrame()

{

  return mPopupSetFrame;

}

void

nsCanvasFrame::SetPopupSetFrame(nsPopupSetFrame* aPopupSet)

{

  MOZ_ASSERT(!aPopupSet || !mPopupSetFrame,

             "Popup set is already defined! Only 1 allowed.");

  mPopupSetFrame = aPopupSet;

}

Element*

nsCanvasFrame::GetDefaultTooltip()

{

  return mTooltipContent;

}

void

nsCanvasFrame::SetDefaultTooltip(Element* aTooltip)

{

  MOZ_ASSERT(!aTooltip || aTooltip == mTooltipContent,

             "Default tooltip should be anonymous content tooltip.");

  mTooltipContent = aTooltip;

}

void

nsDisplayCanvasBackgroundColor::Paint(nsDisplayListBuilder* aBuilder,

                                      gfxContext* aCtx)

{

  nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);

  nsPoint offset = ToReferenceFrame();

  nsRect bgClipRect = frame->CanvasArea() + offset;

  if (NS_GET_A(mColor) > 0) {

    DrawTarget* drawTarget = aCtx->GetDrawTarget();

    int32_t appUnitsPerDevPixel = mFrame->PresContext()->AppUnitsPerDevPixel();

    Rect devPxRect =

      NSRectToSnappedRect(bgClipRect, appUnitsPerDevPixel, *drawTarget);

    drawTarget->FillRect(devPxRect, ColorPattern(ToDeviceColor(mColor)));

  }

}

already_AddRefed<Layer>

nsDisplayCanvasBackgroundColor::BuildLayer(nsDisplayListBuilder* aBuilder,

                                           LayerManager* aManager,

                                           const ContainerLayerParameters& aContainerParameters)

{

  if (NS_GET_A(mColor) == 0) {

    return nullptr;

  }

  RefPtr<ColorLayer> layer = static_cast<ColorLayer*>

    (aManager->GetLayerBuilder()->GetLeafLayerFor(aBuilder, this));

  if (!layer) {

    layer = aManager->CreateColorLayer();

    if (!layer) {

      return nullptr;

    }

  }

  layer->SetColor(ToDeviceColor(mColor));

  nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);

  nsPoint offset = ToReferenceFrame();

  nsRect bgClipRect = frame->CanvasArea() + offset;

  int32_t appUnitsPerDevPixel = mFrame->PresContext()->AppUnitsPerDevPixel();

  layer->SetBounds(bgClipRect.ToNearestPixels(appUnitsPerDevPixel));

  layer->SetBaseTransform(gfx::Matrix4x4::Translation(aContainerParameters.mOffset.x,

                                                      aContainerParameters.mOffset.y, 0));

  return layer.forget();

}

bool

nsDisplayCanvasBackgroundColor::CreateWebRenderCommands(mozilla::wr::DisplayListBuilder& aBuilder,

                                                        mozilla::wr::IpcResourceUpdateQueue& aResources,

                                                        const StackingContextHelper& aSc,

                                                        WebRenderLayerManager* aManager,

                                                        nsDisplayListBuilder* aDisplayListBuilder)

{

  ContainerLayerParameters parameter;

  nsCanvasFrame *frame = static_cast<nsCanvasFrame *>(mFrame);

  nsPoint offset = ToReferenceFrame();

  nsRect bgClipRect = frame->CanvasArea() + offset;

  int32_t appUnitsPerDevPixel = mFrame->PresContext()->AppUnitsPerDevPixel();

  LayoutDeviceRect rect = LayoutDeviceRect::FromAppUnits(

          bgClipRect, appUnitsPerDevPixel);

  wr::LayoutRect roundedRect = wr::ToRoundedLayoutRect(rect);

  aBuilder.PushRect(roundedRect,

                    roundedRect,

                    !BackfaceIsHidden(),

                    wr::ToColorF(ToDeviceColor(mColor)));

  return true;

}

#ifdef MOZ_DUMP_PAINTING

void

nsDisplayCanvasBackgroundColor::WriteDebugInfo(std::stringstream& aStream)

{

  aStream << " (rgba "

          << (int)NS_GET_R(mColor) << ","

          << (int)NS_GET_G(mColor) << ","

          << (int)NS_GET_B(mColor) << ","

          << (int)NS_GET_A(mColor) << ")";

}

#endif

void

nsDisplayCanvasBackgroundImage::Paint(nsDisplayListBuilder* aBuilder,

                                      gfxContext* aCtx)

{

  nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);

  nsPoint offset = ToReferenceFrame();

  nsRect bgClipRect = frame->CanvasArea() + offset;

  PaintInternal(aBuilder, aCtx, GetPaintRect(), &bgClipRect);

}

bool

nsDisplayCanvasBackgroundImage::IsSingleFixedPositionImage(nsDisplayListBuilder* aBuilder,

                                                           const nsRect& aClipRect,

                                                           gfxRect* aDestRect)

{

  if (!mBackgroundStyle)

    return false;

  if (mBackgroundStyle->StyleBackground()->mImage.mLayers.Length() != 1)

    return false;

  nsPresContext* presContext = mFrame->PresContext();

  uint32_t flags = aBuilder->GetBackgroundPaintFlags();

  nsRect borderArea = nsRect(ToReferenceFrame(), mFrame->GetSize());

  const nsStyleImageLayers::Layer &layer = mBackgroundStyle->StyleBackground()->mImage.mLayers[mLayer];

  if (layer.mAttachment != StyleImageLayerAttachment::Fixed)

    return false;

   nsBackgroundLayerState state =

     nsCSSRendering::PrepareImageLayer(presContext, mFrame, flags,

                                       borderArea, aClipRect, layer);

  // We only care about images here, not gradients.

  if (!mIsRasterImage)

    return false;

  int32_t appUnitsPerDevPixel = presContext->AppUnitsPerDevPixel();

  *aDestRect = nsLayoutUtils::RectToGfxRect(state.mFillArea, appUnitsPerDevPixel);

  return true;

}

void

nsDisplayCanvasThemedBackground::Paint(nsDisplayListBuilder* aBuilder,

                                       gfxContext* aCtx)

{

  nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);

  nsPoint offset = ToReferenceFrame();

  nsRect bgClipRect = frame->CanvasArea() + offset;

  PaintInternal(aBuilder, aCtx, GetPaintRect(), &bgClipRect);

}

/**

 * A display item to paint the focus ring for the document.

 *

 * The only reason this can't use nsDisplayGeneric is overriding GetBounds.

 */

class nsDisplayCanvasFocus : public nsDisplayItem {

public:

  nsDisplayCanvasFocus(nsDisplayListBuilder* aBuilder, nsCanvasFrame *aFrame)

    : nsDisplayItem(aBuilder, aFrame)

  {

    MOZ_COUNT_CTOR(nsDisplayCanvasFocus);

  }

  virtual ~nsDisplayCanvasFocus() {

    MOZ_COUNT_DTOR(nsDisplayCanvasFocus);

  }

  virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder,

                           bool* aSnap) const override

  {

    *aSnap = false;

    // This is an overestimate, but that's not a problem.

    nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);

    return frame->CanvasArea() + ToReferenceFrame();

  }

  virtual void Paint(nsDisplayListBuilder* aBuilder,

                     gfxContext* aCtx) override

  {

    nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);

    frame->PaintFocus(aCtx->GetDrawTarget(), ToReferenceFrame());

  }

  NS_DISPLAY_DECL_NAME("CanvasFocus", TYPE_CANVAS_FOCUS)

};

void

nsCanvasFrame::BuildDisplayList(nsDisplayListBuilder*   aBuilder,

                                const nsDisplayListSet& aLists)

{

  if (GetPrevInFlow()) {

    DisplayOverflowContainers(aBuilder, aLists);

  }

  // Force a background to be shown. We may have a background propagated to us,

  // in which case StyleBackground wouldn't have the right background

  // and the code in nsFrame::DisplayBorderBackgroundOutline might not give us

  // a background.

  // We don't have any border or outline, and our background draws over

  // the overflow area, so just add nsDisplayCanvasBackground instead of

  // calling DisplayBorderBackgroundOutline.

  if (IsVisibleForPainting(aBuilder)) {

    ComputedStyle* bg = nullptr;

    nsIFrame* dependentFrame = nullptr;

    bool isThemed = IsThemed();

    if (!isThemed && nsCSSRendering::FindBackgroundFrame(this, &dependentFrame)) {

      bg = dependentFrame->Style();

      if (dependentFrame == this) {

        dependentFrame = nullptr;

      }

    }

    aLists.BorderBackground()->AppendToTop(

        MakeDisplayItem<nsDisplayCanvasBackgroundColor>(aBuilder, this));

    if (isThemed) {

      aLists.BorderBackground()->AppendToTop(

        MakeDisplayItem<nsDisplayCanvasThemedBackground>(aBuilder, this));

      return;

    }

    if (!bg) {

      return;

    }

    const ActiveScrolledRoot* asr =

      aBuilder->CurrentActiveScrolledRoot();

    bool needBlendContainer = false;

    nsDisplayListBuilder::AutoContainerASRTracker contASRTracker(aBuilder);

    // Create separate items for each background layer.

    const nsStyleImageLayers& layers = bg->StyleBackground()->mImage;

    NS_FOR_VISIBLE_IMAGE_LAYERS_BACK_TO_FRONT(i, layers) {

      if (layers.mLayers[i].mImage.IsEmpty()) {

        continue;

      }

      if (layers.mLayers[i].mBlendMode != NS_STYLE_BLEND_NORMAL) {

        needBlendContainer = true;

      }

      nsRect bgRect = GetRectRelativeToSelf() + aBuilder->ToReferenceFrame(this);

      const ActiveScrolledRoot* thisItemASR = asr;

      nsDisplayList thisItemList;

      nsDisplayBackgroundImage::InitData bgData =

        nsDisplayBackgroundImage::GetInitData(aBuilder, this, i, bgRect, bg);

      if (bgData.shouldFixToViewport) {

        auto* displayData = aBuilder->GetCurrentFixedBackgroundDisplayData();

        nsDisplayListBuilder::AutoBuildingDisplayList

          buildingDisplayList(aBuilder, this, aBuilder->GetVisibleRect(), aBuilder->GetDirtyRect(), false);

        DisplayListClipState::AutoSaveRestore clipState(aBuilder);

        nsDisplayListBuilder::AutoCurrentActiveScrolledRootSetter asrSetter(aBuilder);

        if (displayData) {

          nsPoint offset = GetOffsetTo(PresContext()->GetPresShell()->GetRootFrame());

          aBuilder->SetVisibleRect(displayData->mVisibleRect + offset);

          aBuilder->SetDirtyRect(displayData->mDirtyRect + offset);

          clipState.SetClipChainForContainingBlockDescendants(

            displayData->mContainingBlockClipChain);

          asrSetter.SetCurrentActiveScrolledRoot(

            displayData->mContainingBlockActiveScrolledRoot);

          thisItemASR = displayData->mContainingBlockActiveScrolledRoot;

        }

        nsDisplayCanvasBackgroundImage* bgItem = nullptr;

        {

          DisplayListClipState::AutoSaveRestore bgImageClip(aBuilder);

          bgImageClip.Clear();

          bgItem = MakeDisplayItem<nsDisplayCanvasBackgroundImage>(aBuilder, bgData);

          bgItem->SetDependentFrame(aBuilder, dependentFrame);

        }

        thisItemList.AppendToTop(

          nsDisplayFixedPosition::CreateForFixedBackground(aBuilder, this, bgItem, i));

      } else {

        nsDisplayCanvasBackgroundImage* bgItem = MakeDisplayItem<nsDisplayCanvasBackgroundImage>(aBuilder, bgData);

        bgItem->SetDependentFrame(aBuilder, dependentFrame);

        thisItemList.AppendToTop(bgItem);

      }

      if (layers.mLayers[i].mBlendMode != NS_STYLE_BLEND_NORMAL) {

        DisplayListClipState::AutoSaveRestore blendClip(aBuilder);

        thisItemList.AppendToTop(

          MakeDisplayItem<nsDisplayBlendMode>(aBuilder, this, &thisItemList,

                                              layers.mLayers[i].mBlendMode,

                                              thisItemASR, i + 1));

      }

      aLists.BorderBackground()->AppendToTop(&thisItemList);

    }

    if (needBlendContainer) {

      const ActiveScrolledRoot* containerASR = contASRTracker.GetContainerASR();

      DisplayListClipState::AutoSaveRestore blendContainerClip(aBuilder);

      aLists.BorderBackground()->AppendToTop(

        nsDisplayBlendContainer::CreateForBackgroundBlendMode(aBuilder, this,

                                                              aLists.BorderBackground(),

                                                              containerASR));

    }

  }

  for (nsIFrame* kid : PrincipalChildList()) {

    // Put our child into its own pseudo-stack.

    BuildDisplayListForChild(aBuilder, kid, aLists);

  }

#ifdef DEBUG_CANVAS_FOCUS

  nsCOMPtr<nsIContent> focusContent;

  aPresContext->EventStateManager()->

    GetFocusedContent(getter_AddRefs(focusContent));

  bool hasFocus = false;

  nsCOMPtr<nsISupports> container;

  aPresContext->GetContainer(getter_AddRefs(container));

  nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(container));

  if (docShell) {

    docShell->GetHasFocus(&hasFocus);

    nsRect dirty = aBuilder->GetDirtyRect();

    printf("%p - nsCanvasFrame::Paint R:%d,%d,%d,%d  DR: %d,%d,%d,%d\n", this,

            mRect.x, mRect.y, mRect.width, mRect.height,

            dirty.x, dirty.y, dirty.width, dirty.height);

  }

  printf("%p - Focus: %s   c: %p  DoPaint:%s\n", docShell.get(), hasFocus?"Y":"N",

         focusContent.get(), mDoPaintFocus?"Y":"N");

#endif

  if (!mDoPaintFocus)

    return;

  // Only paint the focus if we're visible

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

    return;

  aLists.Outlines()->AppendToTop(

    MakeDisplayItem<nsDisplayCanvasFocus>(aBuilder, this));

}

void

nsCanvasFrame::PaintFocus(DrawTarget* aDrawTarget, nsPoint aPt)

{

  nsRect focusRect(aPt, GetSize());

  nsIScrollableFrame *scrollableFrame = do_QueryFrame(GetParent());

  if (scrollableFrame) {

    nsRect portRect = scrollableFrame->GetScrollPortRect();

    focusRect.width = portRect.width;

    focusRect.height = portRect.height;

    focusRect.MoveBy(scrollableFrame->GetScrollPosition());

  }

 // XXX use the root frame foreground color, but should we find BODY frame

 // for HTML documents?

  nsIFrame* root = mFrames.FirstChild();

  const nsStyleColor* color = root ? root->StyleColor() : StyleColor();

  if (!color) {

    NS_ERROR("current color cannot be found");

    return;

  }

  nsCSSRendering::PaintFocus(PresContext(), aDrawTarget,

                             focusRect, color->mColor);

}

/* virtual */ nscoord

nsCanvasFrame::GetMinISize(gfxContext *aRenderingContext)

{

  nscoord result;

  DISPLAY_MIN_INLINE_SIZE(this, result);

  if (mFrames.IsEmpty())

    result = 0;

  else

    result = mFrames.FirstChild()->GetMinISize(aRenderingContext);

  return result;

}

/* virtual */ nscoord

nsCanvasFrame::GetPrefISize(gfxContext *aRenderingContext)

{

  nscoord result;

  DISPLAY_PREF_INLINE_SIZE(this, result);

  if (mFrames.IsEmpty())

    result = 0;

  else

    result = mFrames.FirstChild()->GetPrefISize(aRenderingContext);

  return result;

}

void

nsCanvasFrame::Reflow(nsPresContext*           aPresContext,

                      ReflowOutput&     aDesiredSize,

                      const ReflowInput& aReflowInput,

                      nsReflowStatus&          aStatus)

{

  MarkInReflow();

  DO_GLOBAL_REFLOW_COUNT("nsCanvasFrame");

  DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);

  MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");

  NS_FRAME_TRACE_REFLOW_IN("nsCanvasFrame::Reflow");

  nsCanvasFrame* prevCanvasFrame = static_cast<nsCanvasFrame*>

                                               (GetPrevInFlow());

  if (prevCanvasFrame) {

    AutoFrameListPtr overflow(aPresContext,

                              prevCanvasFrame->StealOverflowFrames());

    if (overflow) {

      NS_ASSERTION(overflow->OnlyChild(),

                   "must have doc root as canvas frame's only child");

      nsContainerFrame::ReparentFrameViewList(*overflow, prevCanvasFrame, this);

      // Prepend overflow to the our child list. There may already be

      // children placeholders for fixed-pos elements, which don't get

      // reflowed but must not be lost until the canvas frame is destroyed.

      mFrames.InsertFrames(this, nullptr, *overflow);

    }

  }

  // Set our size up front, since some parts of reflow depend on it

  // being already set.  Note that the computed height may be

  // unconstrained; that's ok.  Consumers should watch out for that.

  SetSize(nsSize(aReflowInput.ComputedWidth(), aReflowInput.ComputedHeight()));

  // Reflow our one and only normal child frame. It's either the root

  // element's frame or a placeholder for that frame, if the root element

  // is abs-pos or fixed-pos. We may have additional children which

  // are placeholders for continuations of fixed-pos content, but those

  // don't need to be reflowed. The normal child is always comes before

  // the fixed-pos placeholders, because we insert it at the start

  // of the child list, above.

  ReflowOutput kidDesiredSize(aReflowInput);

  if (mFrames.IsEmpty()) {

    // We have no child frame, so return an empty size

    aDesiredSize.Width() = aDesiredSize.Height() = 0;

  } else if (mFrames.FirstChild() != mPopupSetFrame) {

    nsIFrame* kidFrame = mFrames.FirstChild();

    bool kidDirty = (kidFrame->GetStateBits() & NS_FRAME_IS_DIRTY) != 0;

    ReflowInput

      kidReflowInput(aPresContext, aReflowInput, kidFrame,

                     aReflowInput.AvailableSize(kidFrame->GetWritingMode()));

    if (aReflowInput.IsBResizeForWM(kidReflowInput.GetWritingMode()) &&

        (kidFrame->GetStateBits() & NS_FRAME_CONTAINS_RELATIVE_BSIZE)) {

      // Tell our kid it's being block-dir resized too.  Bit of a

      // hack for framesets.

      kidReflowInput.SetBResize(true);

    }

    WritingMode wm = aReflowInput.GetWritingMode();

    WritingMode kidWM = kidReflowInput.GetWritingMode();

    nsSize containerSize = aReflowInput.ComputedPhysicalSize();

    LogicalMargin margin = kidReflowInput.ComputedLogicalMargin();

    LogicalPoint kidPt(kidWM, margin.IStart(kidWM), margin.BStart(kidWM));

    kidReflowInput.ApplyRelativePositioning(&kidPt, containerSize);

    // Reflow the frame

    ReflowChild(kidFrame, aPresContext, kidDesiredSize, kidReflowInput,

                kidWM, kidPt, containerSize, 0, aStatus);

    // Complete the reflow and position and size the child frame

    FinishReflowChild(kidFrame, aPresContext, kidDesiredSize, &kidReflowInput,

                      kidWM, kidPt, containerSize, 0);

    if (!aStatus.IsFullyComplete()) {

      nsIFrame* nextFrame = kidFrame->GetNextInFlow();

      NS_ASSERTION(nextFrame || aStatus.NextInFlowNeedsReflow(),

        "If it's incomplete and has no nif yet, it must flag a nif reflow.");

      if (!nextFrame) {

        nextFrame = aPresContext->PresShell()->FrameConstructor()->

          CreateContinuingFrame(aPresContext, kidFrame, this);

        SetOverflowFrames(nsFrameList(nextFrame, nextFrame));

        // Root overflow containers will be normal children of

        // the canvas frame, but that's ok because there

        // aren't any other frames we need to isolate them from

        // during reflow.

      }

      if (aStatus.IsOverflowIncomplete()) {

        nextFrame->AddStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER);

      }

    }

    // If the child frame was just inserted, then we're responsible for making sure

    // it repaints

    if (kidDirty) {

      // But we have a new child, which will affect our background, so

      // invalidate our whole rect.

      // Note: Even though we request to be sized to our child's size, our

      // scroll frame ensures that we are always the size of the viewport.

      // Also note: GetPosition() on a CanvasFrame is always going to return

      // (0, 0). We only want to invalidate GetRect() since Get*OverflowRect()

      // could also include overflow to our top and left (out of the viewport)

      // which doesn't need to be painted.

      nsIFrame* viewport = PresContext()->GetPresShell()->GetRootFrame();

      viewport->InvalidateFrame();

    }

    // Return our desired size. Normally it's what we're told, but

    // sometimes we can be given an unconstrained height (when a window

    // is sizing-to-content), and we should compute our desired height.

    LogicalSize finalSize(wm);

    finalSize.ISize(wm) = aReflowInput.ComputedISize();

    if (aReflowInput.ComputedBSize() == NS_UNCONSTRAINEDSIZE) {

      finalSize.BSize(wm) = kidFrame->GetLogicalSize(wm).BSize(wm) +

        kidReflowInput.ComputedLogicalMargin().BStartEnd(wm);

    } else {

      finalSize.BSize(wm) = aReflowInput.ComputedBSize();

    }

    aDesiredSize.SetSize(wm, finalSize);

    aDesiredSize.SetOverflowAreasToDesiredBounds();

    aDesiredSize.mOverflowAreas.UnionWith(

      kidDesiredSize.mOverflowAreas + kidFrame->GetPosition());

  }

  if (prevCanvasFrame) {

    ReflowOverflowContainerChildren(aPresContext, aReflowInput,

                                    aDesiredSize.mOverflowAreas, 0,

                                    aStatus);

  }

  if (mPopupSetFrame) {

    MOZ_ASSERT(mFrames.ContainsFrame(mPopupSetFrame), "Only normal flow supported.");

    nsReflowStatus popupStatus;

    ReflowOutput popupDesiredSize(aReflowInput.GetWritingMode());

    WritingMode wm = mPopupSetFrame->GetWritingMode();

    LogicalSize availSize = aReflowInput.ComputedSize(wm);

    availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE;

    ReflowInput popupReflowInput(aPresContext, aReflowInput,

                                 mPopupSetFrame, availSize);

    ReflowChild(mPopupSetFrame, aPresContext, popupDesiredSize,

                popupReflowInput, 0, 0, NS_FRAME_NO_MOVE_FRAME, popupStatus);

    FinishReflowChild(mPopupSetFrame, aPresContext, popupDesiredSize,

                      &popupReflowInput, 0, 0, NS_FRAME_NO_MOVE_FRAME);

  }

  FinishReflowWithAbsoluteFrames(aPresContext, aDesiredSize, aReflowInput, aStatus);

  NS_FRAME_TRACE_REFLOW_OUT("nsCanvasFrame::Reflow", aStatus);

  NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);

}

nsresult

nsCanvasFrame::GetContentForEvent(WidgetEvent* aEvent, nsIContent** aContent)

{

  NS_ENSURE_ARG_POINTER(aContent);

  nsresult rv = nsFrame::GetContentForEvent(aEvent, aContent);

  if (NS_FAILED(rv) || !*aContent) {

    nsIFrame* kid = mFrames.FirstChild();

    if (kid) {

      rv = kid->GetContentForEvent(aEvent,

                                   aContent);

    }

  }

  return rv;

}