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

#include "WebRenderCommandBuilder.h"

#include "BasicLayers.h"

#include "mozilla/AutoRestore.h"

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

#include "mozilla/gfx/Types.h"

#include "mozilla/layers/ClipManager.h"

#include "mozilla/layers/ImageClient.h"

#include "mozilla/layers/WebRenderBridgeChild.h"

#include "mozilla/layers/WebRenderLayerManager.h"

#include "mozilla/layers/IpcResourceUpdateQueue.h"

#include "mozilla/layers/SharedSurfacesChild.h"

#include "mozilla/layers/SourceSurfaceSharedData.h"

#include "mozilla/layers/StackingContextHelper.h"

#include "mozilla/layers/UpdateImageHelper.h"

#include "mozilla/layers/WebRenderDrawEventRecorder.h"

#include "UnitTransforms.h"

#include "gfxEnv.h"

#include "nsDisplayListInvalidation.h"

#include "WebRenderCanvasRenderer.h"

#include "LayersLogging.h"

#include "LayerTreeInvalidation.h"

namespace mozilla {

namespace layers {

using namespace gfx;

static bool

PaintByLayer(nsDisplayItem* aItem,

             nsDisplayListBuilder* aDisplayListBuilder,

             const RefPtr<BasicLayerManager>& aManager,

             gfxContext* aContext,

             const gfx::Size& aScale,

             const std::function<void()>& aPaintFunc);

static int sIndent;

#include <stdarg.h>

#include <stdio.h>

static void GP(const char *fmt, ...) {

    va_list args;

    va_start(args, fmt);

#if 0

    for (int i = 0; i < sIndent; i++) { printf(" "); }

    vprintf(fmt, args);

#endif

    va_end(args);

}

//XXX: problems:

// - How do we deal with scrolling while having only a single invalidation rect?

// We can have a valid rect and an invalid rect. As we scroll the valid rect will move

// and the invalid rect will be the new area

struct BlobItemData;

static void DestroyBlobGroupDataProperty(nsTArray<BlobItemData*>* aArray);

NS_DECLARE_FRAME_PROPERTY_WITH_DTOR(BlobGroupDataProperty,

                                    nsTArray<BlobItemData*>,

                                    DestroyBlobGroupDataProperty);

static void

SetBlobImageVisibleArea(wr::IpcResourceUpdateQueue& aResources,

                        wr::ImageKey aImageKey,

                        const LayoutDeviceRect& aImageRect,

                        const LayoutDeviceRect& aPaintRect)

{

  LayoutDeviceRect visibleRect = aImageRect.Intersect(aPaintRect);

  // Send the visible rect in normalized coordinates.

  Rect visibleArea = Rect((visibleRect.x - aImageRect.x) / aImageRect.width,

                          (visibleRect.y - aImageRect.y) / aImageRect.height,

                          visibleRect.width / aImageRect.width,

                          visibleRect.height / aImageRect.height);

  aResources.SetImageVisibleArea(aImageKey, visibleArea);

}

// These are currently manually allocated and ownership is help by the mDisplayItems

// hash table in DIGroup

struct BlobItemData

{

  // a weak pointer to the frame for this item.

  // DisplayItemData has a mFrameList to deal with merged frames. Hopefully we

  // don't need to worry about that.

  nsIFrame* mFrame;

  uint32_t  mDisplayItemKey;

  nsTArray<BlobItemData*>* mArray; // a weak pointer to the array that's owned by the frame property

  IntRect mRect;

  // It would be nice to not need this. We need to be able to call ComputeInvalidationRegion.

  // ComputeInvalidationRegion will sometimes reach into parent style structs to get information

  // that can change the invalidation region

  UniquePtr<nsDisplayItemGeometry> mGeometry;

  DisplayItemClip mClip;

  bool mUsed; // initialized near construction

  // a weak pointer to the group that owns this item

  // we use this to track whether group for a particular item has changed

  struct DIGroup* mGroup;

  // XXX: only used for debugging

  bool mInvalid;

  bool mEmpty;

  // properties that are used to emulate layer tree invalidation

  Matrix mMatrix; // updated to track the current transform to device space

  Matrix4x4Flagged mTransform; // only used with nsDisplayTransform items to detect transform changes

  float mOpacity; // only used with nsDisplayOpacity items to detect change to opacity

  RefPtr<BasicLayerManager> mLayerManager;

  IntRect mImageRect;

  LayerIntPoint mGroupOffset;

  BlobItemData(DIGroup* aGroup, nsDisplayItem *aItem)

    : mUsed(false)

    , mGroup(aGroup)

    , mOpacity(0.0)

  {

    mInvalid = false;

    mEmpty = false;

    mDisplayItemKey = aItem->GetPerFrameKey();

    AddFrame(aItem->Frame());

  }

private:

  void AddFrame(nsIFrame* aFrame)

  {

    mFrame = aFrame;

    nsTArray<BlobItemData*>* array =

      aFrame->GetProperty(BlobGroupDataProperty());

    if (!array) {

      array = new nsTArray<BlobItemData*>();

      aFrame->SetProperty(BlobGroupDataProperty(), array);

    }

    array->AppendElement(this);

    mArray = array;

  }

public:

  void ClearFrame()

