/* -*- 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 "LayerTreeInvalidation.h"

#include <stdint.h>                     // for uint32_t
#include "ImageContainer.h"             // for ImageContainer
#include "ImageLayers.h"                // for ImageLayer, etc
#include "Layers.h"                     // for Layer, ContainerLayer, etc
#include "Units.h"                      // for ParentLayerIntRect
#include "gfxRect.h"                    // for gfxRect
#include "gfxUtils.h"                   // for gfxUtils
#include "mozilla/ArrayUtils.h"         // for ArrayEqual
#include "mozilla/gfx/BaseSize.h"       // for BaseSize
#include "mozilla/gfx/Point.h"          // for IntSize
#include "mozilla/mozalloc.h"           // for operator new, etc
#include "nsDataHashtable.h"            // for nsDataHashtable
#include "nsDebug.h"                    // for NS_ASSERTION
#include "nsHashKeys.h"                 // for nsPtrHashKey
#include "nsISupportsImpl.h"            // for Layer::AddRef, etc
#include "nsRect.h"                     // for IntRect
#include "nsTArray.h"                   // for AutoTArray, nsTArray_Impl
#include "mozilla/Poison.h"
#include "mozilla/layers/ImageHost.h"
#include "mozilla/layers/LayerManagerComposite.h"
#include "TreeTraversal.h"              // for ForEachNode
#include "LayersLogging.h"

// LayerTreeInvalidation debugging
#define LTI_DEBUG 0

#if LTI_DEBUG
#  define LTI_DEEPER(aPrefix) nsPrintfCString("%s  ", aPrefix).get()
#  define LTI_DUMP(rgn, label) if (!(rgn).IsEmpty()) printf_stderr("%s%p: " label " portion is %s\n", aPrefix, mLayer.get(), Stringify(rgn).c_str());
#  define LTI_LOG(...) printf_stderr(__VA_ARGS__)
#else
#  define LTI_DEEPER(aPrefix) nullptr
#  define LTI_DUMP(rgn, label)
#  define LTI_LOG(...)
#endif

using namespace mozilla::gfx;

namespace mozilla {
namespace layers {

struct LayerPropertiesBase;
UniquePtr<LayerPropertiesBase> CloneLayerTreePropertiesInternal(Layer* aRoot, bool aIsMask = false);

/**
 * Get accumulated transform of from the context creating layer to the
 * given layer.
 */
static Matrix4x4
GetTransformIn3DContext(Layer* aLayer) {
  Matrix4x4 transform = aLayer->GetLocalTransform();
  for (Layer* layer = aLayer->GetParent();
       layer && layer->Extend3DContext();
       layer = layer->GetParent()) {
    transform = transform * layer->GetLocalTransform();
  }
  return transform;
}

/**
 * Get a transform for the given layer depending on extending 3D
 * context.
 *
 * @return local transform for layers not participating 3D rendering
 * context, or the accmulated transform in the context for else.
 */
static Matrix4x4Flagged
GetTransformForInvalidation(Layer* aLayer) {
  return (!aLayer->Is3DContextLeaf() && !aLayer->Extend3DContext() ?
          aLayer->GetLocalTransform() : GetTransformIn3DContext(aLayer));
}

static IntRect
TransformRect(const IntRect& aRect, const Matrix4x4Flagged& aTransform)
{
  if (aRect.IsEmpty()) {
    return IntRect();
  }

  Rect rect(aRect.X(), aRect.Y(), aRect.Width(), aRect.Height());
  rect = aTransform.TransformAndClipBounds(rect, Rect::MaxIntRect());
  rect.RoundOut();

  IntRect intRect;
  if (!rect.ToIntRect(&intRect)) {
    intRect = IntRect::MaxIntRect();
  }

  return intRect;
}

static void
AddTransformedRegion(nsIntRegion& aDest, const nsIntRegion& aSource, const Matrix4x4Flagged& aTransform)
{
  for (auto iter = aSource.RectIter(); !iter.Done(); iter.Next()) {
    aDest.Or(aDest, TransformRect(iter.Get(), aTransform));
  }
  aDest.SimplifyOutward(20);
}

static void
AddRegion(nsIntRegion& aDest, const nsIntRegion& aSource)
{
  aDest.Or(aDest, aSource);
  aDest.SimplifyOutward(20);
}

