gecko-dev/gfx/layers/basic/BasicPaintedLayer.cpp

/* -*- 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 "BasicPaintedLayer.h"
#include <stdint.h>                // for uint32_t
#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 "mozilla/ProfilerLabels.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) {
  AUTO_PROFILER_LABEL("BasicPaintedLayer::PaintThebes", GRAPHICS);

  NS_ASSERTION(BasicManager()->InDrawing(), "Can only draw in drawing phase");

  float opacity = GetEffectiveOpacity();
  CompositionOp effectiveOperator = GetEffectiveOperator(this);

  if (!BasicManager()->IsRetained()) {
    ClearValidRegion();
    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) {
        DrawTarget* target = context->GetDrawTarget();
        bool oldAA = target->GetPermitSubpixelAA();
        SetAntialiasingFlags(this, target);
        aCallback(this, context, toDraw, toDraw, DrawRegionClip::NONE,
                  nsIntRegion(), aCallbackData);
        target->SetPermitSubpixelAA(oldAA);
      }
      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 |= ContentClient::PAINT_WILL_RESAMPLE;
  }
  if (!(flags & ContentClient::PAINT_WILL_RESAMPLE)) {
    if (MayResample()) {
      flags |= ContentClient::PAINT_WILL_RESAMPLE;
    }
  }
#endif
  if (mDrawAtomically) {
    flags |= ContentClient::PAINT_NO_ROTATION;
  }
  PaintState state = mContentClient->BeginPaint(this, flags);
  SubtractFromValidRegion(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.mClip, aCallback,
                aCallbackData);
    MOZ_LAYERS_LOG_IF_SHADOWABLE(this,
                                 ("Layer::Mutated(%p) PaintThebes", this));
    Mutated();
    ctx = nullptr;
    mContentClient->ReturnDrawTarget(target);
    target = nullptr;

    RenderTraceInvalidateEnd(this, "FFFF00");
  } else {
    if (target) {
      mContentClient->ReturnDrawTarget(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