gecko-dev/layout/painting/nsDisplayListInvalidation.h

/* -*- 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/. */

#ifndef NSDISPLAYLISTINVALIDATION_H_
#define NSDISPLAYLISTINVALIDATION_H_

#include "mozilla/Attributes.h"
#include "FrameLayerBuilder.h"
#include "imgIContainer.h"
#include "nsRect.h"
#include "nsColor.h"
#include "gfxRect.h"
#include "mozilla/gfx/MatrixFwd.h"

class nsDisplayBackgroundImage;
class nsCharClipDisplayItem;
class nsDisplayItem;
class nsDisplayListBuilder;
class nsDisplayTableItem;
class nsDisplayThemedBackground;
class nsDisplaySVGEffects;
class nsDisplayMask;
class nsDisplayFilter;

namespace mozilla {
namespace gfx {
struct Color;
}
}

/**
 * This stores the geometry of an nsDisplayItem, and the area
 * that will be affected when painting the item.
 *
 * It is used to retain information about display items so they
 * can be compared against new display items in the next paint.
 */
class nsDisplayItemGeometry
{
public:
  nsDisplayItemGeometry(nsDisplayItem* aItem, nsDisplayListBuilder* aBuilder);
  virtual ~nsDisplayItemGeometry();

  /**
   * Compute the area required to be invalidated if this
   * display item is removed.
   */
  const nsRect& ComputeInvalidationRegion() { return mBounds; }

  /**
   * Shifts all retained areas of the nsDisplayItemGeometry by the given offset.
   *
   * This is used to compensate for scrolling, since the destination buffer
   * can scroll without requiring a full repaint.
   *
   * @param aOffset Offset to shift by.
   */
  virtual void MoveBy(const nsPoint& aOffset) { mBounds.MoveBy(aOffset); }

  virtual bool InvalidateForSyncDecodeImages() const { return false; }

  /**
   * Bounds of the display item
   */
  nsRect mBounds;
};

/**
 * A default geometry implementation, used by nsDisplayItem. Retains
 * and compares the bounds, and border rect.
 *
 * This should be sufficient for the majority of display items.
 */
class nsDisplayItemGenericGeometry : public nsDisplayItemGeometry
{
public:
  nsDisplayItemGenericGeometry(nsDisplayItem* aItem,
                               nsDisplayListBuilder* aBuilder);

  void MoveBy(const nsPoint& aOffset) override;

  nsRect mBorderRect;
};

bool
ShouldSyncDecodeImages(nsDisplayListBuilder* aBuilder);

/**
 * nsImageGeometryMixin is a mixin for geometry items that draw images.
 * Geometry items that include this mixin can track drawing results and use
 * that information to inform invalidation decisions.
 *
 * This mixin uses CRTP; its template parameter should be the type of the class
 * that is inheriting from it. See nsDisplayItemGenericImageGeometry for an
 * example.
 */
template<typename T>
class nsImageGeometryMixin
{
public:
  nsImageGeometryMixin(nsDisplayItem* aItem, nsDisplayListBuilder* aBuilder)
    : mLastDrawResult(mozilla::image::ImgDrawResult::NOT_READY)
    , mWaitingForPaint(false)
  {
    // Transfer state from the previous version of this geometry item.
    auto lastGeometry =
      static_cast<T*>(mozilla::FrameLayerBuilder::GetMostRecentGeometry(aItem));
    if (lastGeometry) {
      mLastDrawResult = lastGeometry->mLastDrawResult;
      mWaitingForPaint = lastGeometry->mWaitingForPaint;
    }

    // If our display item is going to invalidate to trigger sync decoding of
    // images, mark ourselves as waiting for a paint. If we actually get
    // painted, UpdateDrawResult will get called, and we'll clear the flag.
    if (ShouldSyncDecodeImages(aBuilder) &&
        ShouldInvalidateToSyncDecodeImages()) {
      mWaitingForPaint = true;
    }
  }

  static void UpdateDrawResult(nsDisplayItem* aItem,
                               mozilla::image::ImgDrawResult aResult)
  {
    MOZ_ASSERT(aResult != mozilla::image::ImgDrawResult::NOT_SUPPORTED,
               "ImgDrawResult::NOT_SUPPORTED should be handled already!");

    auto lastGeometry =
      static_cast<T*>(mozilla::FrameLayerBuilder::GetMostRecentGeometry(aItem));
    if (lastGeometry) {
      lastGeometry->mLastDrawResult = aResult;
      lastGeometry->mWaitingForPaint = false;
    }
  }