  {

    // Delete the weak pointer to this BlobItemData on the frame

    MOZ_RELEASE_ASSERT(mFrame);

    // the property may already be removed if WebRenderUserData got deleted

    // first so we use our own mArray pointer.

    mArray->RemoveElement(this);

    // drop the entire property if nothing's left in the array

    if (mArray->IsEmpty()) {

      // If the frame is in the process of being destroyed this will fail

      // but that's ok, because the the property will be removed then anyways

      mFrame->DeleteProperty(BlobGroupDataProperty());

    }

    mFrame = nullptr;

  }

  ~BlobItemData()

  {

    if (mFrame) {

      ClearFrame();

    }

  }

};

static BlobItemData*

GetBlobItemData(nsDisplayItem* aItem)

{

  nsIFrame* frame = aItem->Frame();

  uint32_t key = aItem->GetPerFrameKey();

  const nsTArray<BlobItemData*>* array = frame->GetProperty(BlobGroupDataProperty());

  if (array) {

    for (BlobItemData* item : *array) {

      if (item->mDisplayItemKey == key) {

        return item;

      }

    }

  }

  return nullptr;

}

// We keep around the BlobItemData so that when we invalidate it get properly included in the rect

static void

DestroyBlobGroupDataProperty(nsTArray<BlobItemData*>* aArray)

{

  for (BlobItemData* item : *aArray) {

    GP("DestroyBlobGroupDataProperty: %p-%d\n", item->mFrame, item->mDisplayItemKey);

    item->mFrame = nullptr;

  }

  delete aArray;

}

static void

TakeExternalSurfaces(WebRenderDrawEventRecorder* aRecorder,

                     std::vector<RefPtr<SourceSurface>>& aExternalSurfaces,

                     WebRenderLayerManager* aManager,

                     wr::IpcResourceUpdateQueue& aResources)

{

  aRecorder->TakeExternalSurfaces(aExternalSurfaces);

  for (auto& surface : aExternalSurfaces) {

    if (surface->GetType() != SurfaceType::DATA_SHARED) {

      MOZ_ASSERT_UNREACHABLE("External surface that is not a shared surface!");

      continue;

    }

    // While we don't use the image key with the surface, because the blob image

    // renderer doesn't have easy access to the resource set, we still want to

    // ensure one is generated. That will ensure the surface remains alive until

    // at least the last epoch which the blob image could be used in.

    wr::ImageKey key;

    auto sharedSurface = static_cast<SourceSurfaceSharedData*>(surface.get());

    SharedSurfacesChild::Share(sharedSurface, aManager, aResources, key);

  }

}

struct DIGroup;

struct Grouper

{

  explicit Grouper(ClipManager& aClipManager)

   : mAppUnitsPerDevPixel(0)

   , mDisplayListBuilder(nullptr)

   , mClipManager(aClipManager)

  {}

  int32_t mAppUnitsPerDevPixel;

  std::vector<nsDisplayItem*> mItemStack;

  nsDisplayListBuilder* mDisplayListBuilder;

  ClipManager& mClipManager;

  Matrix mTransform;

  // Paint the list of aChildren display items.

  void PaintContainerItem(DIGroup* aGroup, nsDisplayItem* aItem, const IntRect& aItemBounds,

                          nsDisplayList* aChildren, gfxContext* aContext,

                          WebRenderDrawEventRecorder* aRecorder);

  // Builds groups of display items split based on 'layer activity'

  void ConstructGroups(nsDisplayListBuilder* aDisplayListBuilder,

                       WebRenderCommandBuilder* aCommandBuilder,

                       wr::DisplayListBuilder& aBuilder,

                       wr::IpcResourceUpdateQueue& aResources,

                       DIGroup* aGroup, nsDisplayList* aList,

                       const StackingContextHelper& aSc);

  // Builds a group of display items without promoting anything to active.

  void ConstructGroupInsideInactive(WebRenderCommandBuilder* aCommandBuilder,

                                       wr::DisplayListBuilder& aBuilder,

                                       wr::IpcResourceUpdateQueue& aResources,

                                       DIGroup* aGroup, nsDisplayList* aList,

                                       const StackingContextHelper& aSc);

  // Helper method for processing a single inactive item

  void ConstructItemInsideInactive(WebRenderCommandBuilder* aCommandBuilder,

                                   wr::DisplayListBuilder& aBuilder,

                                   wr::IpcResourceUpdateQueue& aResources,

                                   DIGroup* aGroup, nsDisplayItem* aItem,

                                   const StackingContextHelper& aSc);