/**
 * Walks over this layer, and all descendant layers.
 * If any of these are a ContainerLayer that reports invalidations to a PresShell,
 * then report that the entire bounds have changed.
 */
static void
NotifySubdocumentInvalidation(Layer* aLayer, NotifySubDocInvalidationFunc aCallback)
{
  ForEachNode<ForwardIterator>(
      aLayer,
      [aCallback] (Layer* layer)
      {
        layer->ClearInvalidRegion();
        if (layer->GetMaskLayer()) {
          NotifySubdocumentInvalidation(layer->GetMaskLayer(), aCallback);
        }
        for (size_t i = 0; i < layer->GetAncestorMaskLayerCount(); i++) {
          Layer* maskLayer = layer->GetAncestorMaskLayerAt(i);
          NotifySubdocumentInvalidation(maskLayer, aCallback);
        }
      },
      [aCallback] (Layer* layer)
      {
        ContainerLayer* container = layer->AsContainerLayer();
        if (container) {
          nsIntRegion region = container->GetLocalVisibleRegion().ToUnknownRegion();
          aCallback(container, &region);
        }
      });
}

struct LayerPropertiesBase : public LayerProperties
{
  explicit LayerPropertiesBase(Layer* aLayer)
    : mLayer(aLayer)
    , mMaskLayer(nullptr)
    , mVisibleRegion(mLayer->GetLocalVisibleRegion().ToUnknownRegion())
    , mPostXScale(aLayer->GetPostXScale())
    , mPostYScale(aLayer->GetPostYScale())
    , mOpacity(aLayer->GetLocalOpacity())
    , mUseClipRect(!!aLayer->GetLocalClipRect())
  {
    MOZ_COUNT_CTOR(LayerPropertiesBase);
    if (aLayer->GetMaskLayer()) {
      mMaskLayer = CloneLayerTreePropertiesInternal(aLayer->GetMaskLayer(), true);
    }
    for (size_t i = 0; i < aLayer->GetAncestorMaskLayerCount(); i++) {
      Layer* maskLayer = aLayer->GetAncestorMaskLayerAt(i);
      mAncestorMaskLayers.AppendElement(CloneLayerTreePropertiesInternal(maskLayer, true));
    }
    if (mUseClipRect) {
      mClipRect = *aLayer->GetLocalClipRect();
    }
    mTransform = GetTransformForInvalidation(aLayer);
  }
  LayerPropertiesBase()
    : mLayer(nullptr)
    , mMaskLayer(nullptr)
    , mPostXScale(0.0)
    , mPostYScale(0.0)
    , mOpacity(0.0)
    , mUseClipRect(false)
  {
    MOZ_COUNT_CTOR(LayerPropertiesBase);
  }
  ~LayerPropertiesBase() override
  {
    MOZ_COUNT_DTOR(LayerPropertiesBase);
  }

protected:
  LayerPropertiesBase(const LayerPropertiesBase& a) = delete;
  LayerPropertiesBase& operator=(const LayerPropertiesBase& a) = delete;

public:
  bool ComputeDifferences(Layer* aRoot,
                          nsIntRegion& aOutRegion,
                          NotifySubDocInvalidationFunc aCallback) override;

  void MoveBy(const IntPoint& aOffset) override;