  bool ShouldInvalidateToSyncDecodeImages() const
  {
    if (mWaitingForPaint) {
      // We previously invalidated for sync decoding and haven't gotten painted
      // since them. This suggests that our display item is completely occluded
      // and there's no point in invalidating again - and because the reftest
      // harness takes a new snapshot every time we invalidate, doing so might
      // lead to an invalidation loop if we're in a reftest.
      return false;
    }

    if (mLastDrawResult == mozilla::image::ImgDrawResult::SUCCESS ||
        mLastDrawResult == mozilla::image::ImgDrawResult::BAD_IMAGE) {
      return false;
    }

    return true;
  }

private:
  mozilla::image::ImgDrawResult mLastDrawResult;
  bool mWaitingForPaint;
};

/**
 * nsDisplayItemGenericImageGeometry is a generic geometry item class that
 * includes nsImageGeometryMixin.
 *
 * This should be sufficient for most display items that draw images.
 */
class nsDisplayItemGenericImageGeometry
  : public nsDisplayItemGenericGeometry
  , public nsImageGeometryMixin<nsDisplayItemGenericImageGeometry>
{
public:
  nsDisplayItemGenericImageGeometry(nsDisplayItem* aItem,
                                    nsDisplayListBuilder* aBuilder)
    : nsDisplayItemGenericGeometry(aItem, aBuilder)
    , nsImageGeometryMixin(aItem, aBuilder)
  {
  }

  bool InvalidateForSyncDecodeImages() const override
  {
    return ShouldInvalidateToSyncDecodeImages();
  }
};

class nsDisplayItemBoundsGeometry : public nsDisplayItemGeometry
{
public:
  nsDisplayItemBoundsGeometry(nsDisplayItem* aItem,
                              nsDisplayListBuilder* aBuilder);

  bool mHasRoundedCorners;
};

class nsDisplayBorderGeometry
  : public nsDisplayItemGeometry
  , public nsImageGeometryMixin<nsDisplayBorderGeometry>
{
public:
  nsDisplayBorderGeometry(nsDisplayItem* aItem, nsDisplayListBuilder* aBuilder);

  bool InvalidateForSyncDecodeImages() const override
  {
    return ShouldInvalidateToSyncDecodeImages();
  }
};

class nsDisplayBackgroundGeometry
  : public nsDisplayItemGeometry
  , public nsImageGeometryMixin<nsDisplayBackgroundGeometry>
{
public:
  nsDisplayBackgroundGeometry(nsDisplayBackgroundImage* aItem,
                              nsDisplayListBuilder* aBuilder);

  void MoveBy(const nsPoint& aOffset) override;

  bool InvalidateForSyncDecodeImages() const override
  {
    return ShouldInvalidateToSyncDecodeImages();
  }

  nsRect mPositioningArea;
  nsRect mDestRect;
};

class nsDisplayThemedBackgroundGeometry : public nsDisplayItemGeometry
{
public:
  nsDisplayThemedBackgroundGeometry(nsDisplayThemedBackground* aItem,
                                    nsDisplayListBuilder* aBuilder);

  void MoveBy(const nsPoint& aOffset) override;

  nsRect mPositioningArea;
  bool mWindowIsActive;
};

class nsDisplayBoxShadowInnerGeometry : public nsDisplayItemGeometry
{
public:
  nsDisplayBoxShadowInnerGeometry(nsDisplayItem* aItem,
                                  nsDisplayListBuilder* aBuilder);

  void MoveBy(const nsPoint& aOffset) override;

  nsRect mPaddingRect;
};

class nsDisplayBoxShadowOuterGeometry : public nsDisplayItemGenericGeometry
{
public:
  nsDisplayBoxShadowOuterGeometry(nsDisplayItem* aItem,
                                  nsDisplayListBuilder* aBuilder,
                                  float aOpacity);

  float mOpacity;
};

class nsDisplaySolidColorGeometry : public nsDisplayItemBoundsGeometry
{
public:
  nsDisplaySolidColorGeometry(nsDisplayItem* aItem,
                              nsDisplayListBuilder* aBuilder,
                              nscolor aColor)
    : nsDisplayItemBoundsGeometry(aItem, aBuilder)
    , mColor(aColor)
  {
  }

  nscolor mColor;
};

