The Tor Browser: gfx/thebes/gfxSkipChars.h@97036ab72558 (annotated)

gfx/thebes/gfxSkipChars.h@97036ab72558 (annotated)

gfx/thebes/gfxSkipChars.h

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  * 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 GFX_SKIP_CHARS_H
 #define GFX_SKIP_CHARS_H
 #include "nsTArray.h"
 /*
  * gfxSkipChars is a data structure representing a list of characters that
  * have been skipped. The initial string is called the "original string"
  * and after skipping some characters, the result is called the "skipped string".
  * gfxSkipChars provides efficient ways to translate between offsets in the
  * original string and the skipped string. It is used by textrun code to keep
  * track of offsets before and after text transformations such as whitespace
  * compression and control code deletion.
  */
 /**
  * The gfxSkipChars is represented as a sorted array of skipped ranges.
  *
  * A freshly-created gfxSkipChars means "all chars kept".
  */
 class gfxSkipChars
 {
 private:
     class SkippedRange
     {
     public:
         SkippedRange(uint32_t aOffset, uint32_t aLength, uint32_t aDelta)
             : mOffset(aOffset), mLength(aLength), mDelta(aDelta)
         { }
         uint32_t Start() const
         {
             return mOffset;
         }
         uint32_t End() const
         {
             return mOffset + mLength;
         }
         uint32_t Length() const
         {
             return mLength;
         }
         uint32_t SkippedOffset() const
         {
             return mOffset - mDelta;
         }
         uint32_t Delta() const
         {
             return mDelta;
         }
         uint32_t NextDelta() const
         {
             return mDelta + mLength;
         }
         void Extend(uint32_t aChars)
         {
             mLength += aChars;
         }
     private:
         uint32_t mOffset; // original-string offset at which we want to skip
         uint32_t mLength; // number of skipped chars at this offset
         uint32_t mDelta;  // sum of lengths of preceding skipped-ranges
     };
 public:
     gfxSkipChars()
         : mCharCount(0)
     { }
     void SkipChars(uint32_t aChars)
     {
         NS_ASSERTION(mCharCount + aChars > mCharCount,
                      "Character count overflow");
         uint32_t rangeCount = mRanges.Length();
         uint32_t delta = 0;
         if (rangeCount > 0) {
             SkippedRange& lastRange = mRanges[rangeCount - 1];
             if (lastRange.End() == mCharCount) {
                 lastRange.Extend(aChars);
                 mCharCount += aChars;
                 return;
             }
             delta = lastRange.NextDelta();
         }
         mRanges.AppendElement(SkippedRange(mCharCount, aChars, delta));
         mCharCount += aChars;
     }
     void KeepChars(uint32_t aChars)
     {
         NS_ASSERTION(mCharCount + aChars > mCharCount,
                      "Character count overflow");
         mCharCount += aChars;
     }
     void SkipChar()
     {
         SkipChars(1);
     }
     void KeepChar()
     {
         KeepChars(1);
     }
     void TakeFrom(gfxSkipChars* aSkipChars)
     {
         mRanges.SwapElements(aSkipChars->mRanges);
         mCharCount = aSkipChars->mCharCount;
         aSkipChars->mCharCount = 0;
     }
     int32_t GetOriginalCharCount() const
     {
         return mCharCount;
     }
     const SkippedRange& LastRange() const
     {
         // this is only valid if mRanges is non-empty; no assertion here
         // because nsTArray will already assert if we abuse it
         return mRanges[mRanges.Length() - 1];
     }
     friend class gfxSkipCharsIterator;
 private:
     nsTArray<SkippedRange> mRanges;
     uint32_t               mCharCount;
 };
 /**
  * A gfxSkipCharsIterator represents a position in the original string. It lets you
  * map efficiently to and from positions in the string after skipped characters
  * have been removed. You can also specify an offset that is added to all
  * incoming original string offsets and subtracted from all outgoing original
  * string offsets --- useful when the gfxSkipChars corresponds to something
  * offset from the original DOM coordinates, which it often does for gfxTextRuns.
  *
  * The current positions (in both the original and skipped strings) are
  * always constrained to be >= 0 and <= the string length. When the position
  * is equal to the string length, it is at the end of the string. The current
  * positions do not include any aOriginalStringToSkipCharsOffset.
  *
  * When the position in the original string corresponds to a skipped character,
  * the skipped-characters offset is the offset of the next unskipped character,
  * or the skipped-characters string length if there is no next unskipped character.
  */
 class gfxSkipCharsIterator
 {
 public:
     /**
      * @param aOriginalStringToSkipCharsOffset add this to all incoming and
      * outgoing original string offsets
      */
     gfxSkipCharsIterator(const gfxSkipChars& aSkipChars,
                          int32_t aOriginalStringToSkipCharsOffset,
                          int32_t aOriginalStringOffset)
         : mSkipChars(&aSkipChars),
           mOriginalStringOffset(0),
           mSkippedStringOffset(0),
           mCurrentRangeIndex(-1),
           mOriginalStringToSkipCharsOffset(aOriginalStringToSkipCharsOffset)
     {
           SetOriginalOffset(aOriginalStringOffset);
     }
     gfxSkipCharsIterator(const gfxSkipChars& aSkipChars,
                          int32_t aOriginalStringToSkipCharsOffset = 0)
         : mSkipChars(&aSkipChars),
           mOriginalStringOffset(0),
           mSkippedStringOffset(0),
           mCurrentRangeIndex(-1),
           mOriginalStringToSkipCharsOffset(aOriginalStringToSkipCharsOffset)
     { }
     gfxSkipCharsIterator(const gfxSkipCharsIterator& aIterator)
         : mSkipChars(aIterator.mSkipChars),
           mOriginalStringOffset(aIterator.mOriginalStringOffset),
           mSkippedStringOffset(aIterator.mSkippedStringOffset),
           mCurrentRangeIndex(aIterator.mCurrentRangeIndex),
           mOriginalStringToSkipCharsOffset(aIterator.mOriginalStringToSkipCharsOffset)
     { }
     /**
      * The empty constructor creates an object that is useless until it is assigned.
      */
     gfxSkipCharsIterator()
         : mSkipChars(nullptr)
     { }
     /**
      * Return true if this iterator is properly initialized and usable.
      */
     bool IsInitialized()
     {
         return mSkipChars != nullptr;
     }
     /**
      * Set the iterator to aOriginalStringOffset in the original string.
      * This can efficiently move forward or backward from the current position.
      * aOriginalStringOffset is clamped to [0,originalStringLength].
      */
     void SetOriginalOffset(int32_t aOriginalStringOffset);
     /**
      * Set the iterator to aSkippedStringOffset in the skipped string.
      * This can efficiently move forward or backward from the current position.
      * aSkippedStringOffset is clamped to [0,skippedStringLength].
      */
     void SetSkippedOffset(uint32_t aSkippedStringOffset);
     uint32_t ConvertOriginalToSkipped(int32_t aOriginalStringOffset)
     {
         SetOriginalOffset(aOriginalStringOffset);
         return GetSkippedOffset();
     }
     uint32_t ConvertSkippedToOriginal(int32_t aSkippedStringOffset)
     {
         SetSkippedOffset(aSkippedStringOffset);
         return GetOriginalOffset();
     }
     /**
      * Test if the character at the current position in the original string
      * is skipped or not. If aRunLength is non-null, then *aRunLength is set
      * to a number of characters all of which are either skipped or not, starting
      * at this character. When the current position is at the end of the original
      * string, we return true and *aRunLength is set to zero.
      */
     bool IsOriginalCharSkipped(int32_t* aRunLength = nullptr) const;
     void AdvanceOriginal(int32_t aDelta)
     {
         SetOriginalOffset(GetOriginalOffset() + aDelta);
     }
     void AdvanceSkipped(int32_t aDelta)
     {
         SetSkippedOffset(GetSkippedOffset() + aDelta);
     }
     /**
      * @return the offset within the original string
      */
     int32_t GetOriginalOffset() const
     {
         return mOriginalStringOffset - mOriginalStringToSkipCharsOffset;
     }
     /**
      * @return the offset within the skipped string corresponding to the
      * current position in the original string. If the current position
      * in the original string is a character that is skipped, then we return
      * the position corresponding to the first non-skipped character in the
      * original string after the current position, or the length of the skipped
      * string if there is no such character.
      */
     uint32_t GetSkippedOffset() const
     {
         return mSkippedStringOffset;
     }
     int32_t GetOriginalEnd() const
     {
         return mSkipChars->GetOriginalCharCount() -
             mOriginalStringToSkipCharsOffset;
     }
 private:
     const gfxSkipChars* mSkipChars;
     // Current position
     int32_t mOriginalStringOffset;
     uint32_t mSkippedStringOffset;
     // Index of the last skippedRange that precedes or contains the current
     // position in the original string.
     // If index == -1 then we are before the first skipped char.
     int32_t mCurrentRangeIndex;
     // This offset is added to map from "skipped+unskipped characters in
     // the original DOM string" character space to "skipped+unskipped
     // characters in the textrun's gfxSkipChars" character space
     int32_t mOriginalStringToSkipCharsOffset;
 };
 #endif /*GFX_SKIP_CHARS_H*/

The Tor Browser / annotate

gfx/thebes/gfxSkipChars.h@97036ab72558 (annotated)

gfx/thebes/gfxSkipChars.h