  bool ComputeChange(const char* aPrefix,
                     nsIntRegion& aOutRegion,
                     NotifySubDocInvalidationFunc aCallback)
  {
    // Bug 1251615: This canary is sometimes hit. We're still not sure why.
    mCanary.Check();
    bool transformChanged = !mTransform.FuzzyEqual(GetTransformForInvalidation(mLayer)) ||
                             mLayer->GetPostXScale() != mPostXScale ||
                             mLayer->GetPostYScale() != mPostYScale;
    const Maybe<ParentLayerIntRect>& otherClip = mLayer->GetLocalClipRect();
    nsIntRegion result;

    bool ancestorMaskChanged = mAncestorMaskLayers.Length() != mLayer->GetAncestorMaskLayerCount();
    if (!ancestorMaskChanged) {
      for (size_t i = 0; i < mAncestorMaskLayers.Length(); i++) {
        if (mLayer->GetAncestorMaskLayerAt(i) != mAncestorMaskLayers[i]->mLayer) {
          ancestorMaskChanged = true;
          break;
        }
      }
    }

    // Note that we don't bailout early in general since this function
    // clears some persistent state at the end. Instead we set an overflow
    // flag and check it right before returning.
    bool areaOverflowed = false;

    Layer* otherMask = mLayer->GetMaskLayer();
    if ((mMaskLayer ? mMaskLayer->mLayer : nullptr) != otherMask ||
        ancestorMaskChanged ||
        (mUseClipRect != !!otherClip) ||
        mLayer->GetLocalOpacity() != mOpacity ||
        transformChanged)
    {
      Maybe<IntRect> oldBounds = OldTransformedBounds();
      Maybe<IntRect> newBounds = NewTransformedBounds();
      if (oldBounds && newBounds) {
        LTI_DUMP(oldBounds.value(), "oldtransform");
        LTI_DUMP(newBounds.value(), "newtransform");
        result = oldBounds.value();
        AddRegion(result, newBounds.value());
      } else {
        areaOverflowed = true;
      }

      // We can't bail out early because we might need to update some internal
      // layer state.
    }

    nsIntRegion internal;
    if (!ComputeChangeInternal(aPrefix, internal, aCallback)) {
      areaOverflowed = true;
    }

    LTI_DUMP(internal, "internal");
    AddRegion(result, internal);
    LTI_DUMP(mLayer->GetInvalidRegion().GetRegion(), "invalid");
    AddTransformedRegion(result, mLayer->GetInvalidRegion().GetRegion(), mTransform);

    if (mMaskLayer && otherMask) {
      nsIntRegion mask;
      if (!mMaskLayer->ComputeChange(aPrefix, mask, aCallback)) {
        areaOverflowed = true;
      }
      LTI_DUMP(mask, "mask");
      AddTransformedRegion(result, mask, mTransform);
    }

    for (size_t i = 0;
         i < std::min(mAncestorMaskLayers.Length(), mLayer->GetAncestorMaskLayerCount());
         i++)
    {
      nsIntRegion mask;
      if (!mAncestorMaskLayers[i]->ComputeChange(aPrefix, mask, aCallback)) {
        areaOverflowed = true;
      }
      LTI_DUMP(mask, "ancestormask");
      AddTransformedRegion(result, mask, mTransform);
    }

    if (mUseClipRect && otherClip) {
      if (!mClipRect.IsEqualInterior(*otherClip)) {
        nsIntRegion tmp;
        tmp.Xor(mClipRect.ToUnknownRect(), otherClip->ToUnknownRect());
        LTI_DUMP(tmp, "clip");
        AddRegion(result, tmp);
      }
    }

    mLayer->ClearInvalidRegion();

    if (areaOverflowed) {
      return false;
    }

    aOutRegion = std::move(result);
    return true;
  }

  void CheckCanary()
  {
    mCanary.Check();
    mLayer->CheckCanary();
  }

  IntRect NewTransformedBoundsForLeaf() {
    return TransformRect(mLayer->GetLocalVisibleRegion().GetBounds().ToUnknownRect(),
                         GetTransformForInvalidation(mLayer));
  }

  IntRect OldTransformedBoundsForLeaf() {
    return TransformRect(mVisibleRegion.GetBounds().ToUnknownRect(), mTransform);
  }

  virtual Maybe<IntRect> NewTransformedBounds()
  {
    return Some(TransformRect(mLayer->GetLocalVisibleRegion().GetBounds().ToUnknownRect(),
                              GetTransformForInvalidation(mLayer)));
  }

  virtual Maybe<IntRect> OldTransformedBounds()
  {
    return Some(TransformRect(mVisibleRegion.GetBounds().ToUnknownRect(), mTransform));
  }

  virtual bool ComputeChangeInternal(const char* aPrefix,
                                     nsIntRegion& aOutRegion,
                                     NotifySubDocInvalidationFunc aCallback)
  {
    if (mLayer->AsHostLayer() && !mLayer->GetLocalVisibleRegion().ToUnknownRegion().IsEqual(mVisibleRegion)) {
      IntRect result = NewTransformedBoundsForLeaf();
      result = result.Union(OldTransformedBoundsForLeaf());
      aOutRegion = result;
    }
    return true;
  }

  RefPtr<Layer> mLayer;
  UniquePtr<LayerPropertiesBase> mMaskLayer;
  nsTArray<UniquePtr<LayerPropertiesBase>> mAncestorMaskLayers;
  nsIntRegion mVisibleRegion;
  Matrix4x4Flagged mTransform;
  float mPostXScale;
  float mPostYScale;
  float mOpacity;
  ParentLayerIntRect mClipRect;
  bool mUseClipRect;
  mozilla::CorruptionCanary mCanary;
};

