/* -*- 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 "BasicContainerLayer.h"
#include <sys/types.h>             // for int32_t
#include "BasicLayersImpl.h"       // for ToData
#include "basic/BasicImplData.h"   // for BasicImplData
#include "basic/BasicLayers.h"     // for BasicLayerManager
#include "mozilla/gfx/BaseRect.h"  // for BaseRect
#include "mozilla/mozalloc.h"      // for operator new
#include "nsCOMPtr.h"              // for already_AddRefed
#include "nsISupportsImpl.h"       // for Layer::AddRef, etc
#include "nsPoint.h"               // for nsIntPoint
#include "nsRegion.h"              // for nsIntRegion
#include "ReadbackProcessor.h"

using namespace mozilla::gfx;

namespace mozilla {
namespace layers {

BasicContainerLayer::~BasicContainerLayer() {
  ContainerLayer::RemoveAllChildren();
  MOZ_COUNT_DTOR(BasicContainerLayer);
}

void BasicContainerLayer::ComputeEffectiveTransforms(
    const Matrix4x4& aTransformToSurface) {
  // We push groups for container layers if we need to, which always
  // are aligned in device space, so it doesn't really matter how we snap
  // containers.
  Matrix residual;
  Matrix4x4 transformToSurface = aTransformToSurface;
  bool participate3DCtx = Extend3DContext() || Is3DContextLeaf();
  if (!participate3DCtx && GetContentFlags() & CONTENT_BACKFACE_HIDDEN) {
    // For backface-hidden layers
    transformToSurface.ProjectTo2D();
  }
  Matrix4x4 idealTransform = GetLocalTransform() * transformToSurface;
  if (!participate3DCtx && !(GetContentFlags() & CONTENT_BACKFACE_HIDDEN)) {
    // For non-backface-hidden layers,
    // 3D components are required to handle CONTENT_BACKFACE_HIDDEN.
    idealTransform.ProjectTo2D();
  }

  if (!idealTransform.CanDraw2D()) {
    if (!Extend3DContext()) {
      mEffectiveTransform = idealTransform;
      ComputeEffectiveTransformsForChildren(Matrix4x4());
      ComputeEffectiveTransformForMaskLayers(Matrix4x4());
      mUseIntermediateSurface = true;
      return;
    }

    mEffectiveTransform = idealTransform;
    ComputeEffectiveTransformsForChildren(idealTransform);
    ComputeEffectiveTransformForMaskLayers(idealTransform);
    mUseIntermediateSurface = false;
    return;
  }

  // With 2D transform or extended 3D context.

  Layer* child = GetFirstChild();
  bool hasSingleBlendingChild = false;
  if (!HasMultipleChildren() && child) {
    hasSingleBlendingChild = child->GetMixBlendMode() != CompositionOp::OP_OVER;
  }

  /* If we have a single childand it is not blending,, it can just inherit our
   * opacity, otherwise we need a PushGroup and we need to mark ourselves as
   * using an intermediate surface so our children don't inherit our opacity via
   * GetEffectiveOpacity. Having a mask layer always forces our own push group
   * Having a blend mode also always forces our own push group
   */
  mUseIntermediateSurface =
      GetMaskLayer() || GetForceIsolatedGroup() ||
      (GetMixBlendMode() != CompositionOp::OP_OVER && HasMultipleChildren()) ||
      (GetEffectiveOpacity() != 1.0 &&
       ((HasMultipleChildren() && !Extend3DContext()) ||
        hasSingleBlendingChild));

  mEffectiveTransform =
      !mUseIntermediateSurface
          ? idealTransform
          : (!(GetContentFlags() & CONTENT_BACKFACE_HIDDEN)
                 ? SnapTransformTranslation(idealTransform, &residual)
                 : SnapTransformTranslation3D(idealTransform, &residual));
  Matrix4x4 childTransformToSurface =
      (!mUseIntermediateSurface ||
       (mUseIntermediateSurface && !Extend3DContext() /* 2D */))
          ? idealTransform
          : Matrix4x4::From2D(residual);
  ComputeEffectiveTransformsForChildren(childTransformToSurface);

  ComputeEffectiveTransformForMaskLayers(aTransformToSurface);
}

bool BasicContainerLayer::ChildrenPartitionVisibleRegion(
    const gfx::IntRect& aInRect) {
  Matrix transform;
  if (!GetEffectiveTransform().CanDraw2D(&transform) ||
      ThebesMatrix(transform).HasNonIntegerTranslation())
    return false;

  nsIntPoint offset(int32_t(transform._31), int32_t(transform._32));
  gfx::IntRect rect = aInRect.Intersect(
      GetLocalVisibleRegion().GetBounds().ToUnknownRect() + offset);
  nsIntRegion covered;

  for (Layer* l = mFirstChild; l; l = l->GetNextSibling()) {
    if (ToData(l)->IsHidden()) continue;

    Matrix childTransform;
    if (!l->GetEffectiveTransform().CanDraw2D(&childTransform) ||
        ThebesMatrix(childTransform).HasNonIntegerTranslation() ||
        l->GetEffectiveOpacity() != 1.0)
      return false;
    nsIntRegion childRegion = l->GetLocalVisibleRegion().ToUnknownRegion();
    childRegion.MoveBy(int32_t(childTransform._31),
                       int32_t(childTransform._32));
    childRegion.And(childRegion, rect);
    if (l->GetClipRect()) {
      childRegion.And(childRegion, l->GetClipRect()->ToUnknownRect() + offset);
    }
    nsIntRegion intersection;
    intersection.And(covered, childRegion);
    if (!intersection.IsEmpty()) return false;
    covered.Or(covered, childRegion);
  }

  return covered.Contains(rect);
}

void BasicContainerLayer::Validate(
    LayerManager::DrawPaintedLayerCallback aCallback, void* aCallbackData,
    ReadbackProcessor* aReadback) {
  ReadbackProcessor readback;
  if (BasicManager()->IsRetained()) {
    readback.BuildUpdates(this);
  }
  for (Layer* l = mFirstChild; l; l = l->GetNextSibling()) {
    BasicImplData* data = ToData(l);
    data->Validate(aCallback, aCallbackData, &readback);
    if (l->GetMaskLayer()) {
      data = ToData(l->GetMaskLayer());
      data->Validate(aCallback, aCallbackData, nullptr);
    }
  }
}

already_AddRefed<ContainerLayer> BasicLayerManager::CreateContainerLayer() {
  NS_ASSERTION(InConstruction(), "Only allowed in construction phase");
  RefPtr<ContainerLayer> layer = new BasicContainerLayer(this);
  return layer.forget();
}

}  // namespace layers
}  // namespace mozilla