The Tor Browser: gfx/thebes/gfxMathTable.cpp@97036ab72558 (annotated)

gfx/thebes/gfxMathTable.cpp@97036ab72558 (annotated)

gfx/thebes/gfxMathTable.cpp

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.

 /* 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/. */
 #include "gfxMathTable.h"
 #include "MathTableStructures.h"
 #include "harfbuzz/hb.h"
 #include <algorithm>
 using namespace mozilla;
 gfxMathTable::gfxMathTable(hb_blob_t* aMathTable)
   : mMathTable(aMathTable)
   , mGlyphConstruction(nullptr)
   , mGlyphID(-1)
   , mVertical(false)
 {
 }
 gfxMathTable::~gfxMathTable()
 {
   hb_blob_destroy(mMathTable);
 }
 bool
 gfxMathTable::HasValidHeaders()
 {
   const char* mathData = hb_blob_get_data(mMathTable, nullptr);
   // Verify the MATH table header.
   if (!ValidStructure(mathData, sizeof(MATHTableHeader))) {
     return false;
   }
   const MATHTableHeader* header = GetMATHTableHeader();
   if (uint32_t(header->mVersion) != 0x00010000 ||
       !ValidOffset(mathData, uint16_t(header->mMathConstants)) ||
       !ValidOffset(mathData, uint16_t(header->mMathGlyphInfo)) ||
       !ValidOffset(mathData, uint16_t(header->mMathVariants))) {
     return false;
   }
   // Verify the MathConstants header.
   const MathConstants* mathconstants = GetMathConstants();
   const char* start = reinterpret_cast<const char*>(mathconstants);
   if (!ValidStructure(start, sizeof(MathConstants))) {
     return false;
   }
   // Verify the MathGlyphInfo header.
   const MathGlyphInfo* mathglyphinfo = GetMathGlyphInfo();
   start = reinterpret_cast<const char*>(mathglyphinfo);
   if (!ValidStructure(start, sizeof(MathGlyphInfo))) {
     return false;
   }
   // Verify the MathVariants header.
   const MathVariants* mathvariants = GetMathVariants();
   start = reinterpret_cast<const char*>(mathvariants);
   if (!ValidStructure(start, sizeof(MathVariants)) ||
       !ValidStructure(start,
                       sizeof(MathVariants) + sizeof(Offset) *
                       (uint16_t(mathvariants->mVertGlyphCount) +
                        uint16_t(mathvariants->mHorizGlyphCount))) ||
       !ValidOffset(start, uint16_t(mathvariants->mVertGlyphCoverage)) ||
       !ValidOffset(start, uint16_t(mathvariants->mHorizGlyphCoverage))) {
     return false;
   }
   return true;
 }
 int32_t
 gfxMathTable::GetMathConstant(gfxFontEntry::MathConstant aConstant)
 {
   const MathConstants* mathconstants = GetMathConstants();
   if (aConstant <= gfxFontEntry::ScriptScriptPercentScaleDown) {
     return int16_t(mathconstants->mInt16[aConstant]);
   }
   if (aConstant <= gfxFontEntry::DisplayOperatorMinHeight) {
     return
       uint16_t(mathconstants->
                mUint16[aConstant - gfxFontEntry::DelimitedSubFormulaMinHeight]);
   }
   if (aConstant <= gfxFontEntry::RadicalKernAfterDegree) {
     return int16_t(mathconstants->
                    mMathValues[aConstant - gfxFontEntry::MathLeading].mValue);
   }
   return uint16_t(mathconstants->mRadicalDegreeBottomRaisePercent);
 }
 bool
 gfxMathTable::GetMathItalicsCorrection(uint32_t aGlyphID,
                                        int16_t* aItalicCorrection)
 {
   const MathGlyphInfo* mathglyphinfo = GetMathGlyphInfo();
   // Get the offset of the italic correction and verify whether it is valid.
   const char* start = reinterpret_cast<const char*>(mathglyphinfo);
   uint16_t offset = mathglyphinfo->mMathItalicsCorrectionInfo;
   if (offset == 0 || !ValidOffset(start, offset)) {
     return false;
   }
   start += offset;
   // Verify the validity of the MathItalicsCorrectionInfo and retrieve it.
   if (!ValidStructure(start, sizeof(MathItalicsCorrectionInfo))) {
     return false;
   }
   const MathItalicsCorrectionInfo* italicsCorrectionInfo =
     reinterpret_cast<const MathItalicsCorrectionInfo*>(start);
   // Get the coverage index for the glyph.
   offset = italicsCorrectionInfo->mCoverage;
   const Coverage* coverage =
     reinterpret_cast<const Coverage*>(start + offset);
   int32_t i = GetCoverageIndex(coverage, aGlyphID);
   // Get the ItalicsCorrection.
   uint16_t count = italicsCorrectionInfo->mItalicsCorrectionCount;
   if (i < 0 || i >= count) {
     return false;
   }
   start = reinterpret_cast<const char*>(italicsCorrectionInfo + 1);
   if (!ValidStructure(start, count * sizeof(MathValueRecord))) {
     return false;
   }
   const MathValueRecord* mathValueRecordArray =
     reinterpret_cast<const MathValueRecord*>(start);
   *aItalicCorrection = int16_t(mathValueRecordArray[i].mValue);
   return true;
 }
 uint32_t
 gfxMathTable::GetMathVariantsSize(uint32_t aGlyphID, bool aVertical,
                                   uint16_t aSize)
 {
   // Select the glyph construction.
   SelectGlyphConstruction(aGlyphID, aVertical);
   if (!mGlyphConstruction) {
     return 0;
   }
   // Verify the validity of the array of the MathGlyphVariantRecord's and
   // whether there is a variant of the requested size.
   uint16_t count = mGlyphConstruction->mVariantCount;
   const char* start = reinterpret_cast<const char*>(mGlyphConstruction + 1);
   if (aSize >= count ||
       !ValidStructure(start, count * sizeof(MathGlyphVariantRecord))) {
     return 0;
   }
   // Return the glyph index of the requested size variant.
   const MathGlyphVariantRecord* recordArray =
     reinterpret_cast<const MathGlyphVariantRecord*>(start);
   return uint32_t(recordArray[aSize].mVariantGlyph);
 }
 bool
 gfxMathTable::GetMathVariantsParts(uint32_t aGlyphID, bool aVertical,
                                    uint32_t aGlyphs[4])
 {
   // Get the glyph assembly corresponding to that (aGlyphID, aVertical) pair.
   const GlyphAssembly* glyphAssembly = GetGlyphAssembly(aGlyphID, aVertical);
   if (!glyphAssembly) {
     return false;
   }
   // Verify the validity of the array of GlyphPartRecord's and retrieve it.
   uint16_t count = glyphAssembly->mPartCount;
   const char* start = reinterpret_cast<const char*>(glyphAssembly + 1);
   if (!ValidStructure(start, count * sizeof(GlyphPartRecord))) {
     return false;
   }
   const GlyphPartRecord* recordArray =
     reinterpret_cast<const GlyphPartRecord*>(start);
   // XXXfredw The structure of the Open Type Math table is a bit more general
   // than the one currently used by the nsMathMLChar code, so we try to fallback
   // in reasonable way. We use the approach of the copyComponents function in
   // github.com/mathjax/MathJax-dev/blob/master/fonts/OpenTypeMath/fontUtil.py
   //
   // The nsMathMLChar code can use at most 3 non extender pieces (aGlyphs[0],
   // aGlyphs[1] and aGlyphs[2]) and the extenders between these pieces should
   // all be the same (aGlyphs[4]). Also, the parts of vertical assembly are
   // stored from bottom to top in the Open Type MATH table while they are
   // stored from top to bottom in nsMathMLChar.
   // Count the number of non extender pieces
   uint16_t nonExtenderCount = 0;
   for (uint16_t i = 0; i < count; i++) {
     if (!(uint16_t(recordArray[i].mPartFlags) & PART_FLAG_EXTENDER)) {
       nonExtenderCount++;
     }
   }
   if (nonExtenderCount > 3) {
     // Not supported: too many pieces
     return false;
   }
   // Now browse the list of pieces
   // 0 = look for a left/bottom glyph
   // 1 = look for an extender between left/bottom and mid
   // 2 = look for a middle glyph
   // 3 = look for an extender between middle and right/top
   // 4 = look for a right/top glyph
   // 5 = no more piece expected
   uint8_t state = 0;
   // First extender char found.
   uint32_t extenderChar = 0;
   // Clear the aGlyphs table.
   memset(aGlyphs, 0, sizeof(uint32_t) * 4);
   for (uint16_t i = 0; i < count; i++) {
     bool isExtender = uint16_t(recordArray[i].mPartFlags) & PART_FLAG_EXTENDER;
     uint32_t glyph = recordArray[i].mGlyph;
     if ((state == 1 || state == 2) && nonExtenderCount < 3) {
       // do not try to find a middle glyph
       state += 2;
     }
     if (isExtender) {
       if (!extenderChar) {
         extenderChar = glyph;
         aGlyphs[3] = extenderChar;
       } else if (extenderChar != glyph)  {
         // Not supported: different extenders
         return false;
       }
       if (state == 0) { // or state == 1
         // ignore left/bottom piece and multiple successive extenders
         state = 1;
       } else if (state == 2) { // or state == 3
         // ignore middle piece and multiple successive extenders
         state = 3;
       } else if (state >= 4) {
         // Not supported: unexpected extender
         return false;
       }
       continue;
     }
     if (state == 0) {
       // copy left/bottom part
       aGlyphs[mVertical ? 2 : 0] = glyph;
       state = 1;
       continue;
     }
     if (state == 1 || state == 2) {
       // copy middle part
       aGlyphs[1] = glyph;
       state = 3;
       continue;
     }
     if (state == 3 || state == 4) {
       // copy right/top part
       aGlyphs[mVertical ? 0 : 2] = glyph;
       state = 5;
     }
   }
   return true;
 }
 bool
 gfxMathTable::ValidStructure(const char* aStart, uint16_t aSize)
 {
   unsigned int mathDataLength;
   const char* mathData = hb_blob_get_data(mMathTable, &mathDataLength);
   return (mathData <= aStart &&
           aStart + aSize <= mathData + mathDataLength);
 }
 bool
 gfxMathTable::ValidOffset(const char* aStart, uint16_t aOffset)
 {
   unsigned int mathDataLength;
   const char* mathData = hb_blob_get_data(mMathTable, &mathDataLength);
   return (mathData <= aStart + aOffset &&
           aStart + aOffset < mathData + mathDataLength);
 }
 const MATHTableHeader*
 gfxMathTable::GetMATHTableHeader()
 {
   const char* mathData = hb_blob_get_data(mMathTable, nullptr);
   return reinterpret_cast<const MATHTableHeader*>(mathData);
 }
 const MathConstants*
 gfxMathTable::GetMathConstants()
 {
   const char* mathData = hb_blob_get_data(mMathTable, nullptr);
   return
     reinterpret_cast<const MathConstants*>(mathData +
                                            uint16_t(GetMATHTableHeader()->
                                                     mMathConstants));
 }
 const MathGlyphInfo*
 gfxMathTable::GetMathGlyphInfo()
 {
   const char* mathData = hb_blob_get_data(mMathTable, nullptr);
   return
     reinterpret_cast<const MathGlyphInfo*>(mathData +
                                            uint16_t(GetMATHTableHeader()->
                                                     mMathGlyphInfo));
 }
 const MathVariants*
 gfxMathTable::GetMathVariants()
 {
   const char* mathData = hb_blob_get_data(mMathTable, nullptr);
   return
     reinterpret_cast<const MathVariants*>(mathData +
                                           uint16_t(GetMATHTableHeader()->
                                                    mMathVariants));
 }
 const GlyphAssembly*
 gfxMathTable::GetGlyphAssembly(uint32_t aGlyphID, bool aVertical)
 {
   // Select the glyph construction.
   SelectGlyphConstruction(aGlyphID, aVertical);
   if (!mGlyphConstruction) {
     return nullptr;
   }
   // Get the offset of the glyph assembly and verify whether it is valid.
   const char* start = reinterpret_cast<const char*>(mGlyphConstruction);
   uint16_t offset = mGlyphConstruction->mGlyphAssembly;
   if (offset == 0 || !ValidOffset(start, offset)) {
     return nullptr;
   }
   start += offset;
   // Verify the validity of the GlyphAssembly and return it.
   if (!ValidStructure(start, sizeof(GlyphAssembly))) {
     return nullptr;
   }
   return reinterpret_cast<const GlyphAssembly*>(start);
 }
 int32_t
 gfxMathTable::GetCoverageIndex(const Coverage* aCoverage, uint32_t aGlyph)
 {
   if (uint16_t(aCoverage->mFormat) == 1) {
     // Coverage Format 1: list of individual glyph indices in the glyph set.
     const CoverageFormat1* table =
       reinterpret_cast<const CoverageFormat1*>(aCoverage);
     uint16_t count = table->mGlyphCount;
     const char* start = reinterpret_cast<const char*>(table + 1);
     if (ValidStructure(start, count * sizeof(GlyphID))) {
       const GlyphID* glyphArray =
         reinterpret_cast<const GlyphID*>(start);
       uint32_t imin = 0, imax = count;
       while (imin < imax) {
         uint32_t imid = (imin + imax) >> 1;
         uint16_t glyphMid = glyphArray[imid];
         if (glyphMid == aGlyph) {
           return imid;
         }
         if (glyphMid < aGlyph) {
           imin = imid + 1;
         } else {
           imax = imid;
         }
       }
     }
   } else if (uint16_t(aCoverage->mFormat) == 2) {
     // Coverage Format 2: ranges of consecutive indices.
     const CoverageFormat2* table =
       reinterpret_cast<const CoverageFormat2*>(aCoverage);
     uint16_t count = table->mRangeCount;
     const char* start = reinterpret_cast<const char*>(table + 1);
     if (ValidStructure(start, count * sizeof(RangeRecord))) {
       const RangeRecord* rangeArray =
         reinterpret_cast<const RangeRecord*>(start);
       uint32_t imin = 0, imax = count;
       while (imin < imax) {
         uint32_t imid = (imin + imax) >> 1;
         uint16_t rStart = rangeArray[imid].mStart;
         uint16_t rEnd = rangeArray[imid].mEnd;
         if (rEnd < aGlyph) {
           imin = imid + 1;
         } else if (aGlyph < rStart) {
           imax = imid;
         } else {
           return (uint16_t(rangeArray[imid].mStartCoverageIndex) +
                   aGlyph - rStart);
         }
       }
     }
   }
   return -1;
 }
 void
 gfxMathTable::SelectGlyphConstruction(uint32_t aGlyphID, bool aVertical)
 {
   if (mGlyphID == aGlyphID && mVertical == aVertical) {
     // The (glyph, direction) pair is already selected: nothing to do.
     return;
   }
   // Update our cached values.
   mVertical = aVertical;
   mGlyphID = aGlyphID;
   mGlyphConstruction = nullptr;
   // Get the coverage index for the new values.
   const MathVariants* mathvariants = GetMathVariants();
   const char* start = reinterpret_cast<const char*>(mathvariants);
   uint16_t offset = (aVertical ?
                      mathvariants->mVertGlyphCoverage :
                      mathvariants->mHorizGlyphCoverage);
   const Coverage* coverage =
     reinterpret_cast<const Coverage*>(start + offset);
   int32_t i = GetCoverageIndex(coverage, aGlyphID);
   // Get the offset to the glyph construction.
   uint16_t count = (aVertical ?
                     mathvariants->mVertGlyphCount :
                     mathvariants->mHorizGlyphCount);
   start = reinterpret_cast<const char*>(mathvariants + 1);
   if (i < 0 || i >= count) {
     return;
   }
   if (!aVertical) {
     start += uint16_t(mathvariants->mVertGlyphCount) * sizeof(Offset);
   }
   if (!ValidStructure(start, count * sizeof(Offset))) {
     return;
   }
   const Offset* offsetArray = reinterpret_cast<const Offset*>(start);
   offset = uint16_t(offsetArray[i]);
   // Make mGlyphConstruction point to the desired glyph construction.
   start = reinterpret_cast<const char*>(mathvariants);
   if (!ValidStructure(start + offset, sizeof(MathGlyphConstruction))) {
     return;
   }
   mGlyphConstruction =
     reinterpret_cast<const MathGlyphConstruction*>(start + offset);
 }

The Tor Browser / annotate

gfx/thebes/gfxMathTable.cpp@97036ab72558 (annotated)

gfx/thebes/gfxMathTable.cpp