struct ContainerLayerProperties : public LayerPropertiesBase
{
  explicit ContainerLayerProperties(ContainerLayer* aLayer)
    : LayerPropertiesBase(aLayer)
    , mPreXScale(aLayer->GetPreXScale())
    , mPreYScale(aLayer->GetPreYScale())
  {
    for (Layer* child = aLayer->GetFirstChild(); child; child = child->GetNextSibling()) {
      child->CheckCanary();
      mChildren.AppendElement(CloneLayerTreePropertiesInternal(child));
    }
  }

protected:
  ContainerLayerProperties(const ContainerLayerProperties& a) = delete;
  ContainerLayerProperties& operator=(const ContainerLayerProperties& a) = delete;

public:
  bool ComputeChangeInternal(const char *aPrefix,
                             nsIntRegion& aOutRegion,
                             NotifySubDocInvalidationFunc aCallback) override
  {
    // Make sure we got our virtual call right
    mSubtypeCanary.Check();
    ContainerLayer* container = mLayer->AsContainerLayer();
    nsIntRegion invalidOfLayer; // Invalid regions of this layer.
    nsIntRegion result;         // Invliad regions for children only.

    container->CheckCanary();

    bool childrenChanged = false;
    bool invalidateWholeLayer = false;
    bool areaOverflowed = false;
    if (mPreXScale != container->GetPreXScale() ||
        mPreYScale != container->GetPreYScale())
    {
      Maybe<IntRect> oldBounds = OldTransformedBounds();
      Maybe<IntRect> newBounds = NewTransformedBounds();
      if (oldBounds && newBounds) {
        invalidOfLayer = oldBounds.value();
        AddRegion(invalidOfLayer, newBounds.value());
      } else {
        areaOverflowed = true;
      }
      childrenChanged = true;
      invalidateWholeLayer = true;

      // Can't bail out early, we need to update the child container layers
    }

    // A low frame rate is especially visible to users when scrolling, so we
    // particularly want to avoid unnecessary invalidation at that time. For us
    // here, that means avoiding unnecessary invalidation of child items when
    // other children are added to or removed from our container layer, since
    // that may be caused by children being scrolled in or out of view. We are
    // less concerned with children changing order.
    // TODO: Consider how we could avoid unnecessary invalidation when children
    // change order, and whether the overhead would be worth it.

    nsDataHashtable<nsPtrHashKey<Layer>, uint32_t> oldIndexMap(mChildren.Length());
    for (uint32_t i = 0; i < mChildren.Length(); ++i) {
      mChildren[i]->CheckCanary();
      oldIndexMap.Put(mChildren[i]->mLayer, i);
    }

    uint32_t i = 0; // cursor into the old child list mChildren
    for (Layer* child = container->GetFirstChild(); child; child = child->GetNextSibling()) {
      bool invalidateChildsCurrentArea = false;
      if (i < mChildren.Length()) {
        uint32_t childsOldIndex;
        if (oldIndexMap.Get(child, &childsOldIndex)) {
          if (childsOldIndex >= i) {
            // Invalidate the old areas of layers that used to be between the
            // current |child| and the previous |child| that was also in the
            // old list mChildren (if any of those children have been reordered
            // rather than removed, we will invalidate their new area when we
            // encounter them in the new list):
            for (uint32_t j = i; j < childsOldIndex; ++j) {
              if (Maybe<IntRect> bounds = mChildren[j]->OldTransformedBounds()) {
                LTI_DUMP(bounds.value(), "reordered child");
                AddRegion(result, bounds.value());
              } else {
                areaOverflowed = true;
              }
              childrenChanged |= true;
            }
            if (childsOldIndex >= mChildren.Length()) {
              MOZ_CRASH("Out of bounds");
            }
            // Invalidate any regions of the child that have changed:
            nsIntRegion region;
            if (!mChildren[childsOldIndex]->ComputeChange(LTI_DEEPER(aPrefix), region, aCallback)) {
              areaOverflowed = true;
            }
            i = childsOldIndex + 1;
            if (!region.IsEmpty()) {
              LTI_LOG("%s%p: child %p produced %s\n", aPrefix, mLayer.get(),
                mChildren[childsOldIndex]->mLayer.get(), Stringify(region).c_str());
              AddRegion(result, region);
              childrenChanged |= true;
            }
          } else {
            // We've already seen this child in mChildren (which means it must
            // have been reordered) and invalidated its old area. We need to
            // invalidate its new area too:
            invalidateChildsCurrentArea = true;
          }
        } else {
          // |child| is new
          invalidateChildsCurrentArea = true;
        }
      } else {
        // |child| is new, or was reordered to a higher index
        invalidateChildsCurrentArea = true;
      }
      if (invalidateChildsCurrentArea) {
        LTI_DUMP(child->GetLocalVisibleRegion().ToUnknownRegion(), "invalidateChildsCurrentArea");
        AddTransformedRegion(result, child->GetLocalVisibleRegion().ToUnknownRegion(),
                             GetTransformForInvalidation(child));
        if (aCallback) {
          NotifySubdocumentInvalidation(child, aCallback);
        } else {
          ClearInvalidations(child);
        }
      }
      childrenChanged |= invalidateChildsCurrentArea;
    }

    // Process remaining removed children.
    while (i < mChildren.Length()) {
      childrenChanged |= true;
      if (Maybe<IntRect> bounds = mChildren[i]->OldTransformedBounds()) {
        LTI_DUMP(bounds.value(), "removed child");
        AddRegion(result, bounds.value());
      } else {
        areaOverflowed = true;
      }
      i++;
    }

    if (aCallback) {
      aCallback(container, areaOverflowed ? nullptr : &result);
    }

    if (childrenChanged || areaOverflowed) {
      container->SetChildrenChanged(true);
    }

    if (container->UseIntermediateSurface()) {
      Maybe<IntRect> bounds;
      if (!invalidateWholeLayer && !areaOverflowed) {
        bounds = Some(result.GetBounds());

        // Process changes in the visible region.
        IntRegion newVisible = mLayer->GetLocalVisibleRegion().ToUnknownRegion();
        if (!newVisible.IsEqual(mVisibleRegion)) {
          newVisible.XorWith(mVisibleRegion);
          bounds = bounds->SafeUnion(newVisible.GetBounds());
        }
      }
      container->SetInvalidCompositeRect(bounds ? bounds.ptr() : nullptr);
    }

    // Safe to bail out early now, persistent state has been set.
    if (areaOverflowed) {
      return false;
    }

    if (!mLayer->Extend3DContext()) {
      // |result| contains invalid regions only of children.
      result.Transform(GetTransformForInvalidation(mLayer).GetMatrix());
    }
    // else, effective transforms have applied on children.

    LTI_DUMP(invalidOfLayer, "invalidOfLayer");
    result.OrWith(invalidOfLayer);

    aOutRegion = std::move(result);
    return true;
  }

