author alwu <>
Mon, 07 Jan 2019 19:57:48 +0000
changeset 512757 0e229bbdaae5c8fa9f83796c628a4fdf88f057ba
parent 508163 6f3709b3878117466168c40affa7bca0b60cf75b
permissions -rw-r--r--
Bug 1513039 - part5 : log warning when autoplay is blocked. r=cpearce,karlt Wrap 'nsContentUtils::ReportToConsole()' to reduce necessary input parameters and call it when we need to log error or warning message. Show the warning when autoplay is blocked. For web audio, this restores the console messages removed in part4 and also reports the same message when the AudioContext is blocked in the constructor. Differential Revision:

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


#include "DisplayItemClip.h"
#include "nsAutoPtr.h"
#include "nsPresContext.h"
#include "mozilla/gfx/Matrix.h"

namespace mozilla {

namespace layers {
class ImageContainer;
class KnowsCompositor;
}  // namespace layers

 * Keeps a record of image containers for mask layers, containers are mapped
 * from the rounded rects used to create them.
 * The cache stores MaskLayerImageEntries indexed by MaskLayerImageKeys.
 * Each MaskLayerImageEntry owns a heap-allocated MaskLayerImageKey
 * (heap-allocated so that a mask layer's userdata can keep a pointer to the
 * key for its image, in spite of the hashtable moving its entries around).
 * The key consists of the rounded rects used to create the mask,
 * an nsRefPtr to the ImageContainer containing the image, and a count
 * of the number of layers currently using this ImageContainer.
 * When the key's layer count is zero, the cache
 * may remove the entry, which deletes the key object.
class MaskLayerImageCache {
  typedef mozilla::layers::ImageContainer ImageContainer;
  typedef mozilla::layers::KnowsCompositor KnowsCompositor;


   * Representation of a rounded rectangle in device pixel coordinates, in
   * contrast to DisplayItemClip::RoundedRect, which uses app units.
   * In particular, our internal representation uses a gfxRect, rather than
   * an nsRect, so this class is easier to use with transforms.
  struct PixelRoundedRect {
    PixelRoundedRect() = delete;