  ~Grouper() {

  }

};

// Returns whether this is an item for which complete invalidation was

// reliant on LayerTreeInvalidation in the pre-webrender world.

static bool

IsContainerLayerItem(nsDisplayItem* aItem)

{

  switch (aItem->GetType()) {

    case DisplayItemType::TYPE_WRAP_LIST:

    case DisplayItemType::TYPE_TRANSFORM:

    case DisplayItemType::TYPE_OPACITY:

    case DisplayItemType::TYPE_FILTER:

    case DisplayItemType::TYPE_BLEND_CONTAINER:

    case DisplayItemType::TYPE_BLEND_MODE:

    case DisplayItemType::TYPE_MASK: {

      return true;

    }

    default: {

      return false;

    }

  }

}

#include <sstream>

bool

UpdateContainerLayerPropertiesAndDetectChange(nsDisplayItem* aItem, BlobItemData* aData, nsDisplayItemGeometry& aGeometry)

{

  bool changed = false;

  switch (aItem->GetType()) {

    case DisplayItemType::TYPE_TRANSFORM: {

      auto transformItem = static_cast<nsDisplayTransform*>(aItem);

      Matrix4x4Flagged trans = transformItem->GetTransform();

      changed = aData->mTransform != trans;

      if (changed) {

        std::stringstream ss;

        //ss << trans << ' ' << aData->mTransform;

        //GP("UpdateContainerLayerPropertiesAndDetectChange Matrix %d %s\n", changed, ss.str().c_str());

      }

      aData->mTransform = trans;

      break;

    }

    case DisplayItemType::TYPE_OPACITY: {

      auto opacityItem = static_cast<nsDisplayOpacity*>(aItem);

      float opacity = opacityItem->GetOpacity();

      changed = aData->mOpacity != opacity;

      aData->mOpacity = opacity;

      GP("UpdateContainerLayerPropertiesAndDetectChange Opacity\n");

      break;

    }

    case DisplayItemType::TYPE_MASK:

    case DisplayItemType::TYPE_FILTER: {

      // These two items go through BasicLayerManager composition which clips to the BuildingRect

      aGeometry.mBounds = aGeometry.mBounds.Intersect(aItem->GetBuildingRect());

      break;

    }

    default:

      break;

  }

  return changed || !aGeometry.mBounds.IsEqualEdges(aData->mGeometry->mBounds);

}

struct DIGroup

{

  // XXX: Storing owning pointers to the BlobItemData in a hash table is not

  // a good choice. There are two better options:

  //

  // 1. We should just be using a linked list for this stuff.

  //    That we can iterate over only the used items.

  //    We remove from the unused list and add to the used list

  //    when we see an item.

  //

  //    we allocate using a free list.

  //

  // 2. We can use a Vec and use SwapRemove().

  //    We'll just need to be careful when iterating.

  //    The advantage of a Vec is that everything stays compact

  //    and we don't need to heap allocate the BlobItemData's

  nsTHashtable<nsPtrHashKey<BlobItemData>> mDisplayItems;

  nsPoint mAnimatedGeometryRootOrigin;

  nsPoint mLastAnimatedGeometryRootOrigin;

  IntRect mInvalidRect;

  nsRect mGroupBounds;

  LayoutDeviceRect mPaintRect;

  int32_t mAppUnitsPerDevPixel;

  gfx::Size mScale;

  FrameMetrics::ViewID mScrollId;

  LayerPoint mResidualOffset;

  LayerIntRect mLayerBounds;

  Maybe<wr::ImageKey> mKey;

  std::vector<RefPtr<SourceSurface>> mExternalSurfaces;

  std::vector<RefPtr<ScaledFont>> mFonts;

  DIGroup()

    : mAppUnitsPerDevPixel(0)

    , mScrollId(FrameMetrics::NULL_SCROLL_ID)

  {

  }

  void InvalidateRect(const IntRect& aRect)

  {

    // Empty rects get dropped

    mInvalidRect = mInvalidRect.Union(aRect);

  }

  IntRect ItemBounds(nsDisplayItem* aItem)

  {

    BlobItemData* data = GetBlobItemData(aItem);

    return data->mRect;

  }

  void ClearItems()

  {

    GP("items: %d\n", mDisplayItems.Count());

    for (auto iter = mDisplayItems.Iter(); !iter.Done(); iter.Next()) {

      BlobItemData* data = iter.Get()->GetKey();

      GP("Deleting %p-%d\n", data->mFrame, data->mDisplayItemKey);

      iter.Remove();

      delete data;

    }

  }

  void ClearImageKey(WebRenderLayerManager* aManager, bool aForce = false)

  {

    if (mKey) {

      MOZ_RELEASE_ASSERT(aForce || mInvalidRect.IsEmpty());

      aManager->AddImageKeyForDiscard(mKey.value());

      mKey = Nothing();

    }

    mFonts.clear();

  }

  static IntRect

  ToDeviceSpace(nsRect aBounds, Matrix& aMatrix, int32_t aAppUnitsPerDevPixel, LayerIntPoint aOffset)

  {

    // RoundedOut can convert empty rectangles to non-empty ones

    // so special case them here

    if (aBounds.IsEmpty()) {

      return IntRect();

    }

    return RoundedOut(aMatrix.TransformBounds(ToRect(nsLayoutUtils::RectToGfxRect(aBounds, aAppUnitsPerDevPixel)))) - aOffset.ToUnknownPoint();

  }

  void ComputeGeometryChange(nsDisplayItem* aItem, BlobItemData* aData, Matrix& aMatrix, nsDisplayListBuilder* aBuilder)