  Maybe<IntRect> NewTransformedBounds() override
  {
    if (mLayer->Extend3DContext()) {
      IntRect result;
      for (UniquePtr<LayerPropertiesBase>& child : mChildren) {
        Maybe<IntRect> childBounds = child->NewTransformedBounds();
        if (!childBounds) {
          return Nothing();
        }
        Maybe<IntRect> combined = result.SafeUnion(childBounds.value());
        if (!combined) {
          LTI_LOG("overflowed bounds of container %p accumulating child %p\n", this, child->mLayer.get());
          return Nothing();
        }
        result = combined.value();
      }
      return Some(result);
    }

    return LayerPropertiesBase::NewTransformedBounds();
  }

  Maybe<IntRect> OldTransformedBounds() override
  {
    if (mLayer->Extend3DContext()) {
      IntRect result;
      for (UniquePtr<LayerPropertiesBase>& child : mChildren) {
        Maybe<IntRect> childBounds = child->OldTransformedBounds();
        if (!childBounds) {
          return Nothing();
        }
        Maybe<IntRect> combined = result.SafeUnion(childBounds.value());
        if (!combined) {
          LTI_LOG("overflowed bounds of container %p accumulating child %p\n", this, child->mLayer.get());
          return Nothing();
        }
        result = combined.value();
      }
      return Some(result);
    }
    return LayerPropertiesBase::OldTransformedBounds();
  }

  // The old list of children:
  mozilla::CorruptionCanary mSubtypeCanary;
  nsTArray<UniquePtr<LayerPropertiesBase>> mChildren;
  float mPreXScale;
  float mPreYScale;
};

