Commit d7a06601 authored by Iulian Moraru's avatar Iulian Moraru
Browse files

Backed out changeset 089962073382 (bug 1728903) for causing Bp-hybrid bustages...

Backed out changeset 089962073382 (bug 1728903) for causing Bp-hybrid bustages on ImageBitmapRenderingContext.cpp. CLOSED TREE
parent 9fb43c20
Loading
Loading
Loading
Loading
+48 −0
Original line number Diff line number Diff line
@@ -5364,6 +5364,49 @@ void CanvasRenderingContext2D::OnBeforePaintTransaction() {

void CanvasRenderingContext2D::OnDidPaintTransaction() { MarkContextClean(); }

already_AddRefed<Layer> CanvasRenderingContext2D::GetCanvasLayer(
    nsDisplayListBuilder* aBuilder, Layer* aOldLayer, LayerManager* aManager) {
  if (mOpaque) {
    // If we're opaque then make sure we have a surface so we paint black
    // instead of transparent.
    EnsureTarget();
  }

  // Don't call EnsureTarget() ... if there isn't already a surface, then
  // we have nothing to paint and there is no need to create a surface just
  // to paint nothing. Also, EnsureTarget() can cause creation of a persistent
  // layer manager which must NOT happen during a paint.
  if (!mBufferProvider && !IsTargetValid()) {
    // No DidTransactionCallback will be received, so mark the context clean
    // now so future invalidations will be dispatched.
    MarkContextClean();
    return nullptr;
  }

  if (!mResetLayer && aOldLayer) {
    RefPtr<Layer> ret = aOldLayer;
    return ret.forget();
  }

  RefPtr<CanvasLayer> canvasLayer = aManager->CreateCanvasLayer();
  if (!canvasLayer) {
    NS_WARNING("CreateCanvasLayer returned null!");
    // No DidTransactionCallback will be received, so mark the context clean
    // now so future invalidations will be dispatched.
    MarkContextClean();
    return nullptr;
  }

  const auto canvasRenderer = canvasLayer->CreateOrGetCanvasRenderer();
  InitializeCanvasRenderer(aBuilder, canvasRenderer);
  uint32_t flags = mOpaque ? Layer::CONTENT_OPAQUE : 0;
  canvasLayer->SetContentFlags(flags);

  mResetLayer = false;

  return canvasLayer.forget();
}

bool CanvasRenderingContext2D::UpdateWebRenderCanvasData(
    nsDisplayListBuilder* aBuilder, WebRenderCanvasData* aCanvasData) {
  if (mOpaque) {
@@ -5448,6 +5491,11 @@ bool CanvasRenderingContext2D::IsContextCleanForFrameCapture() {
  return !mIsCapturedFrameInvalid;
}

bool CanvasRenderingContext2D::ShouldForceInactiveLayer(
    LayerManager* aManager) {
  return !aManager->CanUseCanvasLayerForSize(GetSize());
}

void CanvasRenderingContext2D::GetAppUnitsValues(int32_t* aPerDevPixel,
                                                 int32_t* aPerCSSPixel) {
  // If we don't have a canvas element, we just return something generic.
+4 −0
Original line number Diff line number Diff line
@@ -422,12 +422,16 @@ class CanvasRenderingContext2D final : public nsICanvasRenderingContextInternal,
  virtual void SetOpaqueValueFromOpaqueAttr(bool aOpaqueAttrValue) override;
  bool GetIsOpaque() override { return mOpaque; }
  NS_IMETHOD Reset() override;
  already_AddRefed<Layer> GetCanvasLayer(nsDisplayListBuilder* aBuilder,
                                         Layer* aOldLayer,
                                         LayerManager* aManager) override;

  bool UpdateWebRenderCanvasData(nsDisplayListBuilder* aBuilder,
                                 WebRenderCanvasData* aCanvasData) override;

  bool InitializeCanvasRenderer(nsDisplayListBuilder* aBuilder,
                                CanvasRenderer* aRenderer) override;
  virtual bool ShouldForceInactiveLayer(LayerManager* aManager) override;
  void MarkContextClean() override;
  void MarkContextCleanForFrameCapture() override;
  bool IsContextCleanForFrameCapture() override;
+26 −0
Original line number Diff line number Diff line
@@ -386,6 +386,32 @@ void ClientWebGLContext::ClearVRSwapChain() { Run<RPROC(ClearVRSwapChain)>(); }

// -

already_AddRefed<layers::Layer> ClientWebGLContext::GetCanvasLayer(
    nsDisplayListBuilder* builder, Layer* oldLayer, LayerManager* manager) {
  if (!mResetLayer && oldLayer) {
    RefPtr<layers::Layer> ret = oldLayer;
    return ret.forget();
  }

  RefPtr<CanvasLayer> canvasLayer = manager->CreateCanvasLayer();
  if (!canvasLayer) {
    NS_WARNING("CreateCanvasLayer returned null!");
    return nullptr;
  }

  const auto canvasRenderer = canvasLayer->CreateOrGetCanvasRenderer();
  if (!InitializeCanvasRenderer(builder, canvasRenderer)) return nullptr;

  uint32_t flags = 0;
  if (GetIsOpaque()) {
    flags |= Layer::CONTENT_OPAQUE;
  }
  canvasLayer->SetContentFlags(flags);

  mResetLayer = false;
  return canvasLayer.forget();
}

bool ClientWebGLContext::UpdateWebRenderCanvasData(
    nsDisplayListBuilder* aBuilder, WebRenderCanvasData* aCanvasData) {
  CanvasRenderer* renderer = aCanvasData->GetCanvasRenderer();
+3 −0
Original line number Diff line number Diff line
@@ -909,6 +909,9 @@ class ClientWebGLContext final : public nsICanvasRenderingContextInternal,
  // nsICanvasRenderingContextInternal / nsAPostRefreshObserver
  // -------------------------------------------------------------------------
 public:
  already_AddRefed<layers::Layer> GetCanvasLayer(
      nsDisplayListBuilder* builder, layers::Layer* oldLayer,
      layers::LayerManager* manager) override;
  bool InitializeCanvasRenderer(nsDisplayListBuilder* aBuilder,
                                layers::CanvasRenderer* aRenderer) override;
  // Note that 'clean' here refers to its invalidation state, not the
+35 −2
Original line number Diff line number Diff line
@@ -4,11 +4,10 @@
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "ImageBitmapRenderingContext.h"
#include "gfxPlatform.h"
#include "mozilla/dom/ImageBitmapRenderingContextBinding.h"
#include "nsComponentManagerUtils.h"
#include "nsRegion.h"
#include "ImageContainer.h"
#include "ImageLayers.h"

namespace mozilla::dom {

@@ -199,6 +198,40 @@ ImageBitmapRenderingContext::Reset() {
  return NS_OK;
}

already_AddRefed<layers::Layer> ImageBitmapRenderingContext::GetCanvasLayer(
    nsDisplayListBuilder* aBuilder, Layer* aOldLayer, LayerManager* aManager) {
  if (!mImage) {
    // No DidTransactionCallback will be received, so mark the context clean
    // now so future invalidations will be dispatched.
    MarkContextClean();
    return nullptr;
  }

  RefPtr<layers::ImageLayer> imageLayer;

  if (aOldLayer) {
    imageLayer = static_cast<layers::ImageLayer*>(aOldLayer);
  } else {
    imageLayer = aManager->CreateImageLayer();
  }

  RefPtr<layers::ImageContainer> imageContainer = imageLayer->GetContainer();
  if (!imageContainer) {
    imageContainer = LayerManager::CreateImageContainer();
    imageLayer->SetContainer(imageContainer);
  }

  AutoTArray<layers::ImageContainer::NonOwningImage, 1> imageList;
  RefPtr<layers::Image> image = ClipToIntrinsicSize();
  if (!image) {
    return nullptr;
  }
  imageList.AppendElement(layers::ImageContainer::NonOwningImage(image));
  imageContainer->SetCurrentImages(imageList);

  return imageLayer.forget();
}

bool ImageBitmapRenderingContext::UpdateWebRenderCanvasData(
    nsDisplayListBuilder* aBuilder, WebRenderCanvasData* aCanvasData) {
  if (!mImage) {
Loading