  {

    // If the frame is marked as invalidated, and didn't specify a rect to invalidate then we want to

    // invalidate both the old and new bounds, otherwise we only want to invalidate the changed areas.

    // If we do get an invalid rect, then we want to add this on top of the change areas.

    nsRect invalid;

    nsRegion combined;

    const DisplayItemClip& clip = aItem->GetClip();

    nsPoint shift = mAnimatedGeometryRootOrigin - mLastAnimatedGeometryRootOrigin;

    if (shift.x != 0 || shift.y != 0)

      GP("shift %d %d\n", shift.x, shift.y);

    int32_t appUnitsPerDevPixel = aItem->Frame()->PresContext()->AppUnitsPerDevPixel();

    MOZ_RELEASE_ASSERT(mAppUnitsPerDevPixel == appUnitsPerDevPixel);

    LayoutDeviceRect bounds = LayoutDeviceRect::FromAppUnits(mGroupBounds, appUnitsPerDevPixel);

    LayoutDeviceIntPoint offset = RoundedToInt(bounds.TopLeft());

    GP("\n");

    GP("CGC offset %d %d\n", offset.x, offset.y);

    LayerIntSize size = mLayerBounds.Size();

    IntRect imageRect(0, 0, size.width, size.height);

    GP("imageSize: %d %d\n", size.width, size.height);

    /*if (aItem->IsReused() && aData->mGeometry) {

      return;

    }*/

    GP("pre mInvalidRect: %s %p-%d - inv: %d %d %d %d\n", aItem->Name(), aItem->Frame(), aItem->GetPerFrameKey(),

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

    if (!aData->mGeometry) {

      // This item is being added for the first time, invalidate its entire area.

      UniquePtr<nsDisplayItemGeometry> geometry(aItem->AllocateGeometry(aBuilder));

      combined = clip.ApplyNonRoundedIntersection(geometry->ComputeInvalidationRegion());

      aData->mGeometry = std::move(geometry);

      nsRect bounds = combined.GetBounds();

      IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mLayerBounds.TopLeft());

      aData->mRect = transformedRect.Intersect(imageRect);

      GP("CGC %s %d %d %d %d\n", aItem->Name(), bounds.x, bounds.y, bounds.width, bounds.height);

      GP("%d %d,  %f %f\n", mLayerBounds.TopLeft().x, mLayerBounds.TopLeft().y, aMatrix._11, aMatrix._22);

      GP("mRect %d %d %d %d\n", aData->mRect.x, aData->mRect.y, aData->mRect.width, aData->mRect.height);

      InvalidateRect(aData->mRect);

      aData->mInvalid = true;

    } else if (aData->mInvalid || /* XXX: handle image load invalidation */ (aItem->IsInvalid(invalid) && invalid.IsEmpty())) {

      MOZ_RELEASE_ASSERT(imageRect.IsEqualEdges(aData->mImageRect));

      MOZ_RELEASE_ASSERT(mLayerBounds.TopLeft() == aData->mGroupOffset);

      UniquePtr<nsDisplayItemGeometry> geometry(aItem->AllocateGeometry(aBuilder));

      /* Instead of doing this dance, let's just invalidate the old rect and the

       * new rect.

      combined = aData->mClip.ApplyNonRoundedIntersection(aData->mGeometry->ComputeInvalidationRegion());

      combined.MoveBy(shift);

      combined.Or(combined, clip.ApplyNonRoundedIntersection(geometry->ComputeInvalidationRegion()));

      aData->mGeometry = std::move(geometry);

      */

      combined = clip.ApplyNonRoundedIntersection(geometry->ComputeInvalidationRegion());

      aData->mGeometry = std::move(geometry);

      GP("matrix: %f %f\n", aMatrix._31, aMatrix._32); 

      GP("frame invalid invalidate: %s\n", aItem->Name());

      GP("old rect: %d %d %d %d\n",

             aData->mRect.x,

             aData->mRect.y,

             aData->mRect.width,

             aData->mRect.height);

      InvalidateRect(aData->mRect.Intersect(imageRect));

      // We want to snap to outside pixels. When should we multiply by the matrix?

      // XXX: TransformBounds is expensive. We should avoid doing it if we have no transform

      IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mLayerBounds.TopLeft());

      aData->mRect = transformedRect.Intersect(imageRect);

      InvalidateRect(aData->mRect);

      GP("new rect: %d %d %d %d\n",

             aData->mRect.x,

             aData->mRect.y,

             aData->mRect.width,

             aData->mRect.height);

      aData->mInvalid = true;

    } else {

      MOZ_RELEASE_ASSERT(imageRect.IsEqualEdges(aData->mImageRect));

      MOZ_RELEASE_ASSERT(mLayerBounds.TopLeft() == aData->mGroupOffset);

      GP("else invalidate: %s\n", aItem->Name());

      aData->mGeometry->MoveBy(shift);

      // this includes situations like reflow changing the position

      aItem->ComputeInvalidationRegion(aBuilder, aData->mGeometry.get(), &combined);

      if (!combined.IsEmpty()) {

        // There might be no point in doing this elaborate tracking here to get

        // smaller areas

        InvalidateRect(aData->mRect.Intersect(imageRect)); // invalidate the old area -- in theory combined should take care of this

        UniquePtr<nsDisplayItemGeometry> geometry(aItem->AllocateGeometry(aBuilder));

        aData->mClip.AddOffsetAndComputeDifference(shift, aData->mGeometry->ComputeInvalidationRegion(), clip,

                                                   geometry ? geometry->ComputeInvalidationRegion() :

                                                   aData->mGeometry->ComputeInvalidationRegion(),

                                                   &combined);

        IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mLayerBounds.TopLeft());

        IntRect invalidRect = transformedRect.Intersect(imageRect);

        GP("combined not empty: mRect %d %d %d %d\n", invalidRect.x, invalidRect.y, invalidRect.width, invalidRect.height);

        // invalidate the invalidated area.

        InvalidateRect(invalidRect);

        aData->mGeometry = std::move(geometry);

        combined = clip.ApplyNonRoundedIntersection(aData->mGeometry->ComputeInvalidationRegion());

        transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mLayerBounds.TopLeft());