struct ColorLayerProperties : public LayerPropertiesBase
{
  explicit ColorLayerProperties(ColorLayer *aLayer)
    : LayerPropertiesBase(aLayer)
    , mColor(aLayer->GetColor())
    , mBounds(aLayer->GetBounds())
  { }

protected:
  ColorLayerProperties(const ColorLayerProperties& a) = delete;
  ColorLayerProperties& operator=(const ColorLayerProperties& a) = delete;

public:
  bool ComputeChangeInternal(const char* aPrefix,
                             nsIntRegion& aOutRegion,
                             NotifySubDocInvalidationFunc aCallback) override
  {
    ColorLayer* color = static_cast<ColorLayer*>(mLayer.get());

    if (mColor != color->GetColor()) {
      LTI_DUMP(NewTransformedBoundsForLeaf(), "color");
      aOutRegion = NewTransformedBoundsForLeaf();
      return true;
    }

    nsIntRegion boundsDiff;
    boundsDiff.Xor(mBounds, color->GetBounds());
    LTI_DUMP(boundsDiff, "colorbounds");

    AddTransformedRegion(aOutRegion, boundsDiff, mTransform);
    return true;
  }

  Color mColor;
  IntRect mBounds;
};

static ImageHost* GetImageHost(Layer* aLayer)
{
  HostLayer* compositor = aLayer->AsHostLayer();
  if (compositor) {
    return static_cast<ImageHost*>(compositor->GetCompositableHost());
  }
  return nullptr;
}

struct ImageLayerProperties : public LayerPropertiesBase
{
  explicit ImageLayerProperties(ImageLayer* aImage, bool aIsMask)
    : LayerPropertiesBase(aImage)
    , mContainer(aImage->GetContainer())
    , mImageHost(GetImageHost(aImage))
    , mSamplingFilter(aImage->GetSamplingFilter())
    , mScaleToSize(aImage->GetScaleToSize())
    , mScaleMode(aImage->GetScaleMode())
    , mLastProducerID(-1)
    , mLastFrameID(-1)
    , mIsMask(aIsMask)
  {
    if (mImageHost) {
      mLastProducerID = mImageHost->GetLastProducerID();
      mLastFrameID = mImageHost->GetLastFrameID();
    }
  }

  bool ComputeChangeInternal(const char* aPrefix,
                             nsIntRegion& aOutRegion,
                             NotifySubDocInvalidationFunc aCallback) override
  {
    ImageLayer* imageLayer = static_cast<ImageLayer*>(mLayer.get());

    if (!imageLayer->GetLocalVisibleRegion().ToUnknownRegion().IsEqual(mVisibleRegion)) {
      IntRect result = NewTransformedBoundsForLeaf();
      result = result.Union(OldTransformedBoundsForLeaf());
      aOutRegion = result;
      return true;
    }

    ImageContainer* container = imageLayer->GetContainer();
    ImageHost* host = GetImageHost(imageLayer);
    if (mContainer != container ||
        mSamplingFilter != imageLayer->GetSamplingFilter() ||
        mScaleToSize != imageLayer->GetScaleToSize() ||
        mScaleMode != imageLayer->GetScaleMode() ||
        host != mImageHost ||
        (host && host->GetProducerID() != mLastProducerID) ||
        (host && host->GetFrameID() != mLastFrameID)) {

      if (mIsMask) {
        // Mask layers have an empty visible region, so we have to
        // use the image size instead.
        IntSize size;
        if (container) {
          size = container->GetCurrentSize();
        }
        if (host) {
          size = host->GetImageSize();
        }
        IntRect rect(0, 0, size.width, size.height);
        LTI_DUMP(rect, "mask");
        aOutRegion = TransformRect(rect, GetTransformForInvalidation(mLayer));
        return true;
      }
      LTI_DUMP(NewTransformedBoundsForLeaf(), "bounds");
      aOutRegion = NewTransformedBoundsForLeaf();
      return true;
    }

    return true;
  }

  RefPtr<ImageContainer> mContainer;
  RefPtr<ImageHost> mImageHost;
  SamplingFilter mSamplingFilter;
  gfx::IntSize mScaleToSize;
  ScaleMode mScaleMode;
  int32_t mLastProducerID;
  int32_t mLastFrameID;
  bool mIsMask;
};

