Add m-esr52 at 52.6.0

1 files changed, 531 insertions, 0 deletions

diff --git a/gfx/layers/client/CanvasClient.cpp b/gfx/layers/client/CanvasClient.cpp
new file mode 100644
index 000000000..40513984e
--- /dev/null
+++ b/gfx/layers/client/CanvasClient.cpp
@@ -0,0 +1,531 @@
+/* -*- Mode: C++; tab-width: 20; 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 "CanvasClient.h"
+
+#include "ClientCanvasLayer.h"          // for ClientCanvasLayer
+#include "GLContext.h"                  // for GLContext
+#include "GLScreenBuffer.h"             // for GLScreenBuffer
+#include "ScopedGLHelpers.h"
+#include "gfx2DGlue.h"                  // for ImageFormatToSurfaceFormat
+#include "gfxPlatform.h"                // for gfxPlatform
+#include "GLReadTexImageHelper.h"
+#include "mozilla/gfx/BaseSize.h"       // for BaseSize
+#include "mozilla/layers/BufferTexture.h"
+#include "mozilla/layers/AsyncCanvasRenderer.h"
+#include "mozilla/layers/CompositableForwarder.h"
+#include "mozilla/layers/CompositorBridgeChild.h" // for CompositorBridgeChild
+#include "mozilla/layers/LayersTypes.h"
+#include "mozilla/layers/TextureClient.h"  // for TextureClient, etc
+#include "mozilla/layers/TextureClientOGL.h"
+#include "nsDebug.h"                    // for printf_stderr, NS_ASSERTION
+#include "nsXULAppAPI.h"                // for XRE_GetProcessType, etc
+#include "TextureClientSharedSurface.h"
+
+using namespace mozilla::gfx;
+using namespace mozilla::gl;
+
+namespace mozilla {
+namespace layers {
+
+/* static */ already_AddRefed<CanvasClient>
+CanvasClient::CreateCanvasClient(CanvasClientType aType,
+                                 CompositableForwarder* aForwarder,
+                                 TextureFlags aFlags)
+{
+  switch (aType) {
+  case CanvasClientTypeShSurf:
+    return MakeAndAddRef<CanvasClientSharedSurface>(aForwarder, aFlags);
+  case CanvasClientAsync:
+    return MakeAndAddRef<CanvasClientBridge>(aForwarder, aFlags);
+  default:
+    return MakeAndAddRef<CanvasClient2D>(aForwarder, aFlags);
+    break;
+  }
+}
+
+void
+CanvasClientBridge::UpdateAsync(AsyncCanvasRenderer* aRenderer)
+{
+  if (!GetForwarder() || !mLayer || !aRenderer ||
+      !aRenderer->GetCanvasClient()) {
+    return;
+  }
+
+  uint64_t asyncID = aRenderer->GetCanvasClientAsyncID();
+  if (asyncID == 0 || mAsyncID == asyncID) {
+    return;
+  }
+
+  static_cast<ShadowLayerForwarder*>(GetForwarder())
+    ->AttachAsyncCompositable(asyncID, mLayer);
+  mAsyncID = asyncID;
+}
+
+void
+CanvasClient2D::UpdateFromTexture(TextureClient* aTexture)
+{
+  MOZ_ASSERT(aTexture);
+
+  if (!aTexture->IsSharedWithCompositor()) {
+    if (!AddTextureClient(aTexture)) {
+      return;
+    }
+  }
+
+  mBackBuffer = nullptr;
+  mFrontBuffer = nullptr;
+  mBufferProviderTexture = aTexture;
+
+  AutoTArray<CompositableForwarder::TimedTextureClient,1> textures;
+  CompositableForwarder::TimedTextureClient* t = textures.AppendElement();
+  t->mTextureClient = aTexture;
+  t->mPictureRect = nsIntRect(nsIntPoint(0, 0), aTexture->GetSize());
+  t->mFrameID = mFrameID;
+
+  GetForwarder()->UseTextures(this, textures);
+  aTexture->SyncWithObject(GetForwarder()->GetSyncObject());
+}
+
+void
+CanvasClient2D::Update(gfx::IntSize aSize, ClientCanvasLayer* aLayer)
+{
+  mBufferProviderTexture = nullptr;
+
+  AutoRemoveTexture autoRemove(this);
+  if (mBackBuffer && (mBackBuffer->IsReadLocked() || mBackBuffer->GetSize() != aSize)) {
+    autoRemove.mTexture = mBackBuffer;
+    mBackBuffer = nullptr;
+  }
+
+  bool bufferCreated = false;
+  if (!mBackBuffer) {
+    bool isOpaque = (aLayer->GetContentFlags() & Layer::CONTENT_OPAQUE);
+    gfxContentType contentType = isOpaque
+                                                ? gfxContentType::COLOR
+                                                : gfxContentType::COLOR_ALPHA;
+    gfx::SurfaceFormat surfaceFormat
+      = gfxPlatform::GetPlatform()->Optimal2DFormatForContent(contentType);
+    TextureFlags flags = TextureFlags::DEFAULT;
+    if (mTextureFlags & TextureFlags::ORIGIN_BOTTOM_LEFT) {
+      flags |= TextureFlags::ORIGIN_BOTTOM_LEFT;
+    }
+
+    mBackBuffer = CreateTextureClientForCanvas(surfaceFormat, aSize, flags, aLayer);
+    if (!mBackBuffer) {
+      NS_WARNING("Failed to allocate the TextureClient");
+      return;
+    }
+    mBackBuffer->EnableReadLock();
+    MOZ_ASSERT(mBackBuffer->CanExposeDrawTarget());
+
+    bufferCreated = true;
+  }
+
+  bool updated = false;
+  {
+    TextureClientAutoLock autoLock(mBackBuffer, OpenMode::OPEN_WRITE_ONLY);
+    if (!autoLock.Succeeded()) {
+      mBackBuffer = nullptr;
+      return;
+    }
+
+    RefPtr<DrawTarget> target = mBackBuffer->BorrowDrawTarget();
+    if (target) {
+      if (!aLayer->UpdateTarget(target)) {
+        NS_WARNING("Failed to copy the canvas into a TextureClient.");
+        return;
+      }
+      updated = true;
+    }
+  }
+
+  if (bufferCreated && !AddTextureClient(mBackBuffer)) {
+    mBackBuffer = nullptr;
+    return;
+  }
+
+  if (updated) {
+    AutoTArray<CompositableForwarder::TimedTextureClient,1> textures;
+    CompositableForwarder::TimedTextureClient* t = textures.AppendElement();
+    t->mTextureClient = mBackBuffer;
+    t->mPictureRect = nsIntRect(nsIntPoint(0, 0), mBackBuffer->GetSize());
+    t->mFrameID = mFrameID;
+    GetForwarder()->UseTextures(this, textures);
+    mBackBuffer->SyncWithObject(GetForwarder()->GetSyncObject());
+  }
+
+  mBackBuffer.swap(mFrontBuffer);
+}
+
+already_AddRefed<TextureClient>
+CanvasClient2D::CreateTextureClientForCanvas(gfx::SurfaceFormat aFormat,
+                                             gfx::IntSize aSize,
+                                             TextureFlags aFlags,
+                                             ClientCanvasLayer* aLayer)
+{
+  if (aLayer->IsGLLayer()) {
+    // We want a cairo backend here as we don't want to be copying into
+    // an accelerated backend and we like LockBits to work. This is currently
+    // the most effective way to make this work.
+    return TextureClient::CreateForRawBufferAccess(GetForwarder(),
+                                                   aFormat, aSize, BackendType::CAIRO,
+                                                   mTextureFlags | aFlags);
+  }
+
+#ifdef XP_WIN
+  return CreateTextureClientForDrawing(aFormat, aSize, BackendSelector::Canvas, aFlags);
+#else
+  // XXX - We should use CreateTextureClientForDrawing, but we first need
+  // to use double buffering.
+  gfx::BackendType backend = gfxPlatform::GetPlatform()->GetPreferredCanvasBackend();
+  return TextureClient::CreateForRawBufferAccess(GetForwarder(),
+                                                 aFormat, aSize, backend,
+                                                 mTextureFlags | aFlags);
+#endif
+}
+
+////////////////////////////////////////////////////////////////////////
+
+CanvasClientSharedSurface::CanvasClientSharedSurface(CompositableForwarder* aLayerForwarder,
+                                                     TextureFlags aFlags)
+  : CanvasClient(aLayerForwarder, aFlags)
+{ }
+
+CanvasClientSharedSurface::~CanvasClientSharedSurface()
+{
+  ClearSurfaces();
+}
+
+////////////////////////////////////////
+// Readback
+
+// For formats compatible with R8G8B8A8.
+static inline void SwapRB_R8G8B8A8(uint8_t* pixel) {
+  // [RR, GG, BB, AA]
+  Swap(pixel[0], pixel[2]);
+}
+
+class TexClientFactory
+{
+  CompositableForwarder* const mAllocator;
+  const bool mHasAlpha;
+  const gfx::IntSize mSize;
+  const gfx::BackendType mBackendType;
+  const TextureFlags mBaseTexFlags;
+  const LayersBackend mLayersBackend;
+
+public:
+  TexClientFactory(CompositableForwarder* allocator, bool hasAlpha,
+                   const gfx::IntSize& size, gfx::BackendType backendType,
+                   TextureFlags baseTexFlags, LayersBackend layersBackend)
+    : mAllocator(allocator)
+    , mHasAlpha(hasAlpha)
+    , mSize(size)
+    , mBackendType(backendType)
+    , mBaseTexFlags(baseTexFlags)
+    , mLayersBackend(layersBackend)
+  {
+  }
+
+protected:
+  already_AddRefed<TextureClient> Create(gfx::SurfaceFormat format) {
+    return TextureClient::CreateForRawBufferAccess(mAllocator, format,
+                                                   mSize, mBackendType,
+                                                   mBaseTexFlags);
+  }
+
+public:
+  already_AddRefed<TextureClient> CreateB8G8R8AX8() {
+    gfx::SurfaceFormat format = mHasAlpha ? gfx::SurfaceFormat::B8G8R8A8
+                                          : gfx::SurfaceFormat::B8G8R8X8;
+    return Create(format);
+  }
+
+  already_AddRefed<TextureClient> CreateR8G8B8AX8() {
+    RefPtr<TextureClient> ret;
+
+    bool areRGBAFormatsBroken = mLayersBackend == LayersBackend::LAYERS_BASIC;
+    if (!areRGBAFormatsBroken) {
+      gfx::SurfaceFormat format = mHasAlpha ? gfx::SurfaceFormat::R8G8B8A8
+                                            : gfx::SurfaceFormat::R8G8B8X8;
+      ret = Create(format);
+    }
+
+    if (!ret) {
+      ret = CreateB8G8R8AX8();
+      if (ret) {
+        ret->AddFlags(TextureFlags::RB_SWAPPED);
+      }
+    }
+
+    return ret.forget();
+  }
+};
+
+static already_AddRefed<TextureClient>
+TexClientFromReadback(SharedSurface* src, CompositableForwarder* allocator,
+                      TextureFlags baseFlags, LayersBackend layersBackend)
+{
+  auto backendType = gfx::BackendType::CAIRO;
+  TexClientFactory factory(allocator, src->mHasAlpha, src->mSize, backendType,
+                           baseFlags, layersBackend);
+
+  RefPtr<TextureClient> texClient;
+
+  {
+    gl::ScopedReadbackFB autoReadback(src);
+
+    // We have a source FB, now we need a format.
+    GLenum destFormat = LOCAL_GL_BGRA;
+    GLenum destType = LOCAL_GL_UNSIGNED_BYTE;
+    GLenum readFormat;
+    GLenum readType;
+
+    // We actually don't care if they match, since we can handle
+    // any read{Format,Type} we get.
+    auto gl = src->mGL;
+    GetActualReadFormats(gl, destFormat, destType, &readFormat, &readType);
+
+    MOZ_ASSERT(readFormat == LOCAL_GL_RGBA ||
+               readFormat == LOCAL_GL_BGRA);
+    MOZ_ASSERT(readType == LOCAL_GL_UNSIGNED_BYTE);
+
+    // With a format and type, we can create texClient.
+    if (readFormat == LOCAL_GL_BGRA &&
+        readType == LOCAL_GL_UNSIGNED_BYTE)
+    {
+      // 0xAARRGGBB
+      // In Lendian: [BB, GG, RR, AA]
+      texClient = factory.CreateB8G8R8AX8();
+
+    } else if (readFormat == LOCAL_GL_RGBA &&
+               readType == LOCAL_GL_UNSIGNED_BYTE)
+    {
+      // [RR, GG, BB, AA]
+      texClient = factory.CreateR8G8B8AX8();
+    } else {
+      MOZ_CRASH("GFX: Bad `read{Format,Type}`.");
+    }
+
+    MOZ_ASSERT(texClient);
+    if (!texClient)
+      return nullptr;
+
+    // With a texClient, we can lock for writing.
+    TextureClientAutoLock autoLock(texClient, OpenMode::OPEN_WRITE);
+    DebugOnly<bool> succeeded = autoLock.Succeeded();
+    MOZ_ASSERT(succeeded, "texture should have locked");
+
+    MappedTextureData mapped;
+    texClient->BorrowMappedData(mapped);
+
+    // ReadPixels from the current FB into mapped.data.
+    auto width = src->mSize.width;
+    auto height = src->mSize.height;
+
+    {
+      ScopedPackState scopedPackState(gl);
+
+      MOZ_ASSERT(mapped.stride/4 == mapped.size.width);
+      gl->raw_fReadPixels(0, 0, width, height, readFormat, readType, mapped.data);
+    }
+
+    // RB_SWAPPED doesn't work with D3D11. (bug 1051010)
+    // RB_SWAPPED doesn't work with Basic. (bug ???????)
+    // RB_SWAPPED doesn't work with D3D9. (bug ???????)
+    bool layersNeedsManualSwap = layersBackend == LayersBackend::LAYERS_BASIC ||
+                                 layersBackend == LayersBackend::LAYERS_D3D9 ||
+                                 layersBackend == LayersBackend::LAYERS_D3D11;
+    if (texClient->HasFlags(TextureFlags::RB_SWAPPED) &&
+        layersNeedsManualSwap)
+    {
+      size_t pixels = width * height;
+      uint8_t* itr = mapped.data;
+      for (size_t i = 0; i < pixels; i++) {
+        SwapRB_R8G8B8A8(itr);
+        itr += 4;
+      }
+
+      texClient->RemoveFlags(TextureFlags::RB_SWAPPED);
+    }
+  }
+
+  return texClient.forget();
+}
+
+////////////////////////////////////////
+
+static already_AddRefed<SharedSurfaceTextureClient>
+CloneSurface(gl::SharedSurface* src, gl::SurfaceFactory* factory)
+{
+    RefPtr<SharedSurfaceTextureClient> dest = factory->NewTexClient(src->mSize);
+    if (!dest) {
+      return nullptr;
+    }
+
+    gl::SharedSurface* destSurf = dest->Surf();
+
+    destSurf->ProducerAcquire();
+    SharedSurface::ProdCopy(src, dest->Surf(), factory);
+    destSurf->ProducerRelease();
+
+    return dest.forget();
+}
+
+void
+CanvasClientSharedSurface::Update(gfx::IntSize aSize, ClientCanvasLayer* aLayer)
+{
+  Renderer renderer;
+  renderer.construct<ClientCanvasLayer*>(aLayer);
+  UpdateRenderer(aSize, renderer);
+}
+
+void
+CanvasClientSharedSurface::UpdateAsync(AsyncCanvasRenderer* aRenderer)
+{
+  Renderer renderer;
+  renderer.construct<AsyncCanvasRenderer*>(aRenderer);
+  UpdateRenderer(aRenderer->GetSize(), renderer);
+}
+
+void
+CanvasClientSharedSurface::UpdateRenderer(gfx::IntSize aSize, Renderer& aRenderer)
+{
+  GLContext* gl = nullptr;
+  ClientCanvasLayer* layer = nullptr;
+  AsyncCanvasRenderer* asyncRenderer = nullptr;
+  if (aRenderer.constructed<ClientCanvasLayer*>()) {
+    layer = aRenderer.ref<ClientCanvasLayer*>();
+    gl = layer->mGLContext;
+  } else {
+    asyncRenderer = aRenderer.ref<AsyncCanvasRenderer*>();
+    gl = asyncRenderer->mGLContext;
+  }
+  gl->MakeCurrent();
+
+  RefPtr<TextureClient> newFront;
+
+  if (layer && layer->mGLFrontbuffer) {
+    mShSurfClient = CloneSurface(layer->mGLFrontbuffer.get(), layer->mFactory.get());
+    if (!mShSurfClient) {
+      gfxCriticalError() << "Invalid canvas front buffer";
+      return;
+    }
+  } else if (layer && layer->mIsMirror) {
+    mShSurfClient = CloneSurface(gl->Screen()->Front()->Surf(), layer->mFactory.get());
+    if (!mShSurfClient) {
+      return;
+    }
+  } else {
+    mShSurfClient = gl->Screen()->Front();
+    if (mShSurfClient && mShSurfClient->GetAllocator() &&
+        mShSurfClient->GetAllocator() != GetForwarder()->GetTextureForwarder()) {
+      mShSurfClient = CloneSurface(mShSurfClient->Surf(), gl->Screen()->Factory());
+    }
+    if (!mShSurfClient) {
+      return;
+    }
+  }
+  MOZ_ASSERT(mShSurfClient);
+
+  newFront = mShSurfClient;
+
+  SharedSurface* surf = mShSurfClient->Surf();
+
+  // Readback if needed.
+  mReadbackClient = nullptr;
+
+  auto forwarder = GetForwarder();
+
+  bool needsReadback = (surf->mType == SharedSurfaceType::Basic);
+  if (needsReadback) {
+    TextureFlags flags = TextureFlags::IMMUTABLE;
+
+    CompositableForwarder* shadowForwarder = nullptr;
+    if (layer) {
+      flags |= layer->Flags();
+      shadowForwarder = layer->ClientManager()->AsShadowForwarder();
+    } else {
+      MOZ_ASSERT(asyncRenderer);
+      flags |= mTextureFlags;
+      shadowForwarder = GetForwarder();
+    }
+
+    auto layersBackend = shadowForwarder->GetCompositorBackendType();
+    mReadbackClient = TexClientFromReadback(surf, forwarder, flags, layersBackend);
+
+    newFront = mReadbackClient;
+  } else {
+    mReadbackClient = nullptr;
+  }
+
+  if (asyncRenderer) {
+    // If surface type is Basic, above codes will readback
+    // the GLContext to mReadbackClient in order to send frame to
+    // compositor. We copy from this TextureClient directly by
+    // calling CopyFromTextureClient().
+    // Therefore, if main-thread want the content of GLContext,
+    // it doesn't have to readback from GLContext again.
+    //
+    // Otherwise, if surface type isn't Basic, we will read from
+    // SharedSurface directly from main-thread. We still pass
+    // mReadbackClient which is nullptr here to tell
+    // AsyncCanvasRenderer reset some properties.
+    asyncRenderer->CopyFromTextureClient(mReadbackClient);
+  }
+
+  MOZ_ASSERT(newFront);
+  if (!newFront) {
+    // May happen in a release build in case of memory pressure.
+    gfxCriticalError() << "Failed to allocate a TextureClient for SharedSurface Canvas. Size: " << aSize;
+    return;
+  }
+
+  mNewFront = newFront;
+}
+
+void
+CanvasClientSharedSurface::Updated()
+{
+  if (!mNewFront) {
+    return;
+  }
+
+  auto forwarder = GetForwarder();
+
+  mFront = mNewFront;
+  mNewFront = nullptr;
+
+  // Add the new TexClient.
+  MOZ_ALWAYS_TRUE( AddTextureClient(mFront) );
+
+  AutoTArray<CompositableForwarder::TimedTextureClient,1> textures;
+  CompositableForwarder::TimedTextureClient* t = textures.AppendElement();
+  t->mTextureClient = mFront;
+  t->mPictureRect = nsIntRect(nsIntPoint(0, 0), mFront->GetSize());
+  t->mFrameID = mFrameID;
+  forwarder->UseTextures(this, textures);
+}
+
+void
+CanvasClientSharedSurface::OnDetach() {
+  ClearSurfaces();
+}
+
+void
+CanvasClientSharedSurface::ClearSurfaces()
+{
+  if (mFront) {
+    mFront->CancelWaitForRecycle();
+  }
+  mFront = nullptr;
+  mNewFront = nullptr;
+  mShSurfClient = nullptr;
+  mReadbackClient = nullptr;
+}
+
+} // namespace layers
+} // namespace mozilla