        aData->mRect = transformedRect.Intersect(imageRect);

        aData->mInvalid = true;

      } else {

        if (aData->mClip != clip) {

          UniquePtr<nsDisplayItemGeometry> geometry(aItem->AllocateGeometry(aBuilder));

          if (!IsContainerLayerItem(aItem)) {

            // the bounds of layer items can change on us without ComputeInvalidationRegion

            // returning any change. Other items shouldn't have any hidden

            // geometry change.

            MOZ_RELEASE_ASSERT(geometry->mBounds.IsEqualEdges(aData->mGeometry->mBounds));

          } else {

            aData->mGeometry = std::move(geometry);

          }

          combined = clip.ApplyNonRoundedIntersection(aData->mGeometry->ComputeInvalidationRegion());

          IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mLayerBounds.TopLeft());

          InvalidateRect(aData->mRect.Intersect(imageRect));

          aData->mRect = transformedRect.Intersect(imageRect);

          InvalidateRect(aData->mRect);

          GP("ClipChange: %s %d %d %d %d\n", aItem->Name(),

                 aData->mRect.x, aData->mRect.y, aData->mRect.XMost(), aData->mRect.YMost());

        } else if (!aMatrix.ExactlyEquals(aData->mMatrix)) {

          // We haven't detected any changes so far. Unfortunately we don't

          // currently have a good way of checking if the transform has changed

          // so we just store it and see if it see if it has changed.

          // If we want this to go faster, we can probably put a flag on the frame

          // using the style sytem UpdateTransformLayer hint and check for that.

          UniquePtr<nsDisplayItemGeometry> geometry(aItem->AllocateGeometry(aBuilder));

          if (!IsContainerLayerItem(aItem)) {

            // the bounds of layer items can change on us

            // other items shouldn't

            MOZ_RELEASE_ASSERT(geometry->mBounds.IsEqualEdges(aData->mGeometry->mBounds));

          } else {

            aData->mGeometry = std::move(geometry);

          }

          combined = clip.ApplyNonRoundedIntersection(aData->mGeometry->ComputeInvalidationRegion());

          IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mLayerBounds.TopLeft());

          InvalidateRect(aData->mRect.Intersect(imageRect));

          aData->mRect = transformedRect.Intersect(imageRect);

          InvalidateRect(aData->mRect);

          GP("TransformChange: %s %d %d %d %d\n", aItem->Name(),

                 aData->mRect.x, aData->mRect.y, aData->mRect.XMost(), aData->mRect.YMost());

        } else if (IsContainerLayerItem(aItem)) {

          UniquePtr<nsDisplayItemGeometry> geometry(aItem->AllocateGeometry(aBuilder));

          // we need to catch bounds changes of containers so that we continue to have the correct bounds rects in the recording

          if (UpdateContainerLayerPropertiesAndDetectChange(aItem, aData, *geometry)) {

            combined = clip.ApplyNonRoundedIntersection(geometry->ComputeInvalidationRegion());

            aData->mGeometry = std::move(geometry);

            IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mLayerBounds.TopLeft());

            InvalidateRect(aData->mRect.Intersect(imageRect));

            aData->mRect = transformedRect.Intersect(imageRect);

            InvalidateRect(aData->mRect);

            GP("UpdateContainerLayerPropertiesAndDetectChange change\n");

          } else {

            // XXX: this code can eventually be deleted/made debug only

            combined = clip.ApplyNonRoundedIntersection(geometry->ComputeInvalidationRegion());

            IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mLayerBounds.TopLeft());

            auto rect = transformedRect.Intersect(imageRect);

            GP("Layer NoChange: %s %d %d %d %d\n", aItem->Name(),

                   aData->mRect.x, aData->mRect.y, aData->mRect.XMost(), aData->mRect.YMost());