struct CanvasLayerProperties : public LayerPropertiesBase
{
  explicit CanvasLayerProperties(CanvasLayer* aCanvas)
    : LayerPropertiesBase(aCanvas)
    , mImageHost(GetImageHost(aCanvas))
  {
    mFrameID = mImageHost ? mImageHost->GetFrameID() : -1;
  }

  bool ComputeChangeInternal(const char* aPrefix,
                             nsIntRegion& aOutRegion,
                             NotifySubDocInvalidationFunc aCallback) override
  {
    CanvasLayer* canvasLayer = static_cast<CanvasLayer*>(mLayer.get());

    ImageHost* host = GetImageHost(canvasLayer);
    if (host && host->GetFrameID() != mFrameID) {
      LTI_DUMP(NewTransformedBoundsForLeaf(), "frameId");
      aOutRegion = NewTransformedBoundsForLeaf();
      return true;
    }

    return true;
  }

  RefPtr<ImageHost> mImageHost;
  int32_t mFrameID;
};

UniquePtr<LayerPropertiesBase>
CloneLayerTreePropertiesInternal(Layer* aRoot, bool aIsMask /* = false */)
{
  if (!aRoot) {
    return MakeUnique<LayerPropertiesBase>();
  }

  MOZ_ASSERT(!aIsMask || aRoot->GetType() == Layer::TYPE_IMAGE);

  aRoot->CheckCanary();

  switch (aRoot->GetType()) {
    case Layer::TYPE_CONTAINER:
    case Layer::TYPE_REF:
      return MakeUnique<ContainerLayerProperties>(aRoot->AsContainerLayer());
    case Layer::TYPE_COLOR:
      return MakeUnique<ColorLayerProperties>(static_cast<ColorLayer*>(aRoot));
    case Layer::TYPE_IMAGE:
      return MakeUnique<ImageLayerProperties>(static_cast<ImageLayer*>(aRoot), aIsMask);
    case Layer::TYPE_CANVAS:
      return MakeUnique<CanvasLayerProperties>(static_cast<CanvasLayer*>(aRoot));
    case Layer::TYPE_DISPLAYITEM:
    case Layer::TYPE_READBACK:
    case Layer::TYPE_SHADOW:
    case Layer::TYPE_PAINTED:
      return MakeUnique<LayerPropertiesBase>(aRoot);
  }

  MOZ_ASSERT_UNREACHABLE("Unexpected root layer type");
  return MakeUnique<LayerPropertiesBase>(aRoot);
}

/* static */ UniquePtr<LayerProperties>
LayerProperties::CloneFrom(Layer* aRoot)
{
  return CloneLayerTreePropertiesInternal(aRoot);
}

/* static */ void
LayerProperties::ClearInvalidations(Layer *aLayer)
{
  ForEachNode<ForwardIterator>(
        aLayer,
        [] (Layer* layer)
        {
          layer->ClearInvalidRegion();
          if (layer->GetMaskLayer()) {
            ClearInvalidations(layer->GetMaskLayer());
          }
          for (size_t i = 0; i < layer->GetAncestorMaskLayerCount(); i++) {
            ClearInvalidations(layer->GetAncestorMaskLayerAt(i));
          }

        }
      );
}

bool
LayerPropertiesBase::ComputeDifferences(Layer* aRoot, nsIntRegion& aOutRegion, NotifySubDocInvalidationFunc aCallback)
{
  NS_ASSERTION(aRoot, "Must have a layer tree to compare against!");
  if (mLayer != aRoot) {
    if (aCallback) {
      NotifySubdocumentInvalidation(aRoot, aCallback);
    } else {
      ClearInvalidations(aRoot);
    }
    IntRect bounds = TransformRect(
      aRoot->GetLocalVisibleRegion().GetBounds().ToUnknownRect(),
      aRoot->GetLocalTransform());
    Maybe<IntRect> oldBounds = OldTransformedBounds();
    if (!oldBounds) {
      return false;
    }
    Maybe<IntRect> result = bounds.SafeUnion(oldBounds.value());
    if (!result) {
      LTI_LOG("overflowed bounds computing the union of layers %p and %p\n", mLayer.get(), aRoot);
      return false;
    }
    aOutRegion = result.value();
    return true;
  }
  return ComputeChange("  ", aOutRegion, aCallback);
}

void
LayerPropertiesBase::MoveBy(const IntPoint& aOffset)
{
  mTransform.PostTranslate(aOffset.x, aOffset.y, 0);
}

} // namespace layers
} // namespace mozilla