Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 616 insertions, 0 deletions

diff --git a/gfx/layers/Compositor.cpp b/gfx/layers/Compositor.cpp
new file mode 100644
index 0000000000..80fbb97c87
--- /dev/null
+++ b/gfx/layers/Compositor.cpp
@@ -0,0 +1,616 @@
+/* -*- 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 "mozilla/layers/Compositor.h"
+#include "mozilla/layers/CompositionRecorder.h"
+#include "base/message_loop.h"  // for MessageLoop
+#include "mozilla/gfx/Types.h"
+#include "mozilla/layers/CompositorBridgeParent.h"  // for CompositorBridgeParent
+#include "mozilla/layers/Diagnostics.h"
+#include "mozilla/layers/Effects.h"  // for Effect, EffectChain, etc
+#include "mozilla/layers/TextureClient.h"
+#include "mozilla/layers/TextureHost.h"
+#include "mozilla/layers/CompositorThread.h"
+#include "mozilla/mozalloc.h"  // for operator delete, etc
+#include "GeckoProfiler.h"
+#include "gfx2DGlue.h"
+#include "nsAppRunner.h"
+#include "LayersHelpers.h"
+
+namespace mozilla {
+
+namespace layers {
+
+class CompositorRecordedFrame final : public RecordedFrame {
+ public:
+  CompositorRecordedFrame(const TimeStamp& aTimeStamp,
+                          RefPtr<AsyncReadbackBuffer>&& aBuffer)
+      : RecordedFrame(aTimeStamp), mBuffer(aBuffer) {}
+
+  virtual already_AddRefed<gfx::DataSourceSurface> GetSourceSurface() override {
+    if (mSurface) {
+      return do_AddRef(mSurface);
+    }
+
+    gfx::IntSize size = mBuffer->GetSize();
+
+    mSurface = gfx::Factory::CreateDataSourceSurface(
+        size, gfx::SurfaceFormat::B8G8R8A8,
+        /* aZero = */ false);
+
+    if (!mBuffer->MapAndCopyInto(mSurface, size)) {
+      mSurface = nullptr;
+      return nullptr;
+    }
+
+    return do_AddRef(mSurface);
+  }
+
+ private:
+  RefPtr<AsyncReadbackBuffer> mBuffer;
+  RefPtr<gfx::DataSourceSurface> mSurface;
+};
+
+Compositor::Compositor(widget::CompositorWidget* aWidget,
+                       CompositorBridgeParent* aParent)
+    : mDiagnosticTypes(DiagnosticTypes::NO_DIAGNOSTIC),
+      mParent(aParent),
+      mPixelsPerFrame(0),
+      mPixelsFilled(0),
+      mScreenRotation(ROTATION_0),
+      mWidget(aWidget),
+      mIsDestroyed(false)
+#if defined(MOZ_WIDGET_ANDROID)
+      // If the default color isn't white for Fennec, there is a black
+      // flash before the first page of a tab is loaded.
+      ,
+      mClearColor(ToDeviceColor(sRGBColor::OpaqueWhite())),
+      mDefaultClearColor(ToDeviceColor(sRGBColor::OpaqueWhite()))
+#else
+      ,
+      mClearColor(gfx::DeviceColor()),
+      mDefaultClearColor(gfx::DeviceColor())
+#endif
+{
+}
+
+Compositor::~Compositor() { ReadUnlockTextures(); }
+
+void Compositor::Destroy() {
+  mWidget = nullptr;
+
+  TextureSourceProvider::Destroy();
+  mIsDestroyed = true;
+}
+
+void Compositor::EndFrame() {
+  ReadUnlockTextures();
+  mLastCompositionEndTime = TimeStamp::Now();
+}
+
+bool Compositor::ShouldDrawDiagnostics(DiagnosticFlags aFlags) {
+  if ((aFlags & DiagnosticFlags::TILE) &&
+      !(mDiagnosticTypes & DiagnosticTypes::TILE_BORDERS)) {
+    return false;
+  }
+  if ((aFlags & DiagnosticFlags::BIGIMAGE) &&
+      !(mDiagnosticTypes & DiagnosticTypes::BIGIMAGE_BORDERS)) {
+    return false;
+  }
+  if (mDiagnosticTypes == DiagnosticTypes::NO_DIAGNOSTIC) {
+    return false;
+  }
+  return true;
+}
+
+void Compositor::DrawDiagnostics(DiagnosticFlags aFlags,
+                                 const nsIntRegion& aVisibleRegion,
+                                 const gfx::IntRect& aClipRect,
+                                 const gfx::Matrix4x4& aTransform,
+                                 uint32_t aFlashCounter) {
+  if (!ShouldDrawDiagnostics(aFlags)) {
+    return;
+  }
+
+  if (aVisibleRegion.GetNumRects() > 1) {
+    for (auto iter = aVisibleRegion.RectIter(); !iter.Done(); iter.Next()) {
+      DrawDiagnostics(aFlags | DiagnosticFlags::REGION_RECT,
+                      IntRectToRect(iter.Get()), aClipRect, aTransform,
+                      aFlashCounter);
+    }
+  }
+
+  DrawDiagnostics(aFlags, IntRectToRect(aVisibleRegion.GetBounds()), aClipRect,
+                  aTransform, aFlashCounter);
+}
+
+void Compositor::DrawDiagnostics(DiagnosticFlags aFlags,
+                                 const gfx::Rect& aVisibleRect,
+                                 const gfx::IntRect& aClipRect,
+                                 const gfx::Matrix4x4& aTransform,
+                                 uint32_t aFlashCounter) {
+  if (!ShouldDrawDiagnostics(aFlags)) {
+    return;
+  }
+
+  DrawDiagnosticsInternal(aFlags, aVisibleRect, aClipRect, aTransform,
+                          aFlashCounter);
+}
+
+void Compositor::DrawDiagnosticsInternal(DiagnosticFlags aFlags,
+                                         const gfx::Rect& aVisibleRect,
+                                         const gfx::IntRect& aClipRect,
+                                         const gfx::Matrix4x4& aTransform,
+                                         uint32_t aFlashCounter) {
+#ifdef ANDROID
+  int lWidth = 10;
+#else
+  int lWidth = 2;
+#endif
+
+  // Technically it is sRGB but it is just for debugging.
+  gfx::DeviceColor color;
+  if (aFlags & DiagnosticFlags::CONTENT) {
+    color = gfx::DeviceColor(0.0f, 1.0f, 0.0f, 1.0f);  // green
+    if (aFlags & DiagnosticFlags::COMPONENT_ALPHA) {
+      color = gfx::DeviceColor(0.0f, 1.0f, 1.0f, 1.0f);  // greenish blue
+    }
+  } else if (aFlags & DiagnosticFlags::IMAGE) {
+    if (aFlags & DiagnosticFlags::NV12) {
+      color = gfx::DeviceColor(1.0f, 1.0f, 0.0f, 1.0f);  // yellow
+    } else if (aFlags & DiagnosticFlags::YCBCR) {
+      color = gfx::DeviceColor(1.0f, 0.55f, 0.0f, 1.0f);  // orange
+    } else {
+      color = gfx::DeviceColor(1.0f, 0.0f, 0.0f, 1.0f);  // red
+    }
+  } else if (aFlags & DiagnosticFlags::COLOR) {
+    color = gfx::DeviceColor(0.0f, 0.0f, 1.0f, 1.0f);  // blue
+  } else if (aFlags & DiagnosticFlags::CONTAINER) {
+    color = gfx::DeviceColor(0.8f, 0.0f, 0.8f, 1.0f);  // purple
+  }
+
+  // make tile borders a bit more transparent to keep layer borders readable.
+  if (aFlags & DiagnosticFlags::TILE || aFlags & DiagnosticFlags::BIGIMAGE ||
+      aFlags & DiagnosticFlags::REGION_RECT) {
+    lWidth = 1;
+    color.r *= 0.7f;
+    color.g *= 0.7f;
+    color.b *= 0.7f;
+    color.a = color.a * 0.5f;
+  } else {
+    color.a = color.a * 0.7f;
+  }
+
+  if (mDiagnosticTypes & DiagnosticTypes::FLASH_BORDERS) {
+    float flash = (float)aFlashCounter / (float)DIAGNOSTIC_FLASH_COUNTER_MAX;
+    color.r *= flash;
+    color.g *= flash;
+    color.b *= flash;
+  }
+
+  SlowDrawRect(aVisibleRect, color, aClipRect, aTransform, lWidth);
+}
+
+static void UpdateTextureCoordinates(gfx::TexturedTriangle& aTriangle,
+                                     const gfx::Rect& aRect,
+                                     const gfx::Rect& aIntersection,
+                                     const gfx::Rect& aTextureCoords) {
+  // Calculate the relative offset of the intersection within the layer.
+  float dx = (aIntersection.X() - aRect.X()) / aRect.Width();
+  float dy = (aIntersection.Y() - aRect.Y()) / aRect.Height();
+
+  // Update the texture offset.
+  float x = aTextureCoords.X() + dx * aTextureCoords.Width();
+  float y = aTextureCoords.Y() + dy * aTextureCoords.Height();
+
+  // Scale the texture width and height.
+  float w = aTextureCoords.Width() * aIntersection.Width() / aRect.Width();
+  float h = aTextureCoords.Height() * aIntersection.Height() / aRect.Height();
+
+  static const auto Clamp = [](float& f) {
+    if (f >= 1.0f) f = 1.0f;
+    if (f <= 0.0f) f = 0.0f;
+  };
+
+  auto UpdatePoint = [&](const gfx::Point& p, gfx::Point& t) {
+    t.x = x + (p.x - aIntersection.X()) / aIntersection.Width() * w;
+    t.y = y + (p.y - aIntersection.Y()) / aIntersection.Height() * h;
+
+    Clamp(t.x);
+    Clamp(t.y);
+  };
+
+  UpdatePoint(aTriangle.p1, aTriangle.textureCoords.p1);
+  UpdatePoint(aTriangle.p2, aTriangle.textureCoords.p2);
+  UpdatePoint(aTriangle.p3, aTriangle.textureCoords.p3);
+}
+
+void Compositor::DrawGeometry(const gfx::Rect& aRect,
+                              const gfx::IntRect& aClipRect,
+                              const EffectChain& aEffectChain,
+                              gfx::Float aOpacity,
+                              const gfx::Matrix4x4& aTransform,
+                              const gfx::Rect& aVisibleRect,
+                              const Maybe<gfx::Polygon>& aGeometry) {
+  if (aRect.IsEmpty()) {
+    return;
+  }
+
+  if (!aGeometry || !SupportsLayerGeometry()) {
+    DrawQuad(aRect, aClipRect, aEffectChain, aOpacity, aTransform,
+             aVisibleRect);
+    return;
+  }
+
+  // Cull completely invisible polygons.
+  if (aRect.Intersect(aGeometry->BoundingBox()).IsEmpty()) {
+    return;
+  }
+
+  const gfx::Polygon clipped = aGeometry->ClipPolygon(aRect);
+
+  // Cull polygons with no area.
+  if (clipped.IsEmpty()) {
+    return;
+  }
+
+  DrawPolygon(clipped, aRect, aClipRect, aEffectChain, aOpacity, aTransform,
+              aVisibleRect);
+}
+
+void Compositor::DrawTriangles(
+    const nsTArray<gfx::TexturedTriangle>& aTriangles, const gfx::Rect& aRect,
+    const gfx::IntRect& aClipRect, const EffectChain& aEffectChain,
+    gfx::Float aOpacity, const gfx::Matrix4x4& aTransform,
+    const gfx::Rect& aVisibleRect) {
+  for (const gfx::TexturedTriangle& triangle : aTriangles) {
+    DrawTriangle(triangle, aClipRect, aEffectChain, aOpacity, aTransform,
+                 aVisibleRect);
+  }
+}
+
+nsTArray<gfx::TexturedTriangle> GenerateTexturedTriangles(
+    const gfx::Polygon& aPolygon, const gfx::Rect& aRect,
+    const gfx::Rect& aTexRect) {
+  nsTArray<gfx::TexturedTriangle> texturedTriangles;
+
+  gfx::Rect layerRects[4];
+  gfx::Rect textureRects[4];
+  size_t rects =
+      DecomposeIntoNoRepeatRects(aRect, aTexRect, &layerRects, &textureRects);
+  for (size_t i = 0; i < rects; ++i) {
+    const gfx::Rect& rect = layerRects[i];
+    const gfx::Rect& texRect = textureRects[i];
+    const gfx::Polygon clipped = aPolygon.ClipPolygon(rect);
+
+    if (clipped.IsEmpty()) {
+      continue;
+    }
+
+    for (const gfx::Triangle& triangle : clipped.ToTriangles()) {
+      const gfx::Rect intersection = rect.Intersect(triangle.BoundingBox());
+
+      // Cull completely invisible triangles.
+      if (intersection.IsEmpty()) {
+        continue;
+      }
+
+      MOZ_ASSERT(rect.Width() > 0.0f && rect.Height() > 0.0f);
+      MOZ_ASSERT(intersection.Width() > 0.0f && intersection.Height() > 0.0f);
+
+      // Since the texture was created for non-split geometry, we need to
+      // update the texture coordinates to account for the split.
+      gfx::TexturedTriangle t(triangle);
+      UpdateTextureCoordinates(t, rect, intersection, texRect);
+      texturedTriangles.AppendElement(std::move(t));
+    }
+  }
+
+  return texturedTriangles;
+}
+
+nsTArray<TexturedVertex> TexturedTrianglesToVertexArray(
+    const nsTArray<gfx::TexturedTriangle>& aTriangles) {
+  const auto VertexFromPoints = [](const gfx::Point& p, const gfx::Point& t) {
+    return TexturedVertex{{p.x, p.y}, {t.x, t.y}};
+  };
+
+  nsTArray<TexturedVertex> vertices;
+
+  for (const gfx::TexturedTriangle& t : aTriangles) {
+    vertices.AppendElement(VertexFromPoints(t.p1, t.textureCoords.p1));
+    vertices.AppendElement(VertexFromPoints(t.p2, t.textureCoords.p2));
+    vertices.AppendElement(VertexFromPoints(t.p3, t.textureCoords.p3));
+  }
+
+  return vertices;
+}
+
+void Compositor::DrawPolygon(const gfx::Polygon& aPolygon,
+                             const gfx::Rect& aRect,
+                             const gfx::IntRect& aClipRect,
+                             const EffectChain& aEffectChain,
+                             gfx::Float aOpacity,
+                             const gfx::Matrix4x4& aTransform,
+                             const gfx::Rect& aVisibleRect) {
+  nsTArray<gfx::TexturedTriangle> texturedTriangles;
+
+  TexturedEffect* texturedEffect =
+      aEffectChain.mPrimaryEffect->AsTexturedEffect();
+
+  if (texturedEffect) {
+    texturedTriangles = GenerateTexturedTriangles(
+        aPolygon, aRect, texturedEffect->mTextureCoords);
+  } else {
+    for (const gfx::Triangle& triangle : aPolygon.ToTriangles()) {
+      texturedTriangles.AppendElement(gfx::TexturedTriangle(triangle));
+    }
+  }
+
+  if (texturedTriangles.IsEmpty()) {
+    // Nothing to render.
+    return;
+  }
+
+  DrawTriangles(texturedTriangles, aRect, aClipRect, aEffectChain, aOpacity,
+                aTransform, aVisibleRect);
+}
+
+void Compositor::SlowDrawRect(const gfx::Rect& aRect,
+                              const gfx::DeviceColor& aColor,
+                              const gfx::IntRect& aClipRect,
+                              const gfx::Matrix4x4& aTransform,
+                              int aStrokeWidth) {
+  // TODO This should draw a rect using a single draw call but since
+  // this is only used for debugging overlays it's not worth optimizing ATM.
+  float opacity = 1.0f;
+  EffectChain effects;
+
+  effects.mPrimaryEffect = new EffectSolidColor(aColor);
+  // left
+  this->DrawQuad(gfx::Rect(aRect.X(), aRect.Y(), aStrokeWidth, aRect.Height()),
+                 aClipRect, effects, opacity, aTransform);
+  // top
+  this->DrawQuad(gfx::Rect(aRect.X() + aStrokeWidth, aRect.Y(),
+                           aRect.Width() - 2 * aStrokeWidth, aStrokeWidth),
+                 aClipRect, effects, opacity, aTransform);
+  // right
+  this->DrawQuad(gfx::Rect(aRect.XMost() - aStrokeWidth, aRect.Y(),
+                           aStrokeWidth, aRect.Height()),
+                 aClipRect, effects, opacity, aTransform);
+  // bottom
+  this->DrawQuad(
+      gfx::Rect(aRect.X() + aStrokeWidth, aRect.YMost() - aStrokeWidth,
+                aRect.Width() - 2 * aStrokeWidth, aStrokeWidth),
+      aClipRect, effects, opacity, aTransform);
+}
+
+void Compositor::FillRect(const gfx::Rect& aRect,
+                          const gfx::DeviceColor& aColor,
+                          const gfx::IntRect& aClipRect,
+                          const gfx::Matrix4x4& aTransform) {
+  float opacity = 1.0f;
+  EffectChain effects;
+
+  effects.mPrimaryEffect = new EffectSolidColor(aColor);
+  this->DrawQuad(aRect, aClipRect, effects, opacity, aTransform);
+}
+
+static float WrapTexCoord(float v) {
+  // This should return values in range [0, 1.0)
+  return v - floorf(v);
+}
+
+static void SetRects(size_t n, decomposedRectArrayT* aLayerRects,
+                     decomposedRectArrayT* aTextureRects, float x0, float y0,
+                     float x1, float y1, float tx0, float ty0, float tx1,
+                     float ty1, bool flip_y) {
+  if (flip_y) {
+    std::swap(ty0, ty1);
+  }
+  (*aLayerRects)[n] = gfx::Rect(x0, y0, x1 - x0, y1 - y0);
+  (*aTextureRects)[n] = gfx::Rect(tx0, ty0, tx1 - tx0, ty1 - ty0);
+}
+
+#ifdef DEBUG
+static inline bool FuzzyEqual(float a, float b) {
+  return fabs(a - b) < 0.0001f;
+}
+static inline bool FuzzyLTE(float a, float b) { return a <= b + 0.0001f; }
+#endif
+
+size_t DecomposeIntoNoRepeatRects(const gfx::Rect& aRect,
+                                  const gfx::Rect& aTexCoordRect,
+                                  decomposedRectArrayT* aLayerRects,
+                                  decomposedRectArrayT* aTextureRects) {
+  gfx::Rect texCoordRect = aTexCoordRect;
+
+  // If the texture should be flipped, it will have negative height. Detect that
+  // here and compensate for it. We will flip each rect as we emit it.
+  bool flipped = false;
+  if (texCoordRect.Height() < 0) {
+    flipped = true;
+    texCoordRect.MoveByY(texCoordRect.Height());
+    texCoordRect.SetHeight(-texCoordRect.Height());
+  }
+
+  // Wrap the texture coordinates so they are within [0,1] and cap width/height
+  // at 1. We rely on this below.
+  texCoordRect = gfx::Rect(gfx::Point(WrapTexCoord(texCoordRect.X()),
+                                      WrapTexCoord(texCoordRect.Y())),
+                           gfx::Size(std::min(texCoordRect.Width(), 1.0f),
+                                     std::min(texCoordRect.Height(), 1.0f)));
+
+  NS_ASSERTION(
+      texCoordRect.X() >= 0.0f && texCoordRect.X() <= 1.0f &&
+          texCoordRect.Y() >= 0.0f && texCoordRect.Y() <= 1.0f &&
+          texCoordRect.Width() >= 0.0f && texCoordRect.Width() <= 1.0f &&
+          texCoordRect.Height() >= 0.0f && texCoordRect.Height() <= 1.0f &&
+          texCoordRect.XMost() >= 0.0f && texCoordRect.XMost() <= 2.0f &&
+          texCoordRect.YMost() >= 0.0f && texCoordRect.YMost() <= 2.0f,
+      "We just wrapped the texture coordinates, didn't we?");
+
+  // Get the top left and bottom right points of the rectangle. Note that
+  // tl.x/tl.y are within [0,1] but br.x/br.y are within [0,2].
+  gfx::Point tl = texCoordRect.TopLeft();
+  gfx::Point br = texCoordRect.BottomRight();
+
+  NS_ASSERTION(tl.x >= 0.0f && tl.x <= 1.0f && tl.y >= 0.0f && tl.y <= 1.0f &&
+                   br.x >= tl.x && br.x <= 2.0f && br.y >= tl.y &&
+                   br.y <= 2.0f && FuzzyLTE(br.x - tl.x, 1.0f) &&
+                   FuzzyLTE(br.y - tl.y, 1.0f),
+               "Somehow generated invalid texture coordinates");
+
+  // Then check if we wrap in either the x or y axis.
+  bool xwrap = br.x > 1.0f;
+  bool ywrap = br.y > 1.0f;
+
+  // If xwrap is false, the texture will be sampled from tl.x .. br.x.
+  // If xwrap is true, then it will be split into tl.x .. 1.0, and
+  // 0.0 .. WrapTexCoord(br.x). Same for the Y axis. The destination
+  // rectangle is also split appropriately, according to the calculated
+  // xmid/ymid values.
+  if (!xwrap && !ywrap) {
+    SetRects(0, aLayerRects, aTextureRects, aRect.X(), aRect.Y(), aRect.XMost(),
+             aRect.YMost(), tl.x, tl.y, br.x, br.y, flipped);
+    return 1;
+  }
+
+  // If we are dealing with wrapping br.x and br.y are greater than 1.0 so
+  // wrap them here as well.
+  br = gfx::Point(xwrap ? WrapTexCoord(br.x) : br.x,
+                  ywrap ? WrapTexCoord(br.y) : br.y);
+
+  // If we wrap around along the x axis, we will draw first from
+  // tl.x .. 1.0 and then from 0.0 .. br.x (which we just wrapped above).
+  // The same applies for the Y axis. The midpoints we calculate here are
+  // only valid if we actually wrap around.
+  GLfloat xmid =
+      aRect.X() + (1.0f - tl.x) / texCoordRect.Width() * aRect.Width();
+  GLfloat ymid =
+      aRect.Y() + (1.0f - tl.y) / texCoordRect.Height() * aRect.Height();
+
+  // Due to floating-point inaccuracy, we have to use XMost()-x and YMost()-y
+  // to calculate width and height, respectively, to ensure that size will
+  // remain consistent going from absolute to relative and back again.
+  NS_ASSERTION(
+      !xwrap || (xmid >= aRect.X() && xmid <= aRect.XMost() &&
+                 FuzzyEqual((xmid - aRect.X()) + (aRect.XMost() - xmid),
+                            aRect.XMost() - aRect.X())),
+      "xmid should be within [x,XMost()] and the wrapped rect should have the "
+      "same width");
+  NS_ASSERTION(
+      !ywrap || (ymid >= aRect.Y() && ymid <= aRect.YMost() &&
+                 FuzzyEqual((ymid - aRect.Y()) + (aRect.YMost() - ymid),
+                            aRect.YMost() - aRect.Y())),
+      "ymid should be within [y,YMost()] and the wrapped rect should have the "
+      "same height");
+
+  if (!xwrap && ywrap) {
+    SetRects(0, aLayerRects, aTextureRects, aRect.X(), aRect.Y(), aRect.XMost(),
+             ymid, tl.x, tl.y, br.x, 1.0f, flipped);
+    SetRects(1, aLayerRects, aTextureRects, aRect.X(), ymid, aRect.XMost(),
+             aRect.YMost(), tl.x, 0.0f, br.x, br.y, flipped);
+    return 2;
+  }
+
+  if (xwrap && !ywrap) {
+    SetRects(0, aLayerRects, aTextureRects, aRect.X(), aRect.Y(), xmid,
+             aRect.YMost(), tl.x, tl.y, 1.0f, br.y, flipped);
+    SetRects(1, aLayerRects, aTextureRects, xmid, aRect.Y(), aRect.XMost(),
+             aRect.YMost(), 0.0f, tl.y, br.x, br.y, flipped);
+    return 2;
+  }
+
+  SetRects(0, aLayerRects, aTextureRects, aRect.X(), aRect.Y(), xmid, ymid,
+           tl.x, tl.y, 1.0f, 1.0f, flipped);
+  SetRects(1, aLayerRects, aTextureRects, xmid, aRect.Y(), aRect.XMost(), ymid,
+           0.0f, tl.y, br.x, 1.0f, flipped);
+  SetRects(2, aLayerRects, aTextureRects, aRect.X(), ymid, xmid, aRect.YMost(),
+           tl.x, 0.0f, 1.0f, br.y, flipped);
+  SetRects(3, aLayerRects, aTextureRects, xmid, ymid, aRect.XMost(),
+           aRect.YMost(), 0.0f, 0.0f, br.x, br.y, flipped);
+  return 4;
+}
+
+gfx::IntRect Compositor::ComputeBackdropCopyRect(
+    const gfx::Rect& aRect, const gfx::IntRect& aClipRect,
+    const gfx::Matrix4x4& aTransform, gfx::Matrix4x4* aOutTransform,
+    gfx::Rect* aOutLayerQuad) {
+  // Compute the clip.
+  RefPtr<CompositingRenderTarget> currentRenderTarget =
+      GetCurrentRenderTarget();
+  gfx::IntPoint rtOffset = currentRenderTarget->GetOrigin();
+  gfx::IntSize rtSize = currentRenderTarget->GetSize();
+
+  return layers::ComputeBackdropCopyRect(aRect, aClipRect, aTransform,
+                                         gfx::IntRect(rtOffset, rtSize),
+                                         aOutTransform, aOutLayerQuad);
+}
+
+gfx::IntRect Compositor::ComputeBackdropCopyRect(
+    const gfx::Triangle& aTriangle, const gfx::IntRect& aClipRect,
+    const gfx::Matrix4x4& aTransform, gfx::Matrix4x4* aOutTransform,
+    gfx::Rect* aOutLayerQuad) {
+  gfx::Rect boundingBox = aTriangle.BoundingBox();
+  return ComputeBackdropCopyRect(boundingBox, aClipRect, aTransform,
+                                 aOutTransform, aOutLayerQuad);
+}
+
+void Compositor::SetInvalid() { mParent = nullptr; }
+
+bool Compositor::IsValid() const { return !!mParent; }
+
+void Compositor::UnlockAfterComposition(TextureHost* aTexture) {
+  TextureSourceProvider::UnlockAfterComposition(aTexture);
+
+  // If this is being called after we shutdown the compositor, we must finish
+  // read unlocking now to prevent a cycle.
+  if (IsDestroyed()) {
+    ReadUnlockTextures();
+  }
+}
+
+bool Compositor::NotifyNotUsedAfterComposition(TextureHost* aTextureHost) {
+  if (IsDestroyed() || AsBasicCompositor()) {
+    return false;
+  }
+  return TextureSourceProvider::NotifyNotUsedAfterComposition(aTextureHost);
+}
+
+void Compositor::GetFrameStats(GPUStats* aStats) {
+  aStats->mInvalidPixels = mPixelsPerFrame;
+  aStats->mPixelsFilled = mPixelsFilled;
+}
+
+already_AddRefed<RecordedFrame> Compositor::RecordFrame(
+    const TimeStamp& aTimeStamp) {
+  RefPtr<CompositingRenderTarget> renderTarget = GetWindowRenderTarget();
+  if (!renderTarget) {
+    return nullptr;
+  }
+
+  RefPtr<AsyncReadbackBuffer> buffer =
+      CreateAsyncReadbackBuffer(renderTarget->GetSize());
+
+  if (!ReadbackRenderTarget(renderTarget, buffer)) {
+    return nullptr;
+  }
+
+  return MakeAndAddRef<CompositorRecordedFrame>(aTimeStamp, std::move(buffer));
+}
+
+bool Compositor::ShouldRecordFrames() const {
+#ifdef MOZ_GECKO_PROFILER
+  if (profiler_feature_active(ProfilerFeature::Screenshots)) {
+    return true;
+  }
+#endif
+  return mRecordFrames;
+}
+
+}  // namespace layers
+}  // namespace mozilla