The Tor Browser: layout/base/nsCounterManager.h@6474c204b198 (annotated)

layout/base/nsCounterManager.h@6474c204b198 (annotated)

layout/base/nsCounterManager.h

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 // vim:cindent:ai:sw=4:ts=4:et:
 /* 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/. */
 /* implementation of CSS counters (for numbering things) */
 #ifndef nsCounterManager_h_
 #define nsCounterManager_h_
 #include "mozilla/Attributes.h"
 #include "nsGenConList.h"
 #include "nsAutoPtr.h"
 #include "nsClassHashtable.h"
 #include "mozilla/Likely.h"
 class nsCounterList;
 struct nsCounterUseNode;
 struct nsCounterChangeNode;
 struct nsCounterNode : public nsGenConNode {
     enum Type {
         RESET,     // a "counter number" pair in 'counter-reset'
         INCREMENT, // a "counter number" pair in 'counter-increment'
         USE        // counter() or counters() in 'content'
     };
     Type mType;
     // Counter value after this node
     int32_t mValueAfter;
     // mScopeStart points to the node (usually a RESET, but not in the
     // case of an implied 'counter-reset') that created the scope for
     // this element (for a RESET, its outer scope, i.e., the one it is
     // inside rather than the one it creates).
     // May be null for all types, but only when mScopePrev is also null.
     // Being null for a non-RESET means that it is an implied
     // 'counter-reset'.  Being null for a RESET means it has no outer
     // scope.
     nsCounterNode *mScopeStart;
     // mScopePrev points to the previous node that is in the same scope,
     // or for a RESET, the previous node in the scope outside of the
     // reset.
     // May be null for all types, but only when mScopeStart is also
     // null.  Following the mScopePrev links will eventually lead to
     // mScopeStart.  Being null for a non-RESET means that it is an
     // implied 'counter-reset'.  Being null for a RESET means it has no
     // outer scope.
     nsCounterNode *mScopePrev;
     inline nsCounterUseNode* UseNode();
     inline nsCounterChangeNode* ChangeNode();
     // For RESET and INCREMENT nodes, aPseudoFrame need not be a
     // pseudo-element, and aContentIndex represents the index within the
     // 'counter-reset' or 'counter-increment' property instead of within
     // the 'content' property but offset to ensure that (reset,
     // increment, use) sort in that order.  (This slight weirdness
     // allows sharing a lot of code with 'quotes'.)
     nsCounterNode(int32_t aContentIndex, Type aType)
         : nsGenConNode(aContentIndex)
         , mType(aType)
         , mValueAfter(0)
         , mScopeStart(nullptr)
         , mScopePrev(nullptr)
     {
     }
     // to avoid virtual function calls in the common case
     inline void Calc(nsCounterList* aList);
 };
 struct nsCounterUseNode : public nsCounterNode {
     // The same structure passed through the style system:  an array
     // containing the values in the counter() or counters() in the order
     // given in the CSS spec.
     nsRefPtr<nsCSSValue::Array> mCounterStyle;
     // false for counter(), true for counters()
     bool mAllCounters;
     // args go directly to member variables here and of nsGenConNode
     nsCounterUseNode(nsCSSValue::Array* aCounterStyle,
                      uint32_t aContentIndex, bool aAllCounters)
         : nsCounterNode(aContentIndex, USE)
         , mCounterStyle(aCounterStyle)
         , mAllCounters(aAllCounters)
     {
         NS_ASSERTION(aContentIndex <= INT32_MAX, "out of range");
     }
     virtual bool InitTextFrame(nsGenConList* aList,
             nsIFrame* aPseudoFrame, nsIFrame* aTextFrame) MOZ_OVERRIDE;
     // assign the correct |mValueAfter| value to a node that has been inserted
     // Should be called immediately after calling |Insert|.
     void Calc(nsCounterList* aList);
     // The text that should be displayed for this counter.
     void GetText(nsString& aResult);
 };
 struct nsCounterChangeNode : public nsCounterNode {
     int32_t mChangeValue; // the numeric value of the increment or reset
     // |aPseudoFrame| is not necessarily a pseudo-element's frame, but
     // since it is for every other subclass of nsGenConNode, we follow
     // the naming convention here.
     // |aPropIndex| is the index of the value within the list in the
     // 'counter-increment' or 'counter-reset' property.
     nsCounterChangeNode(nsIFrame* aPseudoFrame,
                         nsCounterNode::Type aChangeType,
                         int32_t aChangeValue,
                         int32_t aPropIndex)
         : nsCounterNode(// Fake a content index for resets and increments
                         // that comes before all the real content, with
                         // the resets first, in order, and then the increments.
                         aPropIndex + (aChangeType == RESET
                                         ? (INT32_MIN)
                                         : (INT32_MIN / 2)),
                         aChangeType)
         , mChangeValue(aChangeValue)
     {
         NS_ASSERTION(aPropIndex >= 0, "out of range");
         NS_ASSERTION(aChangeType == INCREMENT || aChangeType == RESET,
                      "bad type");
         mPseudoFrame = aPseudoFrame;
         CheckFrameAssertions();
     }
     // assign the correct |mValueAfter| value to a node that has been inserted
     // Should be called immediately after calling |Insert|.
     void Calc(nsCounterList* aList);
 };
 inline nsCounterUseNode* nsCounterNode::UseNode()
 {
     NS_ASSERTION(mType == USE, "wrong type");
     return static_cast<nsCounterUseNode*>(this);
 }
 inline nsCounterChangeNode* nsCounterNode::ChangeNode()
 {
     NS_ASSERTION(mType == INCREMENT || mType == RESET, "wrong type");
     return static_cast<nsCounterChangeNode*>(this);
 }
 inline void nsCounterNode::Calc(nsCounterList* aList)
 {
     if (mType == USE)
         UseNode()->Calc(aList);
     else
         ChangeNode()->Calc(aList);
 }
 class nsCounterList : public nsGenConList {
 public:
     nsCounterList() : nsGenConList(),
                       mDirty(false)
     {}
     void Insert(nsCounterNode* aNode) {
         nsGenConList::Insert(aNode);
         // Don't SetScope if we're dirty -- we'll reset all the scopes anyway,
         // and we can't usefully compute scopes right now.
         if (MOZ_LIKELY(!IsDirty())) {
             SetScope(aNode);
         }
     }
     nsCounterNode* First() {
         return static_cast<nsCounterNode*>(mFirstNode);
     }
     static nsCounterNode* Next(nsCounterNode* aNode) {
         return static_cast<nsCounterNode*>(nsGenConList::Next(aNode));
     }
     static nsCounterNode* Prev(nsCounterNode* aNode) {
         return static_cast<nsCounterNode*>(nsGenConList::Prev(aNode));
     }
     static int32_t ValueBefore(nsCounterNode* aNode) {
         return aNode->mScopePrev ? aNode->mScopePrev->mValueAfter : 0;
     }
     // Correctly set |aNode->mScopeStart| and |aNode->mScopePrev|
     void SetScope(nsCounterNode *aNode);
     // Recalculate |mScopeStart|, |mScopePrev|, and |mValueAfter| for
     // all nodes and update text in text content nodes.
     void RecalcAll();
     bool IsDirty() { return mDirty; }
     void SetDirty() { mDirty = true; }
 private:
     bool mDirty;
 };
 /**
  * The counter manager maintains an |nsCounterList| for each named
  * counter to keep track of all scopes with that name.
  */
 class nsCounterManager {
 public:
     nsCounterManager();
     // Returns true if dirty
     bool AddCounterResetsAndIncrements(nsIFrame *aFrame);
     // Gets the appropriate counter list, creating it if necessary.
     // Returns null only on out-of-memory.
     nsCounterList* CounterListFor(const nsSubstring& aCounterName);
     // Clean up data in any dirty counter lists.
     void RecalcAll();
     // Destroy nodes for the frame in any lists, and return whether any
     // nodes were destroyed.
     bool DestroyNodesFor(nsIFrame *aFrame);
     // Clear all data.
     void Clear() { mNames.Clear(); }
 #ifdef DEBUG
     void Dump();
 #endif
     static int32_t IncrementCounter(int32_t aOldValue, int32_t aIncrement)
     {
         // Addition of unsigned values is defined to be arithmetic
         // modulo 2^bits (C++ 2011, 3.9.1 [basic.fundamental], clause 4);
         // addition of signed values is undefined (and clang does
         // something very strange if we use it here).  Likewise integral
         // conversion from signed to unsigned is also defined as modulo
         // 2^bits (C++ 2011, 4.7 [conv.integral], clause 2); conversion
         // from unsigned to signed is however undefined (ibid., clause 3),
         // but to do what we want we must nonetheless depend on that
         // small piece of undefined behavior.
         int32_t newValue = int32_t(uint32_t(aOldValue) + uint32_t(aIncrement));
         // The CSS Working Group resolved that a counter-increment that
         // exceeds internal limits should not increment at all.
         // http://lists.w3.org/Archives/Public/www-style/2013Feb/0392.html
         // (This means, for example, that if aIncrement is 5, the
         // counter will get stuck at the largest multiple of 5 less than
         // the maximum 32-bit integer.)
         if ((aIncrement > 0) != (newValue > aOldValue)) {
           newValue = aOldValue;
         }
         return newValue;
     }
 private:
     // for |AddCounterResetsAndIncrements| only
     bool AddResetOrIncrement(nsIFrame *aFrame, int32_t aIndex,
                                const nsStyleCounterData *aCounterData,
                                nsCounterNode::Type aType);
     nsClassHashtable<nsStringHashKey, nsCounterList> mNames;
 };
 #endif /* nsCounterManager_h_ */

The Tor Browser / annotate

layout/base/nsCounterManager.h@6474c204b198 (annotated)

layout/base/nsCounterManager.h