Adding upstream version 86.0.1.upstream/86.0.1upstream

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

1 files changed, 460 insertions, 0 deletions

diff --git a/gfx/layers/composite/ContentHost.cpp b/gfx/layers/composite/ContentHost.cpp
new file mode 100644
index 0000000000..d4be5b0dc7
--- /dev/null
+++ b/gfx/layers/composite/ContentHost.cpp
@@ -0,0 +1,460 @@
+/* -*- 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/ContentHost.h"
+#include "gfx2DGlue.h"                      // for ContentForFormat
+#include "mozilla/gfx/Point.h"              // for IntSize
+#include "mozilla/Assertions.h"             // for MOZ_ASSERT, etc
+#include "mozilla/gfx/BaseRect.h"           // for BaseRect
+#include "mozilla/layers/Compositor.h"      // for Compositor
+#include "mozilla/layers/Effects.h"         // for TexturedEffect, Effect, etc
+#include "mozilla/layers/LayersMessages.h"  // for ThebesBufferData
+#include "nsAString.h"
+#include "nsPrintfCString.h"                // for nsPrintfCString
+#include "nsString.h"                       // for nsAutoCString
+#include "mozilla/layers/TextureHostOGL.h"  // for TextureHostOGL
+
+namespace mozilla {
+using namespace gfx;
+
+namespace layers {
+
+ContentHostBase::ContentHostBase(const TextureInfo& aTextureInfo)
+    : ContentHost(aTextureInfo), mInitialised(false) {}
+
+ContentHostBase::~ContentHostBase() = default;
+
+void ContentHostTexture::Composite(
+    Compositor* aCompositor, LayerComposite* aLayer, EffectChain& aEffectChain,
+    float aOpacity, const gfx::Matrix4x4& aTransform,
+    const SamplingFilter aSamplingFilter, const IntRect& aClipRect,
+    const nsIntRegion* aVisibleRegion, const Maybe<gfx::Polygon>& aGeometry) {
+  NS_ASSERTION(aVisibleRegion, "Requires a visible region");
+
+  AutoLockCompositableHost lock(this);
+  if (lock.Failed()) {
+    return;
+  }
+
+  if (!mTextureHost->BindTextureSource(mTextureSource)) {
+    return;
+  }
+  MOZ_ASSERT(mTextureSource.get());
+
+  if (!mTextureHostOnWhite) {
+    mTextureSourceOnWhite = nullptr;
+  }
+  if (mTextureHostOnWhite &&
+      !mTextureHostOnWhite->BindTextureSource(mTextureSourceOnWhite)) {
+    return;
+  }
+
+  RefPtr<TexturedEffect> effect = CreateTexturedEffect(
+      mTextureSource.get(), mTextureSourceOnWhite.get(), aSamplingFilter, true);
+  if (!effect) {
+    return;
+  }
+
+  aEffectChain.mPrimaryEffect = effect;
+
+  nsIntRegion tmpRegion;
+  const nsIntRegion* renderRegion;
+#ifndef MOZ_IGNORE_PAINT_WILL_RESAMPLE
+  if (PaintWillResample()) {
+    // If we're resampling, then the texture image will contain exactly the
+    // entire visible region's bounds, and we should draw it all in one quad
+    // to avoid unexpected aliasing.
+    tmpRegion = aVisibleRegion->GetBounds();
+    renderRegion = &tmpRegion;
+  } else {
+    renderRegion = aVisibleRegion;
+  }
+#else
+  renderRegion = aVisibleRegion;
+#endif
+
+  nsIntRegion region(*renderRegion);
+  nsIntPoint origin = GetOriginOffset();
+  // translate into TexImage space, buffer origin might not be at texture (0,0)
+  region.MoveBy(-origin);
+
+  // Figure out the intersecting draw region
+  gfx::IntSize texSize = mTextureSource->GetSize();
+  IntRect textureRect = IntRect(0, 0, texSize.width, texSize.height);
+  textureRect.MoveBy(region.GetBounds().TopLeft());
+  nsIntRegion subregion;
+  subregion.And(region, textureRect);
+  if (subregion.IsEmpty()) {
+    // Region is empty, nothing to draw
+    return;
+  }
+
+  nsIntRegion screenRects;
+  nsIntRegion regionRects;
+
+  // Collect texture/screen coordinates for drawing
+  for (auto iter = subregion.RectIter(); !iter.Done(); iter.Next()) {
+    IntRect regionRect = iter.Get();
+    IntRect screenRect = iter.Get();
+    screenRect.MoveBy(origin);
+
+    screenRects.Or(screenRects, screenRect);
+    regionRects.Or(regionRects, regionRect);
+  }
+
+  BigImageIterator* bigImgIter = mTextureSource->AsBigImageIterator();
+  BigImageIterator* iterOnWhite = nullptr;
+  if (bigImgIter) {
+    bigImgIter->BeginBigImageIteration();
+  }
+
+  if (mTextureSourceOnWhite) {
+    iterOnWhite = mTextureSourceOnWhite->AsBigImageIterator();
+    MOZ_ASSERT(!bigImgIter ||
+                   bigImgIter->GetTileCount() == iterOnWhite->GetTileCount(),
+               "Tile count mismatch on component alpha texture");
+    if (iterOnWhite) {
+      iterOnWhite->BeginBigImageIteration();
+    }
+  }
+
+  bool usingTiles = (bigImgIter && bigImgIter->GetTileCount() > 1);
+  do {
+    if (iterOnWhite && bigImgIter) {
+      MOZ_ASSERT(iterOnWhite->GetTileRect() == bigImgIter->GetTileRect(),
+                 "component alpha textures should be the same size.");
+    }
+
+    IntRect texRect = bigImgIter ? bigImgIter->GetTileRect()
+                                 : IntRect(0, 0, texSize.width, texSize.height);
+
+    // Draw texture. If we're using tiles, we do repeating manually, as texture
+    // repeat would cause each individual tile to repeat instead of the
+    // compound texture as a whole. This involves drawing at most 4 sections,
+    // 2 for each axis that has texture repeat.
+    for (int y = 0; y < (usingTiles ? 2 : 1); y++) {
+      for (int x = 0; x < (usingTiles ? 2 : 1); x++) {
+        IntRect currentTileRect(texRect);
+        currentTileRect.MoveBy(x * texSize.width, y * texSize.height);
+
+        for (auto screenIter = screenRects.RectIter(),
+                  regionIter = regionRects.RectIter();
+             !screenIter.Done() && !regionIter.Done();
+             screenIter.Next(), regionIter.Next()) {
+          const IntRect& screenRect = screenIter.Get();
+          const IntRect& regionRect = regionIter.Get();
+          IntRect tileScreenRect(screenRect);
+          IntRect tileRegionRect(regionRect);
+
+          // When we're using tiles, find the intersection between the tile
+          // rect and this region rect. Tiling is then handled by the
+          // outer for-loops and modifying the tile rect.
+          if (usingTiles) {
+            tileScreenRect.MoveBy(-origin);
+            tileScreenRect = tileScreenRect.Intersect(currentTileRect);
+            tileScreenRect.MoveBy(origin);
+
+            if (tileScreenRect.IsEmpty()) continue;
+
+            tileRegionRect = regionRect.Intersect(currentTileRect);
+            tileRegionRect.MoveBy(-currentTileRect.TopLeft());
+          }
+          gfx::Rect rect(tileScreenRect.X(), tileScreenRect.Y(),
+                         tileScreenRect.Width(), tileScreenRect.Height());
+
+          effect->mTextureCoords =
+              Rect(Float(tileRegionRect.X()) / texRect.Width(),
+                   Float(tileRegionRect.Y()) / texRect.Height(),
+                   Float(tileRegionRect.Width()) / texRect.Width(),
+                   Float(tileRegionRect.Height()) / texRect.Height());
+
+          aCompositor->DrawGeometry(rect, aClipRect, aEffectChain, aOpacity,
+                                    aTransform, aGeometry);
+
+          if (usingTiles) {
+            DiagnosticFlags diagnostics =
+                DiagnosticFlags::CONTENT | DiagnosticFlags::BIGIMAGE;
+            if (iterOnWhite) {
+              diagnostics |= DiagnosticFlags::COMPONENT_ALPHA;
+            }
+            aCompositor->DrawDiagnostics(diagnostics, rect, aClipRect,
+                                         aTransform, mFlashCounter);
+          }
+        }
+      }
+    }
+
+    if (iterOnWhite) {
+      iterOnWhite->NextTile();
+    }
+  } while (usingTiles && bigImgIter->NextTile());
+
+  if (bigImgIter) {
+    bigImgIter->EndBigImageIteration();
+  }
+  if (iterOnWhite) {
+    iterOnWhite->EndBigImageIteration();
+  }
+
+  DiagnosticFlags diagnostics = DiagnosticFlags::CONTENT;
+  if (iterOnWhite) {
+    diagnostics |= DiagnosticFlags::COMPONENT_ALPHA;
+  }
+  aCompositor->DrawDiagnostics(diagnostics, nsIntRegion(mBufferRect), aClipRect,
+                               aTransform, mFlashCounter);
+}
+
+RefPtr<TextureSource> ContentHostTexture::AcquireTextureSource() {
+  if (!mTextureHost || !mTextureHost->AcquireTextureSource(mTextureSource)) {
+    return nullptr;
+  }
+  return mTextureSource.get();
+}
+
+RefPtr<TextureSource> ContentHostTexture::AcquireTextureSourceOnWhite() {
+  if (!mTextureHostOnWhite ||
+      !mTextureHostOnWhite->AcquireTextureSource(mTextureSourceOnWhite)) {
+    return nullptr;
+  }
+  return mTextureSourceOnWhite.get();
+}
+
+void ContentHostTexture::UseTextureHost(
+    const nsTArray<TimedTexture>& aTextures) {
+  ContentHostBase::UseTextureHost(aTextures);
+  MOZ_ASSERT(aTextures.Length() == 1);
+  const TimedTexture& t = aTextures[0];
+  MOZ_ASSERT(t.mPictureRect.IsEqualInterior(
+                 nsIntRect(nsIntPoint(0, 0), nsIntSize(t.mTexture->GetSize()))),
+             "Only default picture rect supported");
+
+  if (t.mTexture != mTextureHost) {
+    mReceivedNewHost = true;
+  }
+
+  mTextureHost = t.mTexture;
+  mTextureHostOnWhite = nullptr;
+  mTextureSourceOnWhite = nullptr;
+  if (mTextureHost) {
+    mTextureHost->PrepareTextureSource(mTextureSource);
+  }
+}
+
+void ContentHostTexture::UseComponentAlphaTextures(
+    TextureHost* aTextureOnBlack, TextureHost* aTextureOnWhite) {
+  ContentHostBase::UseComponentAlphaTextures(aTextureOnBlack, aTextureOnWhite);
+  mTextureHost = aTextureOnBlack;
+  mTextureHostOnWhite = aTextureOnWhite;
+  if (mTextureHost) {
+    mTextureHost->PrepareTextureSource(mTextureSource);
+  }
+  if (mTextureHostOnWhite) {
+    mTextureHostOnWhite->PrepareTextureSource(mTextureSourceOnWhite);
+  }
+}
+
+void ContentHostTexture::SetTextureSourceProvider(
+    TextureSourceProvider* aProvider) {
+  ContentHostBase::SetTextureSourceProvider(aProvider);
+  if (mTextureHost) {
+    mTextureHost->SetTextureSourceProvider(aProvider);
+  }
+  if (mTextureHostOnWhite) {
+    mTextureHostOnWhite->SetTextureSourceProvider(aProvider);
+  }
+}
+
+void ContentHostTexture::Dump(std::stringstream& aStream, const char* aPrefix,
+                              bool aDumpHtml) {
+#ifdef MOZ_DUMP_PAINTING
+  if (aDumpHtml) {
+    aStream << "<ul>";
+  }
+  if (mTextureHost) {
+    aStream << aPrefix;
+    if (aDumpHtml) {
+      aStream << "<li> <a href=";
+    } else {
+      aStream << "Front buffer: ";
+    }
+    DumpTextureHost(aStream, mTextureHost);
+    if (aDumpHtml) {
+      aStream << "> Front buffer </a></li> ";
+    } else {
+      aStream << "\n";
+    }
+  }
+  if (mTextureHostOnWhite) {
+    aStream << aPrefix;
+    if (aDumpHtml) {
+      aStream << "<li> <a href=";
+    } else {
+      aStream << "Front buffer on white: ";
+    }
+    DumpTextureHost(aStream, mTextureHostOnWhite);
+    if (aDumpHtml) {
+      aStream << "> Front buffer on white </a> </li> ";
+    } else {
+      aStream << "\n";
+    }
+  }
+  if (aDumpHtml) {
+    aStream << "</ul>";
+  }
+#endif
+}
+
+static inline void AddWrappedRegion(const nsIntRegion& aInput,
+                                    nsIntRegion& aOutput, const IntSize& aSize,
+                                    const nsIntPoint& aShift) {
+  nsIntRegion tempRegion;
+  tempRegion.And(IntRect(aShift, aSize), aInput);
+  tempRegion.MoveBy(-aShift);
+  aOutput.Or(aOutput, tempRegion);
+}
+
+bool ContentHostSingleBuffered::UpdateThebes(
+    const ThebesBufferData& aData, const nsIntRegion& aUpdated,
+    const nsIntRegion& aOldValidRegionBack) {
+  if (!mTextureHost) {
+    mInitialised = false;
+    return true;  // FIXME should we return false? Returning true for now
+  }               // to preserve existing behavior of NOT causing IPC errors.
+
+  // updated is in screen coordinates. Convert it to buffer coordinates.
+  nsIntRegion destRegion(aUpdated);
+
+  if (mReceivedNewHost) {
+    destRegion.Or(destRegion, aOldValidRegionBack);
+    mReceivedNewHost = false;
+  }
+  destRegion.MoveBy(-aData.rect().TopLeft());
+
+  if (!aData.rect().Contains(aUpdated.GetBounds()) ||
+      aData.rotation().x > aData.rect().Width() ||
+      aData.rotation().y > aData.rect().Height()) {
+    NS_ERROR("Invalid update data");
+    return false;
+  }
+
+  // destRegion is now in logical coordinates relative to the buffer, but we
+  // need to account for rotation. We do that by moving the region to the
+  // rotation offset and then wrapping any pixels that extend off the
+  // bottom/right edges.
+
+  // Shift to the rotation point
+  destRegion.MoveBy(aData.rotation());
+
+  IntSize bufferSize = aData.rect().Size();
+
+  // Select only the pixels that are still within the buffer.
+  nsIntRegion finalRegion;
+  finalRegion.And(IntRect(IntPoint(), bufferSize), destRegion);
+
+  // For each of the overlap areas (right, bottom-right, bottom), select those
+  // pixels and wrap them around to the opposite edge of the buffer rect.
+  AddWrappedRegion(destRegion, finalRegion, bufferSize,
+                   nsIntPoint(aData.rect().Width(), 0));
+  AddWrappedRegion(destRegion, finalRegion, bufferSize,
+                   nsIntPoint(aData.rect().Width(), aData.rect().Height()));
+  AddWrappedRegion(destRegion, finalRegion, bufferSize,
+                   nsIntPoint(0, aData.rect().Height()));
+
+  MOZ_ASSERT(IntRect(0, 0, aData.rect().Width(), aData.rect().Height())
+                 .Contains(finalRegion.GetBounds()));
+
+  mTextureHost->Updated(&finalRegion);
+  if (mTextureHostOnWhite) {
+    mTextureHostOnWhite->Updated(&finalRegion);
+  }
+  mInitialised = true;
+
+  mBufferRect = aData.rect();
+  mBufferRotation = aData.rotation();
+
+  return true;
+}
+
+bool ContentHostDoubleBuffered::UpdateThebes(
+    const ThebesBufferData& aData, const nsIntRegion& aUpdated,
+    const nsIntRegion& aOldValidRegionBack) {
+  if (!mTextureHost) {
+    mInitialised = false;
+    return true;
+  }
+
+  // We don't need to calculate an update region because we assume that if we
+  // are using double buffering then we have render-to-texture and thus no
+  // upload to do.
+  mTextureHost->Updated();
+  if (mTextureHostOnWhite) {
+    mTextureHostOnWhite->Updated();
+  }
+  mInitialised = true;
+
+  mBufferRect = aData.rect();
+  mBufferRotation = aData.rotation();
+
+  // Save the current valid region of our front buffer, because if
+  // we're double buffering, it's going to be the valid region for the
+  // next back buffer sent back to the renderer.
+  //
+  // NB: we rely here on the fact that mValidRegion is initialized to
+  // empty, and that the first time Swap() is called we don't have a
+  // valid front buffer that we're going to return to content.
+  mValidRegionForNextBackBuffer = aOldValidRegionBack;
+
+  return true;
+}
+
+void ContentHostTexture::PrintInfo(std::stringstream& aStream,
+                                   const char* aPrefix) {
+  aStream << aPrefix;
+  aStream << nsPrintfCString("ContentHost (0x%p)", this).get()
+          << " [buffer-rect=" << mBufferRect << "]"
+          << " [buffer-rotation=" << mBufferRotation << "]";
+  if (PaintWillResample()) {
+    aStream << " [paint-will-resample]";
+  }
+
+  if (mTextureHost) {
+    nsAutoCString pfx(aPrefix);
+    pfx += "  ";
+
+    aStream << "\n";
+    mTextureHost->PrintInfo(aStream, pfx.get());
+  }
+}
+
+already_AddRefed<TexturedEffect> ContentHostTexture::GenEffect(
+    const gfx::SamplingFilter aSamplingFilter) {
+  if (!mTextureHost) {
+    return nullptr;
+  }
+  if (!mTextureHost->BindTextureSource(mTextureSource)) {
+    return nullptr;
+  }
+  if (!mTextureHostOnWhite) {
+    mTextureSourceOnWhite = nullptr;
+  }
+  if (mTextureHostOnWhite &&
+      !mTextureHostOnWhite->BindTextureSource(mTextureSourceOnWhite)) {
+    return nullptr;
+  }
+  return CreateTexturedEffect(mTextureSource.get(), mTextureSourceOnWhite.get(),
+                              aSamplingFilter, true);
+}
+
+already_AddRefed<gfx::DataSourceSurface> ContentHostTexture::GetAsSurface() {
+  if (!mTextureHost) {
+    return nullptr;
+  }
+
+  return mTextureHost->GetAsSurface();
+}
+
+}  // namespace layers
+}  // namespace mozilla