layout/style/CounterStyleManager.h
author Nika Layzell <nika@thelayzells.com>
Tue, 25 Sep 2018 17:34:53 +0200
changeset 507828 5e6dae0c1e5a4939ccd406f14607f7fafffd45a7
parent 438301 67a8e12324569dd730347187e2ffccae486c758b
child 508163 6f3709b3878117466168c40affa7bca0b60cf75b
permissions -rw-r--r--
Bug 1448426 - Wrap windows.h to avoid problematic define statements, r=froydnj,glandium By default, windows.h exposes a large number of problematic define statements which are UpperCamelCase, such as a define from `CreateWindow` to `CreateWindow{A,W}`. As many of these names are generic (e.g. CreateFile, CreateWindow), they can mess up Gecko code that may legitimately have its own methods with the same names. The header also defines some traditional SCREAMING_SNAKE_CASE defines which can mess up our code by conflicting with local values. This patch adds a simple code generator which generates wrappers for these defines, and uses them to wrap the windows.h wrapper using the `stl_wrappers` mechanism, allowing us to use windows.h in more places. Differential Revision: https://phabricator.services.mozilla.com/D10932

/* -*- 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 mozilla_CounterStyleManager_h_
#define mozilla_CounterStyleManager_h_

#include "nsAtom.h"
#include "nsStringFwd.h"
#include "nsDataHashtable.h"
#include "nsHashKeys.h"

#include "nsStyleConsts.h"

#include "mozilla/Attributes.h"

#include "nsCSSValue.h"

class nsPresContext;

namespace mozilla {

class WritingMode;

typedef int32_t CounterValue;

class CounterStyleManager;
class AnonymousCounterStyle;

struct NegativeType;
struct PadType;

class CounterStyle
{
protected:
  explicit constexpr CounterStyle(int32_t aStyle)
    : mStyle(aStyle)
  {
  }

private:
  CounterStyle(const CounterStyle& aOther) = delete;
  void operator=(const CounterStyle& other) = delete;

public:
  constexpr int32_t GetStyle() const { return mStyle; }
  bool IsNone() const { return mStyle == NS_STYLE_LIST_STYLE_NONE; }
  bool IsCustomStyle() const { return mStyle == NS_STYLE_LIST_STYLE_CUSTOM; }
  // A style is dependent if it depends on the counter style manager.
  // Custom styles are certainly dependent. In addition, some builtin
  // styles are dependent for fallback.
  bool IsDependentStyle() const;

  virtual nsAtom* GetStyleName() const = 0;
  virtual void GetPrefix(nsAString& aResult) = 0;
  virtual void GetSuffix(nsAString& aResult) = 0;
  void GetCounterText(CounterValue aOrdinal,
                      WritingMode aWritingMode,
                      nsAString& aResult,
                      bool& aIsRTL);
  virtual void GetSpokenCounterText(CounterValue aOrdinal,
                                    WritingMode aWritingMode,
                                    nsAString& aResult,
                                    bool& aIsBullet);

  // XXX This method could be removed once ::-moz-list-bullet and
  //     ::-moz-list-number are completely merged into ::marker.
  virtual bool IsBullet() = 0;

  virtual void GetNegative(NegativeType& aResult) = 0;
  /**
   * This method returns whether an ordinal is in the range of this
   * counter style. Note that, it is possible that an ordinal in range
   * is rejected by the generating algorithm.
   */
  virtual bool IsOrdinalInRange(CounterValue aOrdinal) = 0;
  /**
   * This method returns whether an ordinal is in the default range of
   * this counter style. This is the effective range when no 'range'
   * descriptor is specified.
   */
  virtual bool IsOrdinalInAutoRange(CounterValue aOrdinal) = 0;
  virtual void GetPad(PadType& aResult) = 0;
  virtual CounterStyle* GetFallback() = 0;
  virtual uint8_t GetSpeakAs() = 0;
  virtual bool UseNegativeSign() = 0;

  virtual void CallFallbackStyle(CounterValue aOrdinal,
                                 WritingMode aWritingMode,
                                 nsAString& aResult,
                                 bool& aIsRTL);
  virtual bool GetInitialCounterText(CounterValue aOrdinal,
                                     WritingMode aWritingMode,
                                     nsAString& aResult,
                                     bool& aIsRTL) = 0;

  virtual AnonymousCounterStyle* AsAnonymous() { return nullptr; }

protected:
  const int32_t mStyle;
};

class AnonymousCounterStyle final : public CounterStyle
{
public:
  explicit AnonymousCounterStyle(const nsAString& aContent);
  AnonymousCounterStyle(uint8_t aSystem, nsTArray<nsString> aSymbols);
  explicit AnonymousCounterStyle(const nsCSSValue::Array* aValue);