            MOZ_RELEASE_ASSERT(rect.IsEqualEdges(aData->mRect));

          }

        } else {

          // XXX: this code can eventually be deleted/made debug only

          UniquePtr<nsDisplayItemGeometry> geometry(aItem->AllocateGeometry(aBuilder));

          combined = clip.ApplyNonRoundedIntersection(geometry->ComputeInvalidationRegion());

          IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mLayerBounds.TopLeft());

          auto rect = transformedRect.Intersect(imageRect);

          GP("NoChange: %s %d %d %d %d\n", aItem->Name(),

                 aData->mRect.x, aData->mRect.y, aData->mRect.XMost(), aData->mRect.YMost());

          MOZ_RELEASE_ASSERT(rect.IsEqualEdges(aData->mRect));

        }

      }

    }

    aData->mClip = clip;

    aData->mMatrix = aMatrix;

    aData->mGroupOffset = mLayerBounds.TopLeft();

    aData->mImageRect = imageRect;

    GP("post mInvalidRect: %d %d %d %d\n", mInvalidRect.x, mInvalidRect.y, mInvalidRect.width, mInvalidRect.height);

  }

  void EndGroup(WebRenderLayerManager* aWrManager,

                nsDisplayListBuilder* aDisplayListBuilder,

                wr::DisplayListBuilder& aBuilder,

                wr::IpcResourceUpdateQueue& aResources,

                Grouper* aGrouper,

                nsDisplayItem* aStartItem,

                nsDisplayItem* aEndItem)

  {

    mLastAnimatedGeometryRootOrigin = mAnimatedGeometryRootOrigin;

    GP("\n\n");

    GP("Begin EndGroup\n");

    // Invalidate any unused items

    GP("mDisplayItems\n");

    for (auto iter = mDisplayItems.Iter(); !iter.Done(); iter.Next()) {

      BlobItemData* data = iter.Get()->GetKey();

      GP("  : %p-%d\n", data->mFrame, data->mDisplayItemKey);

      if (!data->mUsed) {

        GP("Invalidate unused: %p-%d\n", data->mFrame, data->mDisplayItemKey);

        InvalidateRect(data->mRect);

        iter.Remove();

        delete data;

      } else {

        data->mUsed = false;

      }

    }

    // Round the bounds out to leave space for unsnapped content

    LayoutDeviceToLayerScale2D scale(mScale.width, mScale.height);

    LayerIntRect layerBounds = mLayerBounds;

    IntSize dtSize = layerBounds.Size().ToUnknownSize();

    LayoutDeviceRect bounds = (LayerRect(layerBounds) - mResidualOffset) / scale;

    if (mInvalidRect.IsEmpty()) {

      GP("Not repainting group because it's empty\n");

      GP("End EndGroup\n");

      if (mKey) {

        SetBlobImageVisibleArea(aResources, mKey.value(), bounds, mPaintRect);

        PushImage(aBuilder, bounds);

      }

      return;

    }

    gfx::SurfaceFormat format = gfx::SurfaceFormat::B8G8R8A8;

    std::vector<RefPtr<ScaledFont>> fonts;

    RefPtr<WebRenderDrawEventRecorder> recorder =

      MakeAndAddRef<WebRenderDrawEventRecorder>(

        [&](MemStream& aStream, std::vector<RefPtr<ScaledFont>>& aScaledFonts) {

          size_t count = aScaledFonts.size();

          aStream.write((const char*)&count, sizeof(count));

          for (auto& scaled : aScaledFonts) {

            BlobFont font = {

              aWrManager->WrBridge()->GetFontKeyForScaledFont(scaled, &aResources),

              scaled

            };

            aStream.write((const char*)&font, sizeof(font));

          }

          fonts = std::move(aScaledFonts);

        });

    RefPtr<gfx::DrawTarget> dummyDt =

      gfx::Factory::CreateDrawTarget(gfx::BackendType::SKIA, gfx::IntSize(1, 1), format);

    RefPtr<gfx::DrawTarget> dt = gfx::Factory::CreateRecordingDrawTarget(recorder, dummyDt, dtSize);

    // Setup the gfxContext

    RefPtr<gfxContext> context = gfxContext::CreateOrNull(dt);

    GP("ctx-offset %f %f\n", bounds.x, bounds.y);

    context->SetMatrix(Matrix::Scaling(mScale.width, mScale.height).PreTranslate(-bounds.x, -bounds.y));

    GP("mInvalidRect: %d %d %d %d\n", mInvalidRect.x, mInvalidRect.y, mInvalidRect.width, mInvalidRect.height);

    bool empty = aStartItem == aEndItem;

    if (empty) {

      ClearImageKey(aWrManager, true);

      return;

    }

    PaintItemRange(aGrouper, aStartItem, aEndItem, context, recorder);

    // XXX: set this correctly perhaps using aItem->GetOpaqueRegion(aDisplayListBuilder, &snapped).Contains(paintBounds);?

    bool isOpaque = false;

    TakeExternalSurfaces(recorder, mExternalSurfaces, aWrManager, aResources);

    bool hasItems = recorder->Finish();

    GP("%d Finish\n", hasItems);

    Range<uint8_t> bytes((uint8_t*)recorder->mOutputStream.mData, recorder->mOutputStream.mLength);

    if (!mKey) {

      if (!hasItems) // we don't want to send a new image that doesn't have any items in it

        return;

      wr::ImageKey key = aWrManager->WrBridge()->GetNextImageKey();

      GP("No previous key making new one %d\n", key.mHandle);

      wr::ImageDescriptor descriptor(dtSize, 0, dt->GetFormat(), isOpaque);

      MOZ_RELEASE_ASSERT(bytes.length() > sizeof(size_t));

      if (!aResources.AddBlobImage(key, descriptor, bytes)) {

        return;

      }

      mKey = Some(key);

    } else {

      wr::ImageDescriptor descriptor(dtSize, 0, dt->GetFormat(), isOpaque);

      auto bottomRight = mInvalidRect.BottomRight();

      GP("check invalid %d %d - %d %d\n", bottomRight.x, bottomRight.y, dtSize.width, dtSize.height);

      MOZ_RELEASE_ASSERT(bottomRight.x <= dtSize.width && bottomRight.y <= dtSize.height);

      GP("Update Blob %d %d %d %d\n", mInvalidRect.x, mInvalidRect.y, mInvalidRect.width, mInvalidRect.height);

      if (!aResources.UpdateBlobImage(mKey.value(), descriptor, bytes, ViewAs<ImagePixel>(mInvalidRect))) {

        return;

      }

    }

    mFonts = std::move(fonts);

    mInvalidRect.SetEmpty();

    SetBlobImageVisibleArea(aResources, mKey.value(), mPaintRect, bounds);

    PushImage(aBuilder, bounds);

    GP("End EndGroup\n\n");

  }

  void PushImage(wr::DisplayListBuilder& aBuilder, const LayoutDeviceRect& bounds)

  {

    wr::LayoutRect dest = wr::ToLayoutRect(bounds);

    GP("PushImage: %f %f %f %f\n", dest.origin.x, dest.origin.y, dest.size.width, dest.size.height);

    gfx::SamplingFilter sampleFilter = gfx::SamplingFilter::LINEAR; //nsLayoutUtils::GetSamplingFilterForFrame(aItem->Frame());

    bool backfaceHidden = false;

    // Emit a dispatch-to-content hit test region covering this area

    auto hitInfo = CompositorHitTestInfo::eVisibleToHitTest |

                   CompositorHitTestInfo::eDispatchToContent;

    // XXX - clipping the item against the paint rect breaks some content.

    // cf. Bug 1455422.

    //wr::LayoutRect clip = wr::ToLayoutRect(bounds.Intersect(mPaintRect));

    aBuilder.SetHitTestInfo(mScrollId, hitInfo);

    aBuilder.PushImage(dest, dest, !backfaceHidden,

                       wr::ToImageRendering(sampleFilter),

                       mKey.value());

    aBuilder.ClearHitTestInfo();

  }

  void PaintItemRange(Grouper* aGrouper,

                      nsDisplayItem* aStartItem,

                      nsDisplayItem* aEndItem,

                      gfxContext* aContext,

                      WebRenderDrawEventRecorder* aRecorder) {

    LayerIntSize size = mLayerBounds.Size();

    for (nsDisplayItem* item = aStartItem; item != aEndItem; item = item->GetAbove()) {

      IntRect bounds = ItemBounds(item);

      auto bottomRight = bounds.BottomRight();

      GP("Trying %s %p-%d %d %d %d %d\n", item->Name(), item->Frame(), item->GetPerFrameKey(), bounds.x, bounds.y, bounds.XMost(), bounds.YMost());

      GP("paint check invalid %d %d - %d %d\n", bottomRight.x, bottomRight.y, size.width, size.height);

      // skip empty items

      if (bounds.IsEmpty()) {

          continue;

      }

      bool dirty = true;

      if (!mInvalidRect.Contains(bounds)) {

        GP("Passing\n");

        dirty = false;

      }

      if (mInvalidRect.Contains(bounds)) {

        GP("Wholely contained\n");

        BlobItemData* data = GetBlobItemData(item);

        data->mInvalid = false;

      } else {

        BlobItemData* data = GetBlobItemData(item);

        // if the item is invalid it needs to be fully contained

        MOZ_RELEASE_ASSERT(!data->mInvalid);

      }

      nsDisplayList* children = item->GetChildren();

      if (children) {

        GP("doing children in EndGroup\n");

        aGrouper->PaintContainerItem(this, item, bounds, children, aContext, aRecorder);

      } else {

        // Hit test items don't have anything to paint so skip them. Ideally we

        // would drop these items earlier...

        if (dirty && item->GetType() != DisplayItemType::TYPE_COMPOSITOR_HITTEST_INFO) {

          // What should the clip settting strategy be? We can set the full clip everytime.

          // this is probably easiest for now. An alternative would be to put the push and the pop

          // into separate items and let invalidation handle it that way.

          DisplayItemClip currentClip = item->GetClip();

          if (currentClip.HasClip()) {

            aContext->Save();

            currentClip.ApplyTo(aContext, aGrouper->mAppUnitsPerDevPixel);

          }

          aContext->NewPath();

          GP("painting %s %p-%d\n", item->Name(), item->Frame(), item->GetPerFrameKey());

          if (aGrouper->mDisplayListBuilder->IsPaintingToWindow()) {

            item->Frame()->AddStateBits(NS_FRAME_PAINTED_THEBES);

          }

          item->Paint(aGrouper->mDisplayListBuilder, aContext);

          if (currentClip.HasClip()) {

            aContext->Restore();

          }

        }

        aContext->GetDrawTarget()->FlushItem(bounds);

      }

    }

  }

  ~DIGroup()

  {

    GP("Group destruct\n");

    for (auto iter = mDisplayItems.Iter(); !iter.Done(); iter.Next()) {

      BlobItemData* data = iter.Get()->GetKey();

      GP("Deleting %p-%d\n", data->mFrame, data->mDisplayItemKey);

      iter.Remove();

      delete data;

    }

  }

};

