Don't bother checking pointers before delete[] and FX_Free().

core/src/fpdfapi/fpdf_font/ttgsubtable.h

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #ifndef CORE_SRC_FPDFAPI_FPDF_FONT_TTGSUBTABLE_H_
 #define CORE_SRC_FPDFAPI_FPDF_FONT_TTGSUBTABLE_H_
 
 #include "../../../include/fxge/fx_freetype.h"
@@ skipping 31 matching lines @@
   struct TLangSys {
     TT_uint16_t LookupOrder;
     TT_uint16_t ReqFeatureIndex;
     TT_uint16_t FeatureCount;
     TT_uint16_t* FeatureIndex;
     TLangSys()
         : LookupOrder(0),
           ReqFeatureIndex(0),
           FeatureCount(0),
           FeatureIndex(NULL) {}
-    ~TLangSys() {
-      if (FeatureIndex) {
-        delete[] FeatureIndex;
-      }
-    }
+    ~TLangSys() { delete[] FeatureIndex; }
 
    private:
     TLangSys(const TLangSys&);
     TLangSys& operator=(const TLangSys&);
   };
   struct TLangSysRecord {
     TT_uint32_t LangSysTag;
     struct TLangSys LangSys;
     TLangSysRecord() : LangSysTag(0) {}
 
    private:
     TLangSysRecord(const TLangSysRecord&);
     TLangSysRecord& operator=(const TLangSysRecord&);
   };
   struct TScript {
     TT_uint16_t DefaultLangSys;
     TT_uint16_t LangSysCount;
     struct TLangSysRecord* LangSysRecord;
     TScript() : DefaultLangSys(0), LangSysCount(0), LangSysRecord(NULL) {}
-    ~TScript() {
-      if (LangSysRecord) {
-        delete[] LangSysRecord;
-      }
-    }
+    ~TScript() { delete[] LangSysRecord; }
 
    private:
     TScript(const TScript&);
     TScript& operator=(const TScript&);
   };
   struct TScriptRecord {
     TT_uint32_t ScriptTag;
     struct TScript Script;
     TScriptRecord() : ScriptTag(0) {}
 
    private:
     TScriptRecord(const TScriptRecord&);
     TScriptRecord& operator=(const TScriptRecord&);
   };
   struct TScriptList {
     TT_uint16_t ScriptCount;
     struct TScriptRecord* ScriptRecord;
     TScriptList() : ScriptCount(0), ScriptRecord(NULL) {}
-    ~TScriptList() {
-      if (ScriptRecord) {
-        delete[] ScriptRecord;
-      }
-    }
+    ~TScriptList() { delete[] ScriptRecord; }
 
    private:
     TScriptList(const TScriptList&);
     TScriptList& operator=(const TScriptList&);
   };
   struct TFeature {
     TT_uint16_t FeatureParams;
     int LookupCount;
     TT_uint16_t* LookupListIndex;
     TFeature() : FeatureParams(0), LookupCount(0), LookupListIndex(NULL) {}
-    ~TFeature() {
-      if (LookupListIndex) {
-        delete[] LookupListIndex;
-      }
-    }
+    ~TFeature() { delete[] LookupListIndex; }
 
    private:
     TFeature(const TFeature&);
     TFeature& operator=(const TFeature&);
   };
   struct TFeatureRecord {
     TT_uint32_t FeatureTag;
     struct TFeature Feature;
     TFeatureRecord() : FeatureTag(0) {}
 
    private:
     TFeatureRecord(const TFeatureRecord&);
     TFeatureRecord& operator=(const TFeatureRecord&);
   };
   struct TFeatureList {
     int FeatureCount;
     struct TFeatureRecord* FeatureRecord;
     TFeatureList() : FeatureCount(0), FeatureRecord(NULL) {}
-    ~TFeatureList() {
-      if (FeatureRecord) {
-        delete[] FeatureRecord;
-      }
-    }
+    ~TFeatureList() { delete[] FeatureRecord; }
 
    private:
     TFeatureList(const TFeatureList&);
     TFeatureList& operator=(const TFeatureList&);
   };
   enum TLookupFlag {
     LOOKUPFLAG_RightToLeft = 0x0001,
     LOOKUPFLAG_IgnoreBaseGlyphs = 0x0002,
     LOOKUPFLAG_IgnoreLigatures = 0x0004,
     LOOKUPFLAG_IgnoreMarks = 0x0008,
     LOOKUPFLAG_Reserved = 0x00F0,
     LOOKUPFLAG_MarkAttachmentType = 0xFF00,
   };
   struct TCoverageFormatBase {
     TT_uint16_t CoverageFormat;
     CFX_GlyphMap m_glyphMap;
     TCoverageFormatBase() : CoverageFormat(0) {}
     virtual ~TCoverageFormatBase() {}
 
    private:
     TCoverageFormatBase(const TCoverageFormatBase&);
     TCoverageFormatBase& operator=(const TCoverageFormatBase&);
   };
   struct TCoverageFormat1 : public TCoverageFormatBase {
     TT_uint16_t GlyphCount;
     TT_uint16_t* GlyphArray;
     TCoverageFormat1() : GlyphCount(0), GlyphArray(NULL) { CoverageFormat = 1; }
-    ~TCoverageFormat1() override {
-      if (GlyphArray) {
-        delete[] GlyphArray;
-      }
-    }
+    ~TCoverageFormat1() override { delete[] GlyphArray; }
 
    private:
     TCoverageFormat1(const TCoverageFormat1&);
     TCoverageFormat1& operator=(const TCoverageFormat1&);
   };
   struct TRangeRecord {
     TT_uint16_t Start;
     TT_uint16_t End;
     TT_uint16_t StartCoverageIndex;
     TRangeRecord() : Start(0), End(0), StartCoverageIndex(0) {}
     friend bool operator>(const TRangeRecord& r1, const TRangeRecord& r2) {
       return r1.Start > r2.Start;
     }
 
    private:
     TRangeRecord(const TRangeRecord&);
   };
   struct TCoverageFormat2 : public TCoverageFormatBase {
     TT_uint16_t RangeCount;
     struct TRangeRecord* RangeRecord;
     TCoverageFormat2() : RangeCount(0), RangeRecord(NULL) {
       CoverageFormat = 2;
     }
-    ~TCoverageFormat2() override {
-      if (RangeRecord) {
-        delete[] RangeRecord;
-      }
-    }
+    ~TCoverageFormat2() override { delete[] RangeRecord; }
 
    private:
     TCoverageFormat2(const TCoverageFormat2&);
     TCoverageFormat2& operator=(const TCoverageFormat2&);
   };
   struct TClassDefFormatBase {
     TT_uint16_t ClassFormat;
     TClassDefFormatBase() : ClassFormat(0) {}
     virtual ~TClassDefFormatBase() {}
 
    private:
     TClassDefFormatBase(const TClassDefFormatBase&);
     TClassDefFormatBase& operator=(const TClassDefFormatBase&);
   };
   struct TClassDefFormat1 : public TClassDefFormatBase {
     TT_uint16_t StartGlyph;
     TT_uint16_t GlyphCount;
     TT_uint16_t* ClassValueArray;
     TClassDefFormat1() : StartGlyph(0), GlyphCount(0), ClassValueArray(NULL) {
       ClassFormat = 1;
     }
-    ~TClassDefFormat1() override {
-      if (ClassValueArray) {
-        delete[] ClassValueArray;
-      }
-    }
+    ~TClassDefFormat1() override { delete[] ClassValueArray; }
 
    private:
     TClassDefFormat1(const TClassDefFormat1&);
     TClassDefFormat1& operator=(const TClassDefFormat1&);
   };
   struct TClassRangeRecord {
     TT_uint16_t Start;
     TT_uint16_t End;
     TT_uint16_t Class;
     TClassRangeRecord() : Start(0), End(0), Class(0) {}
 
    private:
     TClassRangeRecord(const TClassRangeRecord&);
     TClassRangeRecord& operator=(const TClassRangeRecord&);
   };
   struct TClassDefFormat2 : public TClassDefFormatBase {
     TT_uint16_t ClassRangeCount;
     struct TClassRangeRecord* ClassRangeRecord;
     TClassDefFormat2() : ClassRangeCount(0), ClassRangeRecord(NULL) {
       ClassFormat = 2;
     }
-    ~TClassDefFormat2() override {
-      if (ClassRangeRecord) {
-        delete[] ClassRangeRecord;
-      }
-    }
+    ~TClassDefFormat2() override { delete[] ClassRangeRecord; }
 
    private:
     TClassDefFormat2(const TClassDefFormat2&);
     TClassDefFormat2& operator=(const TClassDefFormat2&);
   };
   struct TDevice {
     TT_uint16_t StartSize;
     TT_uint16_t EndSize;
     TT_uint16_t DeltaFormat;
     TDevice() : StartSize(0), EndSize(0), DeltaFormat(0) {}
@@ skipping 54 matching lines @@
     }
 
    private:
     TLookup(const TLookup&);
     TLookup& operator=(const TLookup&);
   };
   struct TLookupList {
     int LookupCount;
     struct TLookup* Lookup;
     TLookupList() : LookupCount(0), Lookup(NULL) {}
-    ~TLookupList() {
-      if (Lookup) {
-        delete[] Lookup;
-      }
-    }
+    ~TLookupList() { delete[] Lookup; }
 
    private:
     TLookupList(const TLookupList&);
     TLookupList& operator=(const TLookupList&);
   };
   bool Parse(FT_Bytes scriptlist, FT_Bytes featurelist, FT_Bytes lookuplist);
   void ParseScriptList(FT_Bytes raw, TScriptList* rec);
   void ParseScript(FT_Bytes raw, TScript* rec);
   void ParseLangSys(FT_Bytes raw, TLangSys* rec);
   void ParseFeatureList(FT_Bytes raw, TFeatureList* rec);
@@ skipping 49 matching lines @@
 class CFX_GSUBTable final : public IFX_GSUBTable {
  public:
   ~CFX_GSUBTable() override {}
   virtual FX_BOOL GetVerticalGlyph(FX_DWORD glyphnum,
                                    FX_DWORD* vglyphnum) override;
 
   CFX_CTTGSUBTable m_GsubImp;
 };
 
 #endif  // CORE_SRC_FPDFAPI_FPDF_FONT_TTGSUBTABLE_H_