C++11 override should now be supported by all of {bots,Chrome,Android,Mozilla}

src/ports/SkFontMgr_fontconfig.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDataTable.h"
 #include "SkFontDescriptor.h"
 #include "SkFontHost_FreeType_common.h"
@@ skipping 364 matching lines @@
 
 class SkTypeface_stream : public SkTypeface_FreeType {
 public:
     /** @param stream does not take ownership of the reference, does take ownership of the stream.*/
     SkTypeface_stream(const SkFontStyle& style, bool fixedWidth, int index, SkStreamAsset* stream)
         : INHERITED(style, SkTypefaceCache::NewFontID(), fixedWidth)
         , fStream(stream)
         , fIndex(index)
     { };
 
-    void onGetFamilyName(SkString* familyName) const SK_OVERRIDE {
+    void onGetFamilyName(SkString* familyName) const override {
         familyName->reset();
     }
 
-    void onGetFontDescriptor(SkFontDescriptor* desc, bool* serialize) const SK_OVERRIDE {
+    void onGetFontDescriptor(SkFontDescriptor* desc, bool* serialize) const override {
         desc->setFontIndex(fIndex);
         *serialize = true;
     }
 
-    SkStreamAsset* onOpenStream(int* ttcIndex) const SK_OVERRIDE {
+    SkStreamAsset* onOpenStream(int* ttcIndex) const override {
         *ttcIndex = fIndex;
         return fStream->duplicate();
     }
 
 private:
     SkAutoTDelete<SkStreamAsset> fStream;
     int fIndex;
 
     typedef SkTypeface_FreeType INHERITED;
 };
 
 class SkTypeface_fontconfig : public SkTypeface_FreeType {
 public:
     /** @param pattern takes ownership of the reference. */
     static SkTypeface_fontconfig* Create(FcPattern* pattern) {
         return SkNEW_ARGS(SkTypeface_fontconfig, (pattern));
     }
     mutable SkAutoFcPattern fPattern;
 
-    void onGetFamilyName(SkString* familyName) const SK_OVERRIDE {
+    void onGetFamilyName(SkString* familyName) const override {
         *familyName = get_string(fPattern, FC_FAMILY);
     }
 
-    void onGetFontDescriptor(SkFontDescriptor* desc, bool* serialize) const SK_OVERRIDE {
+    void onGetFontDescriptor(SkFontDescriptor* desc, bool* serialize) const override {
         FCLocker lock;
         desc->setFamilyName(get_string(fPattern, FC_FAMILY));
         desc->setFullName(get_string(fPattern, FC_FULLNAME));
         desc->setPostscriptName(get_string(fPattern, FC_POSTSCRIPT_NAME));
         desc->setFontFileName(get_string(fPattern, FC_FILE));
         desc->setFontIndex(get_int(fPattern, FC_INDEX, 0));
         *serialize = false;
     }
 
-    SkStreamAsset* onOpenStream(int* ttcIndex) const SK_OVERRIDE {
+    SkStreamAsset* onOpenStream(int* ttcIndex) const override {
         FCLocker lock;
         *ttcIndex = get_int(fPattern, FC_INDEX, 0);
         return SkStream::NewFromFile(get_string(fPattern, FC_FILE));
     }
 
     virtual ~SkTypeface_fontconfig() {
         // Hold the lock while unrefing the pattern.
         FCLocker lock;
         fPattern.reset();
     }
@@ skipping 23 matching lines @@
         StyleSet(const SkFontMgr_fontconfig* parent, FcFontSet* fontSet)
             : fFontMgr(SkRef(parent)), fFontSet(fontSet)
         { }
 
         virtual ~StyleSet() {
             // Hold the lock while unrefing the font set.
             FCLocker lock;
             fFontSet.reset();
         }
 
-        int count() SK_OVERRIDE { return fFontSet->nfont; }
+        int count() override { return fFontSet->nfont; }
 
-        void getStyle(int index, SkFontStyle* style, SkString* styleName) SK_OVERRIDE {
+        void getStyle(int index, SkFontStyle* style, SkString* styleName) override {
             if (index < 0 || fFontSet->nfont <= index) {
                 return;
             }
 
             FCLocker lock;
             if (style) {
                 *style = skfontstyle_from_fcpattern(fFontSet->fonts[index]);
             }
             if (styleName) {
                 *styleName = get_string(fFontSet->fonts[index], FC_STYLE);
             }
         }
 
-        SkTypeface* createTypeface(int index) SK_OVERRIDE {
+        SkTypeface* createTypeface(int index) override {
             FCLocker lock;
 
             FcPattern* match = fFontSet->fonts[index];
             return fFontMgr->createTypefaceFromFcPattern(match);
         }
 
-        SkTypeface* matchStyle(const SkFontStyle& style) SK_OVERRIDE {
+        SkTypeface* matchStyle(const SkFontStyle& style) override {
             FCLocker lock;
 
             SkAutoFcPattern pattern;
             fcpattern_from_skfontstyle(style, pattern);
             FcConfigSubstitute(fFontMgr->fFC, pattern, FcMatchPattern);
             FcDefaultSubstitute(pattern);
 
             FcResult result;
             FcFontSet* fontSets[1] = { fFontSet };
             SkAutoFcPattern match(FcFontSetMatch(fFontMgr->fFC,
@@ skipping 94 matching lines @@
         : fFC(config)
         , fFamilyNames(GetFamilyNames(fFC)) { }
 
     virtual ~SkFontMgr_fontconfig() {
         // Hold the lock while unrefing the config.
         FCLocker lock;
         fFC.reset();
     }
 
 protected:
-    int onCountFamilies() const SK_OVERRIDE {
+    int onCountFamilies() const override {
         return fFamilyNames->count();
     }
 
-    void onGetFamilyName(int index, SkString* familyName) const SK_OVERRIDE {
+    void onGetFamilyName(int index, SkString* familyName) const override {
         familyName->set(fFamilyNames->atStr(index));
     }
 
-    SkFontStyleSet* onCreateStyleSet(int index) const SK_OVERRIDE {
+    SkFontStyleSet* onCreateStyleSet(int index) const override {
         return this->onMatchFamily(fFamilyNames->atStr(index));
     }
 
     /** True if any string object value in the font is the same
      *         as a string object value in the pattern.
      */
     static bool AnyMatching(FcPattern* font, FcPattern* pattern, const char* object) {
         FcChar8* fontString;
         FcChar8* patternString;
         FcResult result;
@@ skipping 48 matching lines @@
             if (FcResultMatch != result) {
                 continue;
             }
             if (FcCharSetHasChar(matchCharSet, character)) {
                 return true;
             }
         }
         return false;
     }
 
-    SkFontStyleSet* onMatchFamily(const char familyName[]) const SK_OVERRIDE {
+    SkFontStyleSet* onMatchFamily(const char familyName[]) const override {
         FCLocker lock;
 
         SkAutoFcPattern pattern;
         FcPatternAddString(pattern, FC_FAMILY, (FcChar8*)familyName);
         FcConfigSubstitute(fFC, pattern, FcMatchPattern);
         FcDefaultSubstitute(pattern);
 
         FcPattern* matchPattern;
         SkAutoFcPattern strongPattern(NULL);
         if (familyName) {
@@ skipping 21 matching lines @@
                 if (FontAccessible(font) && FontFamilyNameMatches(font, matchPattern)) {
                     FcFontSetAdd(matches, FcFontRenderPrepare(fFC, pattern, font));
                 }
             }
         }
 
         return SkNEW_ARGS(StyleSet, (this, matches.detach()));
     }
 
     virtual SkTypeface* onMatchFamilyStyle(const char familyName[],
-                                           const SkFontStyle& style) const SK_OVERRIDE
+                                           const SkFontStyle& style) const override
     {
         FCLocker lock;
 
         SkAutoFcPattern pattern;
         FcPatternAddString(pattern, FC_FAMILY, (FcChar8*)familyName);
         fcpattern_from_skfontstyle(style, pattern);
         FcConfigSubstitute(fFC, pattern, FcMatchPattern);
         FcDefaultSubstitute(pattern);
 
         // We really want to match strong (prefered) and same (acceptable) only here.
@@ skipping 20 matching lines @@
             return NULL;
         }
 
         return createTypefaceFromFcPattern(font);
     }
 
     virtual SkTypeface* onMatchFamilyStyleCharacter(const char familyName[],
                                                     const SkFontStyle& style,
                                                     const char* bcp47[],
                                                     int bcp47Count,
-                                                    SkUnichar character) const SK_OVERRIDE
+                                                    SkUnichar character) const override
     {
         FCLocker lock;
 
         SkAutoFcPattern pattern;
         FcPatternAddString(pattern, FC_FAMILY, (FcChar8*)familyName);
         fcpattern_from_skfontstyle(style, pattern);
 
         SkAutoFcCharSet charSet;
         FcCharSetAddChar(charSet, character);
         FcPatternAddCharSet(pattern, FC_CHARSET, charSet);
@@ skipping 13 matching lines @@
         FcResult result;
         SkAutoFcPattern font(FcFontMatch(fFC, pattern, &result));
         if (NULL == font || !FontAccessible(font) || !FontContainsCharacter(font, character)) {
             return NULL;
         }
 
         return createTypefaceFromFcPattern(font);
     }
 
     virtual SkTypeface* onMatchFaceStyle(const SkTypeface* typeface,
-                                         const SkFontStyle& style) const SK_OVERRIDE
+                                         const SkFontStyle& style) const override
     {
         //TODO: should the SkTypeface_fontconfig know its family?
         const SkTypeface_fontconfig* fcTypeface =
                 static_cast<const SkTypeface_fontconfig*>(typeface);
         return this->matchFamilyStyle(get_string(fcTypeface->fPattern, FC_FAMILY), style);
     }
 
-    SkTypeface* onCreateFromStream(SkStreamAsset* bareStream, int ttcIndex) const SK_OVERRIDE {
+    SkTypeface* onCreateFromStream(SkStreamAsset* bareStream, int ttcIndex) const override {
         SkAutoTDelete<SkStreamAsset> stream(bareStream);
         const size_t length = stream->getLength();
         if (length <= 0 || (1u << 30) < length) {
             return NULL;
         }
 
         SkFontStyle style;
         bool isFixedWidth = false;
         if (!fScanner.scanFont(stream, ttcIndex, NULL, &style, &isFixedWidth)) {
             return NULL;
         }
 
         return SkNEW_ARGS(SkTypeface_stream, (style, isFixedWidth, ttcIndex,
                                               static_cast<SkStreamAsset*>(stream.detach())));
     }
 
-    SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const SK_OVERRIDE {
+    SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const override {
         return this->createFromStream(SkNEW_ARGS(SkMemoryStream, (data)), ttcIndex);
     }
 
-    SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const SK_OVERRIDE {
+    SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const override {
         return this->createFromStream(SkStream::NewFromFile(path), ttcIndex);
     }
 
     virtual SkTypeface* onLegacyCreateTypeface(const char familyName[],
-                                               unsigned styleBits) const SK_OVERRIDE {
+                                               unsigned styleBits) const override {
         bool bold = styleBits & SkTypeface::kBold;
         bool italic = styleBits & SkTypeface::kItalic;
         SkFontStyle style = SkFontStyle(bold ? SkFontStyle::kBold_Weight
                                              : SkFontStyle::kNormal_Weight,
                                         SkFontStyle::kNormal_Width,
                                         italic ? SkFontStyle::kItalic_Slant
                                                : SkFontStyle::kUpright_Slant);
         SkAutoTUnref<SkTypeface> typeface(this->matchFamilyStyle(familyName, style));
         if (typeface.get()) {
             return typeface.detach();
         }
 
         return this->matchFamilyStyle(NULL, style);
     }
 };
 
 SkFontMgr* SkFontMgr::Factory() {
     return SkNEW(SkFontMgr_fontconfig);
 }