Merge to XFA: Use override in more classes in core/

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 148 matching lines @@
     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() {
+    ~TCoverageFormat1() override {
       if (GlyphArray) {
         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() {
+    ~TCoverageFormat2() override {
       if (RangeRecord) {
         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() {
+    ~TClassDefFormat1() override {
       if (ClassValueArray) {
         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() {
+    ~TClassDefFormat2() override {
       if (ClassRangeRecord) {
         delete[] ClassRangeRecord;
       }
     }
 
    private:
     TClassDefFormat2(const TClassDefFormat2&);
     TClassDefFormat2& operator=(const TClassDefFormat2&);
   };
   struct TDevice {
@@ skipping 12 matching lines @@
     virtual ~TSubTableBase() {}
 
    private:
     TSubTableBase(const TSubTableBase&);
     TSubTableBase& operator=(const TSubTableBase&);
   };
   struct TSingleSubstFormat1 : public TSubTableBase {
     TCoverageFormatBase* Coverage;
     TT_int16_t DeltaGlyphID;
     TSingleSubstFormat1() : Coverage(NULL), DeltaGlyphID(0) { SubstFormat = 1; }
-    ~TSingleSubstFormat1() { delete Coverage; }
+    ~TSingleSubstFormat1() override { delete Coverage; }
 
    private:
     TSingleSubstFormat1(const TSingleSubstFormat1&);
     TSingleSubstFormat1& operator=(const TSingleSubstFormat1&);
   };
   struct TSingleSubstFormat2 : public TSubTableBase {
     TCoverageFormatBase* Coverage;
     TT_uint16_t GlyphCount;
     TT_uint16_t* Substitute;
     TSingleSubstFormat2() : Coverage(NULL), GlyphCount(0), Substitute(NULL) {
@@ skipping 99 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_