  virtual nsAtom* GetStyleName() const override;
  virtual void GetPrefix(nsAString& aResult) override;
  virtual void GetSuffix(nsAString& aResult) override;
  virtual bool IsBullet() override;

  virtual void GetNegative(NegativeType& aResult) override;
  virtual bool IsOrdinalInRange(CounterValue aOrdinal) override;
  virtual bool IsOrdinalInAutoRange(CounterValue aOrdinal) override;
  virtual void GetPad(PadType& aResult) override;
  virtual CounterStyle* GetFallback() override;
  virtual uint8_t GetSpeakAs() override;
  virtual bool UseNegativeSign() override;

  virtual bool GetInitialCounterText(CounterValue aOrdinal,
                                     WritingMode aWritingMode,
                                     nsAString& aResult,
                                     bool& aIsRTL) override;

  virtual AnonymousCounterStyle* AsAnonymous() override { return this; }

  bool IsSingleString() const { return mSingleString; }
  uint8_t GetSystem() const { return mSystem; }
  const nsTArray<nsString>& GetSymbols() const { return mSymbols; }

  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(AnonymousCounterStyle)

private:
  ~AnonymousCounterStyle() {}

  bool mSingleString;
  uint8_t mSystem;
  nsTArray<nsString> mSymbols;
};

// A smart pointer to CounterStyle. It either owns a reference to an
// anonymous counter style, or weakly refers to a named counter style
// managed by counter style manager.
class CounterStylePtr
{
public:
  CounterStylePtr() : mRaw(0) {}
  CounterStylePtr(const CounterStylePtr& aOther)
    : mRaw(aOther.mRaw)
  {
    switch (GetType()) {
      case eCounterStyle:
        break;
      case eAnonymousCounterStyle:
        AsAnonymous()->AddRef();
        break;
      case eUnresolvedAtom:
        AsAtom()->AddRef();
        break;
      case eMask:
        MOZ_ASSERT_UNREACHABLE("Unknown type");
        break;
    }
  }
  CounterStylePtr(CounterStylePtr&& aOther)
    : mRaw(aOther.mRaw)
  {
    aOther.mRaw = 0;
  }
  ~CounterStylePtr() { Reset(); }

  CounterStylePtr& operator=(const CounterStylePtr& aOther)
  {
    if (this != &aOther) {
      Reset();
      new (this) CounterStylePtr(aOther);
    }
    return *this;
  }
  CounterStylePtr& operator=(CounterStylePtr&& aOther)
  {
    if (this != &aOther) {
      Reset();
      mRaw = aOther.mRaw;
      aOther.mRaw = 0;
    }
    return *this;
  }
  CounterStylePtr& operator=(decltype(nullptr))
  {
    Reset();
    return *this;
  }
  CounterStylePtr& operator=(already_AddRefed<nsAtom> aAtom)
  {
    Reset();
    if (nsAtom* raw = aAtom.take()) {
      AssertPointerAligned(raw);
      mRaw = reinterpret_cast<uintptr_t>(raw) | eUnresolvedAtom;
    }
    return *this;
  }
  CounterStylePtr& operator=(AnonymousCounterStyle* aCounterStyle)
  {
    Reset();
    if (aCounterStyle) {
      CounterStyle* raw = do_AddRef(aCounterStyle).take();
      AssertPointerAligned(raw);
      mRaw = reinterpret_cast<uintptr_t>(raw) | eAnonymousCounterStyle;
    }
    return *this;
  }
  CounterStylePtr& operator=(CounterStyle* aCounterStyle)
  {
    Reset();
    if (aCounterStyle) {
      MOZ_ASSERT(!aCounterStyle->AsAnonymous());
      AssertPointerAligned(aCounterStyle);
      mRaw = reinterpret_cast<uintptr_t>(aCounterStyle) | eCounterStyle;
    }
    return *this;
  }

  operator CounterStyle*() const & { return Get(); }
  operator CounterStyle*() const && = delete;
  CounterStyle* operator->() const { return Get(); }
  explicit operator bool() const { return !!mRaw; }
  bool operator!() const { return !mRaw; }
  bool operator==(const CounterStylePtr& aOther) const
    { return mRaw == aOther.mRaw; }
  bool operator!=(const CounterStylePtr& aOther) const
    { return mRaw != aOther.mRaw; }

  bool IsResolved() const { return !IsUnresolved(); }
  inline void Resolve(CounterStyleManager* aManager);

