Add m-esr52 at 52.6.0

1 files changed, 245 insertions, 0 deletions

diff --git a/gfx/layers/basic/BasicPaintedLayer.cpp b/gfx/layers/basic/BasicPaintedLayer.cpp
new file mode 100644
index 000000000..7ce0c24af
--- /dev/null
+++ b/gfx/layers/basic/BasicPaintedLayer.cpp
@@ -0,0 +1,245 @@
+/* -*- 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 "BasicPaintedLayer.h"
+#include <stdint.h>                     // for uint32_t
+#include "GeckoProfiler.h"              // for PROFILER_LABEL
+#include "ReadbackLayer.h"              // for ReadbackLayer, ReadbackSink
+#include "ReadbackProcessor.h"          // for ReadbackProcessor::Update, etc
+#include "RenderTrace.h"                // for RenderTraceInvalidateEnd, etc
+#include "BasicLayersImpl.h"            // for AutoMaskData, etc
+#include "gfxContext.h"                 // for gfxContext, etc
+#include "gfxRect.h"                    // for gfxRect
+#include "gfxUtils.h"                   // for gfxUtils
+#include "mozilla/gfx/2D.h"             // for DrawTarget
+#include "mozilla/gfx/BaseRect.h"       // for BaseRect
+#include "mozilla/gfx/Matrix.h"         // for Matrix
+#include "mozilla/gfx/Rect.h"           // for Rect, IntRect
+#include "mozilla/gfx/Types.h"          // for Float, etc
+#include "mozilla/layers/LayersTypes.h"
+#include "nsCOMPtr.h"                   // for already_AddRefed
+#include "nsISupportsImpl.h"            // for gfxContext::Release, etc
+#include "nsPoint.h"                    // for nsIntPoint
+#include "nsRect.h"                     // for mozilla::gfx::IntRect
+#include "nsTArray.h"                   // for nsTArray, nsTArray_Impl
+#include "AutoMaskData.h"
+#include "gfx2DGlue.h"
+
+namespace mozilla {
+namespace layers {
+
+using namespace mozilla::gfx;
+
+static nsIntRegion
+IntersectWithClip(const nsIntRegion& aRegion, gfxContext* aContext)
+{
+  gfxRect clip = aContext->GetClipExtents();
+  nsIntRegion result;
+  result.And(aRegion, IntRect::RoundOut(clip.X(), clip.Y(),
+                                        clip.Width(), clip.Height()));
+  return result;
+}
+
+void
+BasicPaintedLayer::PaintThebes(gfxContext* aContext,
+                              Layer* aMaskLayer,
+                              LayerManager::DrawPaintedLayerCallback aCallback,
+                              void* aCallbackData)
+{
+  PROFILER_LABEL("BasicPaintedLayer", "PaintThebes",
+    js::ProfileEntry::Category::GRAPHICS);
+
+  NS_ASSERTION(BasicManager()->InDrawing(),
+               "Can only draw in drawing phase");
+
+  float opacity = GetEffectiveOpacity();
+  CompositionOp effectiveOperator = GetEffectiveOperator(this);
+
+  if (!BasicManager()->IsRetained()) {
+    mValidRegion.SetEmpty();
+    mContentClient->Clear();
+
+    nsIntRegion toDraw = IntersectWithClip(GetLocalVisibleRegion().ToUnknownRegion(), aContext);
+
+    RenderTraceInvalidateStart(this, "FFFF00", toDraw.GetBounds());
+
+    if (!toDraw.IsEmpty() && !IsHidden()) {
+      if (!aCallback) {
+        BasicManager()->SetTransactionIncomplete();
+        return;
+      }
+
+      aContext->Save();
+
+      bool needsGroup = opacity != 1.0 ||
+                        effectiveOperator != CompositionOp::OP_OVER ||
+                        aMaskLayer;
+      RefPtr<gfxContext> context = nullptr;
+      BasicLayerManager::PushedGroup group;
+      bool availableGroup = false;
+
+      if (needsGroup) {
+        availableGroup =
+            BasicManager()->PushGroupForLayer(aContext, this, toDraw, group);
+        if (availableGroup) {
+          context = group.mGroupTarget;
+        }
+      } else {
+        context = aContext;
+      }
+      if (context) {
+        SetAntialiasingFlags(this, context->GetDrawTarget());
+        aCallback(this, context, toDraw, toDraw, DrawRegionClip::NONE,
+                  nsIntRegion(), aCallbackData);
+      }
+      if (needsGroup && availableGroup) {
+        BasicManager()->PopGroupForLayer(group);
+      }
+
+      aContext->Restore();
+    }
+
+    RenderTraceInvalidateEnd(this, "FFFF00");
+    return;
+  }
+
+  if (BasicManager()->IsTransactionIncomplete())
+    return;
+
+  gfxRect clipExtents;
+  clipExtents = aContext->GetClipExtents();
+
+  // Pull out the mask surface and transform here, because the mask
+  // is internal to basic layers
+  AutoMoz2DMaskData mask;
+  SourceSurface* maskSurface = nullptr;
+  Matrix maskTransform;
+  if (GetMaskData(aMaskLayer, aContext->GetDeviceOffset(), &mask)) {
+    maskSurface = mask.GetSurface();
+    maskTransform = mask.GetTransform();
+  }
+
+  if (!IsHidden() && !clipExtents.IsEmpty()) {
+    mContentClient->DrawTo(this, aContext->GetDrawTarget(), opacity,
+                           effectiveOperator,
+                           maskSurface, &maskTransform);
+  }
+}
+
+void
+BasicPaintedLayer::Validate(LayerManager::DrawPaintedLayerCallback aCallback,
+                           void* aCallbackData,
+                           ReadbackProcessor* aReadback)
+{
+  if (!mContentClient) {
+    // This client will have a null Forwarder, which means it will not have
+    // a ContentHost on the other side.
+    mContentClient = new ContentClientBasic(mBackend);
+  }
+
+  if (!BasicManager()->IsRetained()) {
+    return;
+  }
+
+  nsTArray<ReadbackProcessor::Update> readbackUpdates;
+  if (aReadback && UsedForReadback()) {
+    aReadback->GetPaintedLayerUpdates(this, &readbackUpdates);
+  }
+
+  uint32_t flags = 0;
+#ifndef MOZ_WIDGET_ANDROID
+  if (BasicManager()->CompositorMightResample()) {
+    flags |= RotatedContentBuffer::PAINT_WILL_RESAMPLE;
+  }
+  if (!(flags & RotatedContentBuffer::PAINT_WILL_RESAMPLE)) {
+    if (MayResample()) {
+      flags |= RotatedContentBuffer::PAINT_WILL_RESAMPLE;
+    }
+  }
+#endif
+  if (mDrawAtomically) {
+    flags |= RotatedContentBuffer::PAINT_NO_ROTATION;
+  }
+  PaintState state =
+    mContentClient->BeginPaintBuffer(this, flags);
+  mValidRegion.Sub(mValidRegion, state.mRegionToInvalidate);
+
+  DrawTarget* target = mContentClient->BorrowDrawTargetForPainting(state);
+  if (target && target->IsValid()) {
+    // The area that became invalid and is visible needs to be repainted
+    // (this could be the whole visible area if our buffer switched
+    // from RGB to RGBA, because we might need to repaint with
+    // subpixel AA)
+    state.mRegionToInvalidate.And(state.mRegionToInvalidate,
+                                  GetLocalVisibleRegion().ToUnknownRegion());
+    SetAntialiasingFlags(this, target);
+
+    RenderTraceInvalidateStart(this, "FFFF00", state.mRegionToDraw.GetBounds());
+
+    RefPtr<gfxContext> ctx = gfxContext::CreatePreservingTransformOrNull(target);
+    MOZ_ASSERT(ctx); // already checked the target above
+
+    PaintBuffer(ctx,
+                state.mRegionToDraw, state.mRegionToDraw, state.mRegionToInvalidate,
+                state.mDidSelfCopy,
+                state.mClip,
+                aCallback, aCallbackData);
+    MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) PaintThebes", this));
+    Mutated();
+    ctx = nullptr;
+    mContentClient->ReturnDrawTargetToBuffer(target);
+    target = nullptr;
+
+    RenderTraceInvalidateEnd(this, "FFFF00");
+  } else {
+    if (target) {
+      mContentClient->ReturnDrawTargetToBuffer(target);
+      target = nullptr;
+    }
+
+    // It's possible that state.mRegionToInvalidate is nonempty here,
+    // if we are shrinking the valid region to nothing. So use mRegionToDraw
+    // instead.
+    NS_WARNING_ASSERTION(
+      state.mRegionToDraw.IsEmpty(),
+      "No context when we have something to draw, resource exhaustion?");
+  }
+
+  for (uint32_t i = 0; i < readbackUpdates.Length(); ++i) {
+    ReadbackProcessor::Update& update = readbackUpdates[i];
+    nsIntPoint offset = update.mLayer->GetBackgroundLayerOffset();
+    RefPtr<DrawTarget> dt =
+      update.mLayer->GetSink()->BeginUpdate(update.mUpdateRect + offset,
+                                            update.mSequenceCounter);
+    if (dt) {
+      NS_ASSERTION(GetEffectiveOpacity() == 1.0, "Should only read back opaque layers");
+      NS_ASSERTION(!GetMaskLayer(), "Should only read back layers without masks");
+      dt->SetTransform(dt->GetTransform().PreTranslate(offset.x, offset.y));
+      mContentClient->DrawTo(this, dt, 1.0, CompositionOp::OP_OVER,
+                             nullptr, nullptr);
+      update.mLayer->GetSink()->EndUpdate(update.mUpdateRect + offset);
+    }
+  }
+}
+
+already_AddRefed<PaintedLayer>
+BasicLayerManager::CreatePaintedLayer()
+{
+  NS_ASSERTION(InConstruction(), "Only allowed in construction phase");
+
+  BackendType backend = gfxPlatform::GetPlatform()->GetDefaultContentBackend();
+
+  if (mDefaultTarget) {
+    backend = mDefaultTarget->GetDrawTarget()->GetBackendType();
+  } else if (mType == BLM_WIDGET) {
+    backend = gfxPlatform::GetPlatform()->GetContentBackendFor(LayersBackend::LAYERS_BASIC);
+  }
+
+  RefPtr<PaintedLayer> layer = new BasicPaintedLayer(this, backend);
+  return layer.forget();
+}
+
+} // namespace layers
+} // namespace mozilla