    PixelRoundedRect(const DisplayItemClip::RoundedRect& aRRect,
                     nsPresContext* aPresContext)
        : mRect(aPresContext->AppUnitsToGfxUnits(aRRect.mRect.x),
                aPresContext->AppUnitsToGfxUnits(aRRect.mRect.height)) {
      NS_FOR_CSS_HALF_CORNERS(corner) {
        mRadii[corner] =

    PixelRoundedRect(const PixelRoundedRect& aPRR) : mRect(aPRR.mRect) {
      NS_FOR_CSS_HALF_CORNERS(corner) { mRadii[corner] = aPRR.mRadii[corner]; }

    ~PixelRoundedRect() { MOZ_COUNT_DTOR(PixelRoundedRect); }

    // Applies the scale and translate components of aTransform.
    // It is an error to pass a matrix which does more than just scale
    // and translate.
    void ScaleAndTranslate(const gfx::Matrix& aTransform) {
      NS_ASSERTION(aTransform._12 == 0 && aTransform._21 == 0,
                   "Transform has a component other than scale and translate");

      mRect = aTransform.TransformBounds(mRect);

      for (size_t i = 0; i < ArrayLength(mRadii); i += 2) {
        mRadii[i] *= aTransform._11;
        mRadii[i + 1] *= aTransform._22;

    bool operator==(const PixelRoundedRect& aOther) const {
      if (!mRect.IsEqualInterior(aOther.mRect)) {
        return false;

      NS_FOR_CSS_HALF_CORNERS(corner) {
        if (mRadii[corner] != aOther.mRadii[corner]) {
          return false;
      return true;
    bool operator!=(const PixelRoundedRect& aOther) const {
      return !(*this == aOther);

    // Create a hash for this object.
    PLDHashNumber Hash() const {
      PLDHashNumber hash = HashBytes(&mRect.x, 4 * sizeof(gfxFloat));
      hash = AddToHash(hash, HashBytes(mRadii, 8 * sizeof(gfxFloat)));

      return hash;

    gfx::Rect mRect;
    // Indices into mRadii are the enum HalfCorner constants in gfx/2d/Types.h
    gfxFloat mRadii[8];

  struct MaskLayerImageKeyRef;

   * A key to identify cached image containers.
   * The const-ness of this class is with respect to its use as a key into a
   * hashtable, so anything not used to create the hash is mutable.
   * mLayerCount counts the number of mask layers which have a reference to
   * MaskLayerImageEntry::mContainer; it is maintained by MaskLayerUserData,
   * which keeps a reference to the key. There will usually be mLayerCount + 1
   * pointers to a key object (the +1 being from the hashtable entry), but this
   * invariant may be temporarily broken.
  struct MaskLayerImageKey {
    friend struct MaskLayerImageKeyRef;

    MaskLayerImageKey(const MaskLayerImageKey& aKey);


    bool HasZeroLayerCount() const { return mLayerCount == 0; }

    PLDHashNumber Hash() const {
      PLDHashNumber hash = 0;

      for (uint32_t i = 0; i < mRoundedClipRects.Length(); ++i) {
        hash = AddToHash(hash, mRoundedClipRects[i].Hash());
      hash = AddToHash(hash, mKnowsCompositor.get());

      return hash;

    bool operator==(const MaskLayerImageKey& aOther) const {
      return mKnowsCompositor == aOther.mKnowsCompositor &&
             mRoundedClipRects == aOther.mRoundedClipRects;

    nsTArray<PixelRoundedRect> mRoundedClipRects;
    RefPtr<KnowsCompositor> mKnowsCompositor;

    void IncLayerCount() const { ++mLayerCount; }
    void DecLayerCount() const {
      NS_ASSERTION(mLayerCount > 0, "Inconsistent layer count");
    mutable uint32_t mLayerCount;

   * This struct maintains a reference to a MaskLayerImageKey, via a variant on
   * refcounting. When a key is passed in via Reset(), we increment the
   * passed-in key's mLayerCount, and we decrement its mLayerCount when we're
   * destructed (or when the key is replaced via a second Reset() call).
   * However, unlike standard refcounting smart-pointers, this object does
   * *not* delete the tracked MaskLayerImageKey -- instead, deletion happens
   * in MaskLayerImageCache::Sweep(), for any keys whose mLayerCount is 0.
  struct MaskLayerImageKeyRef {
    ~MaskLayerImageKeyRef() {
      if (mRawPtr) {

    MaskLayerImageKeyRef() : mRawPtr(nullptr) {}
    MaskLayerImageKeyRef(const MaskLayerImageKeyRef&) = delete;
    void operator=(const MaskLayerImageKeyRef&) = delete;

    void Reset(const MaskLayerImageKey* aPtr) {
          aPtr, "Cannot initialize a MaskLayerImageKeyRef with a null pointer");
      if (mRawPtr) {
      mRawPtr = aPtr;

    const MaskLayerImageKey* mRawPtr;

  // Find an image container for aKey, returns nullptr if there is no suitable
  // cached image. If there is an image, then aKey is set to point at the stored
  // key for the image.
  ImageContainer* FindImageFor(const MaskLayerImageKey** aKey);

  // Add an image container with a key to the cache
  // The image container used will be set as the container in aKey and aKey
  // itself will be linked from this cache
  void PutImage(const MaskLayerImageKey* aKey, ImageContainer* aContainer);

  // Sweep the cache for old image containers that can be deleted
  void Sweep();

  class MaskLayerImageEntry : public PLDHashEntryHdr {
    typedef const MaskLayerImageKey& KeyType;
    typedef const MaskLayerImageKey* KeyTypePointer;

    explicit MaskLayerImageEntry(KeyTypePointer aKey) : mKey(aKey) {
    MaskLayerImageEntry(const MaskLayerImageEntry& aOther)
        : mKey(aOther.mKey.get()) {
      NS_ERROR("ALLOW_MEMMOVE == true, should never be called");
    ~MaskLayerImageEntry() { MOZ_COUNT_DTOR(MaskLayerImageEntry); }

    // KeyEquals(): does this entry match this key?
    bool KeyEquals(KeyTypePointer aKey) const { return *mKey == *aKey; }

    // KeyToPointer(): Convert KeyType to KeyTypePointer
    static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }

    // HashKey(): calculate the hash number
    static PLDHashNumber HashKey(KeyTypePointer aKey) { return aKey->Hash(); }

    // ALLOW_MEMMOVE can we move this class with memmove(), or do we have
    // to use the copy constructor?
    enum { ALLOW_MEMMOVE = true };

    bool operator==(const MaskLayerImageEntry& aOther) const {
      return KeyEquals(aOther.mKey);

    nsAutoPtr<const MaskLayerImageKey> mKey;
    RefPtr<ImageContainer> mContainer;

  nsTHashtable<MaskLayerImageEntry> mMaskImageContainers;

}  // namespace mozilla