class nsDisplaySolidColorRegionGeometry : public nsDisplayItemBoundsGeometry
{
public:
  nsDisplaySolidColorRegionGeometry(nsDisplayItem* aItem,
                                    nsDisplayListBuilder* aBuilder,
                                    const nsRegion& aRegion,
                                    mozilla::gfx::Color aColor)
    : nsDisplayItemBoundsGeometry(aItem, aBuilder)
    , mRegion(aRegion)
    , mColor(aColor)
  {
  }

  void MoveBy(const nsPoint& aOffset) override;

  nsRegion mRegion;
  mozilla::gfx::Color mColor;
};

class nsDisplaySVGEffectGeometry : public nsDisplayItemGeometry
{
public:
  nsDisplaySVGEffectGeometry(nsDisplaySVGEffects* aItem,
                             nsDisplayListBuilder* aBuilder);

  void MoveBy(const nsPoint& aOffset) override;

  gfxRect mBBox;
  gfxPoint mUserSpaceOffset;
  nsPoint mFrameOffsetToReferenceFrame;
};

class nsDisplayMaskGeometry
  : public nsDisplaySVGEffectGeometry
  , public nsImageGeometryMixin<nsDisplayMaskGeometry>
{
public:
  nsDisplayMaskGeometry(nsDisplayMask* aItem, nsDisplayListBuilder* aBuilder);

  bool InvalidateForSyncDecodeImages() const override
  {
    return ShouldInvalidateToSyncDecodeImages();
  }

  nsTArray<nsRect> mDestRects;
  float mOpacity;
  bool mHandleOpacity;
};

class nsDisplayFilterGeometry
  : public nsDisplaySVGEffectGeometry
  , public nsImageGeometryMixin<nsDisplayFilterGeometry>
{
public:
  nsDisplayFilterGeometry(nsDisplayFilter* aItem,
                          nsDisplayListBuilder* aBuilder);

  bool InvalidateForSyncDecodeImages() const override
  {
    return ShouldInvalidateToSyncDecodeImages();
  }
};

class nsCharClipGeometry : public nsDisplayItemGenericGeometry
{
public:
  nsCharClipGeometry(nsCharClipDisplayItem* aItem,
                     nsDisplayListBuilder* aBuilder);

  nscoord mVisIStartEdge;
  nscoord mVisIEndEdge;
};

class nsDisplayTableItemGeometry
  : public nsDisplayItemGenericGeometry
  , public nsImageGeometryMixin<nsDisplayTableItemGeometry>
{
public:
  nsDisplayTableItemGeometry(nsDisplayTableItem* aItem,
                             nsDisplayListBuilder* aBuilder,
                             const nsPoint& aFrameOffsetToViewport);

  bool InvalidateForSyncDecodeImages() const override
  {
    return ShouldInvalidateToSyncDecodeImages();
  }

  nsPoint mFrameOffsetToViewport;
};

class nsDisplayOpacityGeometry : public nsDisplayItemGenericGeometry
{
public:
  nsDisplayOpacityGeometry(nsDisplayItem* aItem,
                           nsDisplayListBuilder* aBuilder,
                           float aOpacity)
    : nsDisplayItemGenericGeometry(aItem, aBuilder)
    , mOpacity(aOpacity)
  {
  }

  float mOpacity;
};

class nsDisplayTransformGeometry : public nsDisplayItemGeometry
{
public:
  nsDisplayTransformGeometry(nsDisplayItem* aItem,
                             nsDisplayListBuilder* aBuilder,
                             const mozilla::gfx::Matrix4x4Flagged& aTransform,
                             int32_t aAppUnitsPerDevPixel)
    : nsDisplayItemGeometry(aItem, aBuilder)
    , mTransform(aTransform)
    , mAppUnitsPerDevPixel(aAppUnitsPerDevPixel)
  {
  }

  void MoveBy(const nsPoint& aOffset) override
  {
    nsDisplayItemGeometry::MoveBy(aOffset);
    mTransform.PostTranslate(
      NSAppUnitsToFloatPixels(aOffset.x, mAppUnitsPerDevPixel),
      NSAppUnitsToFloatPixels(aOffset.y, mAppUnitsPerDevPixel),
      0.0f);
  }

  mozilla::gfx::Matrix4x4Flagged mTransform;
  int32_t mAppUnitsPerDevPixel;
};

#endif /*NSDISPLAYLISTINVALIDATION_H_*/