  nsAtom* AsAtom() const
  {
    MOZ_ASSERT(IsUnresolved());
    return reinterpret_cast<nsAtom*>(mRaw & ~eMask);
  }
  AnonymousCounterStyle* AsAnonymous() const
  {
    MOZ_ASSERT(IsAnonymous());
    return static_cast<AnonymousCounterStyle*>(
      reinterpret_cast<CounterStyle*>(mRaw & ~eMask));
  }

private:
  CounterStyle* Get() const
  {
    MOZ_ASSERT(IsResolved());
    return reinterpret_cast<CounterStyle*>(mRaw & ~eMask);
  }
  template<typename T>
  void AssertPointerAligned(T* aPointer)
  {
    // This can be checked at compile time via
    // > static_assert(alignof(CounterStyle) >= 4);
    // > static_assert(alignof(nsAtom) >= 4);
    // but MSVC2015 doesn't support using alignof on an abstract class.
    // Once we move to MSVC2017, we can replace this runtime check with
    // the compile time check above.
    MOZ_ASSERT(!(reinterpret_cast<uintptr_t>(aPointer) & eMask));
  }

  enum Type : uintptr_t {
    eCounterStyle = 0,
    eAnonymousCounterStyle = 1,
    eUnresolvedAtom = 2,
    eMask = 3,
  };

  Type GetType() const { return static_cast<Type>(mRaw & eMask); }
  bool IsUnresolved() const { return GetType() == eUnresolvedAtom; }
  bool IsAnonymous() const { return GetType() == eAnonymousCounterStyle; }

  void Reset()
  {
    switch (GetType()) {
      case eCounterStyle:
        break;
      case eAnonymousCounterStyle:
        AsAnonymous()->Release();
        break;
      case eUnresolvedAtom:
        AsAtom()->Release();
        break;
      case eMask:
        MOZ_ASSERT_UNREACHABLE("Unknown type");
        break;
    }
    mRaw = 0;
  }

  // mRaw contains the pointer, and its last two bits are used for type
  // of the pointer.
  // If the type is eUnresolvedAtom, the pointer owns a reference to an
  // nsAtom, and it needs to be resolved to a counter style before use.
  // If the type is eAnonymousCounterStyle, it owns a reference to an
  // anonymous counter style.
  // Otherwise it is a weak pointer referring a named counter style
  // managed by CounterStyleManager.
  uintptr_t mRaw;
};

class CounterStyleManager final
{
private:
  ~CounterStyleManager();
public:
  explicit CounterStyleManager(nsPresContext* aPresContext);

  void Disconnect();

  bool IsInitial() const
  {
    // only 'none', 'decimal', and 'disc'
    return mStyles.Count() == 3;
  }

  // Returns the counter style object for the given name from the style
  // table if it is already built, and nullptr otherwise.
  CounterStyle* GetCounterStyle(nsAtom* aName) const {
    return mStyles.Get(aName);
  }
  // Same as GetCounterStyle but try to build the counter style object
  // rather than returning nullptr if that hasn't been built.
  CounterStyle* BuildCounterStyle(nsAtom* aName);

  static CounterStyle* GetBuiltinStyle(int32_t aStyle);
  static CounterStyle* GetNoneStyle()
  {
    return GetBuiltinStyle(NS_STYLE_LIST_STYLE_NONE);
  }
  static CounterStyle* GetDecimalStyle()
  {
    return GetBuiltinStyle(NS_STYLE_LIST_STYLE_DECIMAL);
  }
  static CounterStyle* GetDiscStyle()
  {
    return GetBuiltinStyle(NS_STYLE_LIST_STYLE_DISC);
  }

  static nsAtom* GetStyleNameFromType(int32_t aStyle);

  // This method will scan all existing counter styles generated by this
  // manager, and remove or mark data dirty accordingly. It returns true
  // if any counter style is changed, false elsewise. This method should
  // be called when any counter style may be affected.
  bool NotifyRuleChanged();
  // NotifyRuleChanged will evict no longer needed counter styles into
  // mRetiredStyles, and this function destroys all objects listed there.
  // It should be called only after no one may ever use those objects.
  void CleanRetiredStyles();

  nsPresContext* PresContext() const { return mPresContext; }

  NS_INLINE_DECL_REFCOUNTING(CounterStyleManager)

private:
  void DestroyCounterStyle(CounterStyle* aCounterStyle);

  nsPresContext* mPresContext;
  nsDataHashtable<nsRefPtrHashKey<nsAtom>, CounterStyle*> mStyles;
  nsTArray<CounterStyle*> mRetiredStyles;
};

void
CounterStylePtr::Resolve(CounterStyleManager* aManager)
{
  if (IsUnresolved()) {
    *this = aManager->BuildCounterStyle(AsAtom());
  }
}

} // namespace mozilla

#endif /* !defined(mozilla_CounterStyleManager_h_) */