Add m-esr52 at 52.6.0

1 files changed, 679 insertions, 0 deletions

diff --git a/gfx/layers/LayerTreeInvalidation.cpp b/gfx/layers/LayerTreeInvalidation.cpp
new file mode 100644
index 000000000..5604fafee
--- /dev/null
+++ b/gfx/layers/LayerTreeInvalidation.cpp
@@ -0,0 +1,679 @@
+/*-*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * 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/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
+
+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 Matrix4x4
+GetTransformForInvalidation(Layer* aLayer) {
+  return (!aLayer->Is3DContextLeaf() && !aLayer->Extend3DContext() ?
+          aLayer->GetLocalTransform() : GetTransformIn3DContext(aLayer));
+}
+
+static IntRect
+TransformRect(const IntRect& aRect, const Matrix4x4& 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 (!gfxUtils::GfxRectToIntRect(ThebesRect(rect), &intRect)) {
+    return IntRect();
+  }
+
+  return intRect;
+}
+
+static void
+AddTransformedRegion(nsIntRegion& aDest, const nsIntRegion& aSource, const Matrix4x4& 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->ClearInvalidRect();
+        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) {
+          aCallback(container, container->GetLocalVisibleRegion().ToUnknownRegion());
+        }
+      });
+}
+
+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)
+  {
+    MOZ_COUNT_CTOR(LayerPropertiesBase);
+  }
+  ~LayerPropertiesBase()
+  {
+    MOZ_COUNT_DTOR(LayerPropertiesBase);
+  }
+
+protected:
+  LayerPropertiesBase(const LayerPropertiesBase& a) = delete;
+  LayerPropertiesBase& operator=(const LayerPropertiesBase& a) = delete;
+
+public:
+  virtual nsIntRegion ComputeDifferences(Layer* aRoot,
+                                         NotifySubDocInvalidationFunc aCallback,
+                                         bool* aGeometryChanged);
+
+  virtual void MoveBy(const IntPoint& aOffset);
+
+  nsIntRegion ComputeChange(NotifySubDocInvalidationFunc aCallback,
+                            bool& aGeometryChanged)
+  {
+    // 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;
+        }
+      }
+    }
+
+    Layer* otherMask = mLayer->GetMaskLayer();
+    if ((mMaskLayer ? mMaskLayer->mLayer : nullptr) != otherMask ||
+        ancestorMaskChanged ||
+        (mUseClipRect != !!otherClip) ||
+        mLayer->GetLocalOpacity() != mOpacity ||
+        transformChanged)
+    {
+      aGeometryChanged = true;
+      result = OldTransformedBounds();
+      AddRegion(result, NewTransformedBounds());
+
+      // We can't bail out early because we need to update mChildrenChanged.
+    }
+
+    AddRegion(result, ComputeChangeInternal(aCallback, aGeometryChanged));
+    AddTransformedRegion(result, mLayer->GetInvalidRegion().GetRegion(), mTransform);
+
+    if (mMaskLayer && otherMask) {
+      AddTransformedRegion(result, mMaskLayer->ComputeChange(aCallback, aGeometryChanged),
+                           mTransform);
+    }
+
+    for (size_t i = 0;
+         i < std::min(mAncestorMaskLayers.Length(), mLayer->GetAncestorMaskLayerCount());
+         i++)
+    {
+      AddTransformedRegion(result,
+                           mAncestorMaskLayers[i]->ComputeChange(aCallback, aGeometryChanged),
+                           mTransform);
+    }
+
+    if (mUseClipRect && otherClip) {
+      if (!mClipRect.IsEqualInterior(*otherClip)) {
+        aGeometryChanged = true;
+        nsIntRegion tmp;
+        tmp.Xor(mClipRect.ToUnknownRect(), otherClip->ToUnknownRect());
+        AddRegion(result, tmp);
+      }
+    }
+
+    mLayer->ClearInvalidRect();
+    return result;
+  }
+
+  void CheckCanary()
+  {
+    mCanary.Check();
+    mLayer->CheckCanary();
+  }
+
+  virtual IntRect NewTransformedBounds()
+  {
+    return TransformRect(mLayer->GetLocalVisibleRegion().ToUnknownRegion().GetBounds(),
+                         GetTransformForInvalidation(mLayer));
+  }
+
+  virtual IntRect OldTransformedBounds()
+  {
+    return TransformRect(mVisibleRegion.ToUnknownRegion().GetBounds(), mTransform);
+  }
+
+  virtual nsIntRegion ComputeChangeInternal(NotifySubDocInvalidationFunc aCallback,
+                                            bool& aGeometryChanged)
+  {
+    return IntRect();
+  }
+
+  RefPtr<Layer> mLayer;
+  UniquePtr<LayerPropertiesBase> mMaskLayer;
+  nsTArray<UniquePtr<LayerPropertiesBase>> mAncestorMaskLayers;
+  nsIntRegion mVisibleRegion;
+  Matrix4x4 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(Move(CloneLayerTreePropertiesInternal(child)));
+    }
+  }
+
+protected:
+  ContainerLayerProperties(const ContainerLayerProperties& a) = delete;
+  ContainerLayerProperties& operator=(const ContainerLayerProperties& a) = delete;
+
+public:
+  nsIntRegion ComputeChangeInternal(NotifySubDocInvalidationFunc aCallback,
+                                    bool& aGeometryChanged) 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;
+
+    if (mPreXScale != container->GetPreXScale() ||
+        mPreYScale != container->GetPreYScale()) {
+      aGeometryChanged = true;
+      invalidOfLayer = OldTransformedBounds();
+      AddRegion(invalidOfLayer, NewTransformedBounds());
+      childrenChanged = 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) {
+              AddRegion(result, mChildren[j]->OldTransformedBounds());
+              childrenChanged |= true;
+            }
+            if (childsOldIndex >= mChildren.Length()) {
+              MOZ_CRASH("Out of bounds");
+            }
+            // Invalidate any regions of the child that have changed:
+            nsIntRegion region = mChildren[childsOldIndex]->ComputeChange(aCallback, aGeometryChanged);
+            i = childsOldIndex + 1;
+            if (!region.IsEmpty()) {
+              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) {
+        aGeometryChanged = true;
+        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;
+      AddRegion(result, mChildren[i]->OldTransformedBounds());
+      i++;
+    }
+
+    if (aCallback) {
+      aCallback(container, result);
+    }
+
+    if (childrenChanged) {
+      container->SetChildrenChanged(true);
+    }
+
+    if (!mLayer->Extend3DContext()) {
+      // |result| contains invalid regions only of children.
+      result.Transform(GetTransformForInvalidation(mLayer));
+    }
+    // else, effective transforms have applied on children.
+
+    result.OrWith(invalidOfLayer);
+
+    return result;
+  }
+
+  IntRect NewTransformedBounds() override
+  {
+    if (mLayer->Extend3DContext()) {
+      IntRect result;
+      for (UniquePtr<LayerPropertiesBase>& child : mChildren) {
+        result = result.Union(child->NewTransformedBounds());
+      }
+      return result;
+    }
+
+    return LayerPropertiesBase::NewTransformedBounds();
+  }
+
+  IntRect OldTransformedBounds() override
+  {
+    if (mLayer->Extend3DContext()) {
+      IntRect result;
+      for (UniquePtr<LayerPropertiesBase>& child : mChildren) {
+        result = result.Union(child->OldTransformedBounds());
+      }
+      return 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:
+  virtual nsIntRegion ComputeChangeInternal(NotifySubDocInvalidationFunc aCallback,
+                                            bool& aGeometryChanged)
+  {
+    ColorLayer* color = static_cast<ColorLayer*>(mLayer.get());
+
+    if (mColor != color->GetColor()) {
+      aGeometryChanged = true;
+      return NewTransformedBounds();
+    }
+
+    nsIntRegion boundsDiff;
+    boundsDiff.Xor(mBounds, color->GetBounds());
+
+    nsIntRegion result;
+    AddTransformedRegion(result, boundsDiff, mTransform);
+
+    return result;
+  }
+
+  Color mColor;
+  IntRect mBounds;
+};
+
+static ImageHost* GetImageHost(Layer* aLayer)
+{
+  LayerComposite* composite = aLayer->AsLayerComposite();
+  if (composite) {
+    return static_cast<ImageHost*>(composite->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();
+    }
+  }
+
+  virtual nsIntRegion ComputeChangeInternal(NotifySubDocInvalidationFunc aCallback,
+                                            bool& aGeometryChanged)
+  {
+    ImageLayer* imageLayer = static_cast<ImageLayer*>(mLayer.get());
+
+    if (!imageLayer->GetLocalVisibleRegion().ToUnknownRegion().IsEqual(mVisibleRegion)) {
+      aGeometryChanged = true;
+      IntRect result = NewTransformedBounds();
+      result = result.Union(OldTransformedBounds());
+      return result;
+    }
+
+    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)) {
+      aGeometryChanged = true;
+
+      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);
+        return TransformRect(rect, GetTransformForInvalidation(mLayer));
+      }
+      return NewTransformedBounds();
+    }
+
+    return IntRect();
+  }
+
+  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;
+  }
+
+  virtual nsIntRegion ComputeChangeInternal(NotifySubDocInvalidationFunc aCallback,
+                                            bool& aGeometryChanged)
+  {
+    CanvasLayer* canvasLayer = static_cast<CanvasLayer*>(mLayer.get());
+
+    ImageHost* host = GetImageHost(canvasLayer);
+    if (host && host->GetFrameID() != mFrameID) {
+      aGeometryChanged = true;
+
+      return NewTransformedBounds();
+    }
+
+    return IntRect();
+  }
+
+  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_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->ClearInvalidRect();
+          if (layer->GetMaskLayer()) {
+            ClearInvalidations(layer->GetMaskLayer());
+          }
+          for (size_t i = 0; i < layer->GetAncestorMaskLayerCount(); i++) {
+            ClearInvalidations(layer->GetAncestorMaskLayerAt(i));
+          }
+
+        }
+      );
+}
+
+nsIntRegion
+LayerPropertiesBase::ComputeDifferences(Layer* aRoot, NotifySubDocInvalidationFunc aCallback,
+                                        bool* aGeometryChanged = nullptr)
+{
+  NS_ASSERTION(aRoot, "Must have a layer tree to compare against!");
+  if (mLayer != aRoot) {
+    if (aCallback) {
+      NotifySubdocumentInvalidation(aRoot, aCallback);
+    } else {
+      ClearInvalidations(aRoot);
+    }
+    IntRect result = TransformRect(aRoot->GetLocalVisibleRegion().ToUnknownRegion().GetBounds(),
+                                     aRoot->GetLocalTransform());
+    result = result.Union(OldTransformedBounds());
+    if (aGeometryChanged != nullptr) {
+      *aGeometryChanged = true;
+    }
+    return result;
+  } else {
+    bool geometryChanged = (aGeometryChanged != nullptr) ? *aGeometryChanged : false;
+    nsIntRegion invalid = ComputeChange(aCallback, geometryChanged);
+    if (aGeometryChanged != nullptr) {
+      *aGeometryChanged = geometryChanged;
+    }
+    return invalid;
+  }
+}
+
+void
+LayerPropertiesBase::MoveBy(const IntPoint& aOffset)
+{
+  mTransform.PostTranslate(aOffset.x, aOffset.y, 0);
+}
+
+} // namespace layers
+} // namespace mozilla