The Tor Browser: gfx/skia/trunk/src/pdf/SkPDFFont.h@129ffea94266 (annotated)

gfx/skia/trunk/src/pdf/SkPDFFont.h@129ffea94266 (annotated)

gfx/skia/trunk/src/pdf/SkPDFFont.h

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkPDFFont_DEFINED
 #define SkPDFFont_DEFINED
 #include "SkAdvancedTypefaceMetrics.h"
 #include "SkBitSet.h"
 #include "SkPDFTypes.h"
 #include "SkTDArray.h"
 #include "SkThread.h"
 #include "SkTypeface.h"
 class SkPaint;
 class SkPDFCatalog;
 class SkPDFFont;
 class SkPDFGlyphSet : public SkNoncopyable {
 public:
     SkPDFGlyphSet();
     void set(const uint16_t* glyphIDs, int numGlyphs);
     bool has(uint16_t glyphID) const;
     void merge(const SkPDFGlyphSet& usage);
     void exportTo(SkTDArray<uint32_t>* glyphIDs) const;
 private:
     SkBitSet fBitSet;
 };
 class SkPDFGlyphSetMap : public SkNoncopyable {
 public:
     struct FontGlyphSetPair {
         FontGlyphSetPair(SkPDFFont* font, SkPDFGlyphSet* glyphSet);
         SkPDFFont* fFont;
         SkPDFGlyphSet* fGlyphSet;
     };
     SkPDFGlyphSetMap();
     ~SkPDFGlyphSetMap();
     class F2BIter {
     public:
         explicit F2BIter(const SkPDFGlyphSetMap& map);
         const FontGlyphSetPair* next() const;
         void reset(const SkPDFGlyphSetMap& map);
     private:
         const SkTDArray<FontGlyphSetPair>* fMap;
         mutable int fIndex;
     };
     void merge(const SkPDFGlyphSetMap& usage);
     void reset();
     void noteGlyphUsage(SkPDFFont* font, const uint16_t* glyphIDs,
                         int numGlyphs);
 private:
     SkPDFGlyphSet* getGlyphSetForFont(SkPDFFont* font);
     SkTDArray<FontGlyphSetPair> fMap;
 };
 /** \class SkPDFFont
     A PDF Object class representing a font.  The font may have resources
     attached to it in order to embed the font.  SkPDFFonts are canonicalized
     so that resource deduplication will only include one copy of a font.
     This class uses the same pattern as SkPDFGraphicState, a static weak
     reference to each instantiated class.
 */
 class SkPDFFont : public SkPDFDict {
     SK_DECLARE_INST_COUNT(SkPDFFont)
 public:
     virtual ~SkPDFFont();
     virtual void getResources(const SkTSet<SkPDFObject*>& knownResourceObjects,
                               SkTSet<SkPDFObject*>* newResourceObjects);
     /** Returns the typeface represented by this class. Returns NULL for the
      *  default typeface.
      */
     SkTypeface* typeface();
     /** Returns the font type represented in this font.  For Type0 fonts,
      *  returns the type of the decendant font.
      */
     virtual SkAdvancedTypefaceMetrics::FontType getType();
     /** Returns true if this font encoding supports glyph IDs above 255.
      */
     virtual bool multiByteGlyphs() const = 0;
     /** Return true if this font has an encoding for the passed glyph id.
      */
     bool hasGlyph(uint16_t glyphID);
     /** Convert (in place) the input glyph IDs into the font encoding.  If the
      *  font has more glyphs than can be encoded (like a type 1 font with more
      *  than 255 glyphs) this method only converts up to the first out of range
      *  glyph ID.
      *  @param glyphIDs       The input text as glyph IDs.
      *  @param numGlyphs      The number of input glyphs.
      *  @return               Returns the number of glyphs consumed.
      */
     size_t glyphsToPDFFontEncoding(uint16_t* glyphIDs, size_t numGlyphs);
     /** Get the font resource for the passed typeface and glyphID. The
      *  reference count of the object is incremented and it is the caller's
      *  responsibility to unreference it when done.  This is needed to
      *  accommodate the weak reference pattern used when the returned object
      *  is new and has no other references.
      *  @param typeface  The typeface to find.
      *  @param glyphID   Specify which section of a large font is of interest.
      */
     static SkPDFFont* GetFontResource(SkTypeface* typeface,
                                              uint16_t glyphID);
     /** Subset the font based on usage set. Returns a SkPDFFont instance with
      *  subset.
      *  @param usage  Glyph subset requested.
      *  @return       NULL if font does not support subsetting, a new instance
      *                of SkPDFFont otherwise.
      */
     virtual SkPDFFont* getFontSubset(const SkPDFGlyphSet* usage);
 protected:
     // Common constructor to handle common members.
     SkPDFFont(SkAdvancedTypefaceMetrics* fontInfo, SkTypeface* typeface,
               SkPDFDict* relatedFontDescriptor);
     // Accessors for subclass.
     SkAdvancedTypefaceMetrics* fontInfo();
     void setFontInfo(SkAdvancedTypefaceMetrics* info);
     uint16_t firstGlyphID() const;
     uint16_t lastGlyphID() const;
     void setLastGlyphID(uint16_t glyphID);
     // Add object to resource list.
     void addResource(SkPDFObject* object);
     // Accessors for FontDescriptor associated with this object.
     SkPDFDict* getFontDescriptor();
     void setFontDescriptor(SkPDFDict* descriptor);
     // Add common entries to FontDescriptor.
     bool addCommonFontDescriptorEntries(int16_t defaultWidth);
     /** Set fFirstGlyphID and fLastGlyphID to span at most 255 glyphs,
      *  including the passed glyphID.
      */
     void adjustGlyphRangeForSingleByteEncoding(int16_t glyphID);
     // Generate ToUnicode table according to glyph usage subset.
     // If subset is NULL, all available glyph ids will be used.
     void populateToUnicodeTable(const SkPDFGlyphSet* subset);
     // Create instances of derived types based on fontInfo.
     static SkPDFFont* Create(SkAdvancedTypefaceMetrics* fontInfo,
                              SkTypeface* typeface, uint16_t glyphID,
                              SkPDFDict* relatedFontDescriptor);
     static bool Find(uint32_t fontID, uint16_t glyphID, int* index);
 private:
     class FontRec {
     public:
         SkPDFFont* fFont;
         uint32_t fFontID;
         uint16_t fGlyphID;
         // A fGlyphID of 0 with no fFont always matches.
         bool operator==(const FontRec& b) const;
         FontRec(SkPDFFont* font, uint32_t fontID, uint16_t fGlyphID);
     };
     SkAutoTUnref<SkTypeface> fTypeface;
     // The glyph IDs accessible with this font.  For Type1 (non CID) fonts,
     // this will be a subset if the font has more than 255 glyphs.
     uint16_t fFirstGlyphID;
     uint16_t fLastGlyphID;
     // The font info is only kept around after construction for large
     // Type1 (non CID) fonts that need multiple "fonts" to access all glyphs.
     SkAutoTUnref<SkAdvancedTypefaceMetrics> fFontInfo;
     SkTDArray<SkPDFObject*> fResources;
     SkAutoTUnref<SkPDFDict> fDescriptor;
     SkAdvancedTypefaceMetrics::FontType fFontType;
     // This should be made a hash table if performance is a problem.
     static SkTDArray<FontRec>& CanonicalFonts();
     static SkBaseMutex& CanonicalFontsMutex();
     typedef SkPDFDict INHERITED;
 };
 #endif

The Tor Browser / annotate

gfx/skia/trunk/src/pdf/SkPDFFont.h@129ffea94266 (annotated)

gfx/skia/trunk/src/pdf/SkPDFFont.h