// If we have an item we need to make sure it matches the current group

// otherwise it means the item switched groups and we need to invalidate

// it and recreate the data.

static BlobItemData*

GetBlobItemDataForGroup(nsDisplayItem* aItem, DIGroup* aGroup)

{

  BlobItemData* data = GetBlobItemData(aItem);

  if (data) {

    MOZ_RELEASE_ASSERT(data->mGroup->mDisplayItems.Contains(data));

    if (data->mGroup != aGroup) {

      GP("group don't match %p %p\n", data->mGroup, aGroup);

      data->ClearFrame();

      // the item is for another group

      // it should be cleared out as being unused at the end of this paint

      data = nullptr;

    }

  }

  if (!data) {

    GP("Allocating blob data\n");

    data = new BlobItemData(aGroup, aItem);

    aGroup->mDisplayItems.PutEntry(data);

  }

  data->mUsed = true;

  return data;

}

void

Grouper::PaintContainerItem(DIGroup* aGroup, nsDisplayItem* aItem, const IntRect& aItemBounds,

                            nsDisplayList* aChildren, gfxContext* aContext,

                            WebRenderDrawEventRecorder* aRecorder)

{

  mItemStack.push_back(aItem);

  switch (aItem->GetType()) {

    case DisplayItemType::TYPE_TRANSFORM: {

      DisplayItemClip currentClip = aItem->GetClip();

      gfx::Matrix matrix;

      if (currentClip.HasClip()) {

        aContext->Save();

        currentClip.ApplyTo(aContext, this->mAppUnitsPerDevPixel);

        aContext->GetDrawTarget()->FlushItem(aItemBounds);

      } else {

        matrix = aContext->CurrentMatrix();

      }

      auto transformItem = static_cast<nsDisplayTransform*>(aItem);

      Matrix4x4Flagged trans = transformItem->GetTransform();

      Matrix trans2d;

      if (!trans.Is2D(&trans2d)) {

        // We don't currently support doing invalidation inside 3d transforms.

        // For now just paint it as a single item.

        BlobItemData* data = GetBlobItemDataForGroup(aItem, aGroup);

        if (data->mLayerManager->GetRoot()) {

          data->mLayerManager->BeginTransaction();

          data->mLayerManager->EndTransaction(FrameLayerBuilder::DrawPaintedLayer, mDisplayListBuilder);

          aContext->GetDrawTarget()->FlushItem(aItemBounds);

        }

      } else {

        aContext->Multiply(ThebesMatrix(trans2d));

        aGroup->PaintItemRange(this, aChildren->GetBottom(), nullptr, aContext, aRecorder);

        if (currentClip.HasClip()) {

          aContext->Restore();

          aContext->GetDrawTarget()->FlushItem(aItemBounds);

        } else {

          aContext->SetMatrix(matrix);

        }

      }

      break;

    }

    case DisplayItemType::TYPE_OPACITY: {

      auto opacityItem = static_cast<nsDisplayOpacity*>(aItem);

      float opacity = opacityItem->GetOpacity();

      if (opacity == 0.0f) {

        return;

      }

      aContext->GetDrawTarget()->PushLayer(false, opacityItem->GetOpacity(), nullptr, mozilla::gfx::Matrix(), aItemBounds);

      GP("beginGroup %s %p-%d\n", aItem->Name(), aItem->Frame(), aItem->GetPerFrameKey());

      aContext->GetDrawTarget()->FlushItem(aItemBounds);

      aGroup->PaintItemRange(this, aChildren->GetBottom(), nullptr, aContext, aRecorder);

      aContext->GetDrawTarget()->PopLayer();

      GP("endGroup %s %p-%d\n", aItem->Name(), aItem->Frame(), aItem->GetPerFrameKey());

      aContext->GetDrawTarget()->FlushItem(aItemBounds);

      break;

    }

    case DisplayItemType::TYPE_BLEND_MODE: {

      auto blendItem = static_cast<nsDisplayBlendMode*>(aItem);

      auto blendMode = blendItem->BlendMode();

      aContext->GetDrawTarget()->PushLayerWithBlend(false, 1.0, nullptr, mozilla::gfx::Matrix(), aItemBounds, false, blendMode);

      GP("beginGroup %s %p-%d\n", aItem->Name(), aItem->Frame(), aItem->GetPerFrameKey());

      aContext->GetDrawTarget()->FlushItem(aItemBounds);

      aGroup->PaintItemRange(this, aChildren->GetBottom(), nullptr, aContext, aRecorder);

      aContext->GetDrawTarget()->PopLayer();

      GP("endGroup %s %p-%d\n", aItem->Name(), aItem->Frame(), aItem->GetPerFrameKey());

      aContext->GetDrawTarget()->FlushItem(aItemBounds);

      break;

    }

    case DisplayItemType::TYPE_MASK: {

      GP("Paint Mask\n");

      auto maskItem = static_cast<nsDisplayMask*>(aItem);

      maskItem->SetPaintRect(maskItem->GetClippedBounds(mDisplayListBuilder));

      if (maskItem->IsValidMask()) {

        maskItem->PaintWithContentsPaintCallback(mDisplayListBuilder, aContext, [&] {

          GP("beginGroup %s %p-%d\n", aItem->Name(), aItem->Frame(), aItem->GetPerFrameKey());

          aContext->GetDrawTarget()->FlushItem(aItemBounds);