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

src/fonts/SkFontMgr_fontconfig.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkFontMgr.h"
 #include "SkFontStyle.h"
 #include "SkFontConfigInterface.h"
@@ skipping 124 matching lines @@
 
     *count = iter - firstIter;
     return firstIter;
 }
 
 class SkFontStyleSet_FC : public SkFontStyleSet {
 public:
     SkFontStyleSet_FC(FcPattern** matches, int count);
     virtual ~SkFontStyleSet_FC();
 
-    int count() SK_OVERRIDE { return fRecCount; }
-    void getStyle(int index, SkFontStyle*, SkString* style) SK_OVERRIDE;
-    SkTypeface* createTypeface(int index) SK_OVERRIDE;
-    SkTypeface* matchStyle(const SkFontStyle& pattern) SK_OVERRIDE;
+    int count() override { return fRecCount; }
+    void getStyle(int index, SkFontStyle*, SkString* style) override;
+    SkTypeface* createTypeface(int index) override;
+    SkTypeface* matchStyle(const SkFontStyle& pattern) override;
 
 private:
     struct Rec {
         SkString    fStyleName;
         SkString    fFileName;
         SkFontStyle fStyle;
     };
     Rec* fRecs;
     int  fRecCount;
 };
@@ skipping 60 matching lines @@
 public:
     SkFontMgr_fontconfig(SkFontConfigInterface* fci)
         : fFCI(fci)
         , fFamilyNames(fFCI->getFamilyNames()) {}
 
     virtual ~SkFontMgr_fontconfig() {
         SkSafeUnref(fFamilyNames);
     }
 
 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));
     }
 
-    SkFontStyleSet* onMatchFamily(const char familyName[]) const SK_OVERRIDE {
+    SkFontStyleSet* onMatchFamily(const char familyName[]) const override {
         FCLocker lock;
 
         FcPattern* pattern = FcPatternCreate();
 
         FcPatternAddString(pattern, FC_FAMILY, (FcChar8*)familyName);
 #if 0
         FcPatternAddBool(pattern, FC_SCALABLE, FcTrue);
 #endif
         FcConfigSubstitute(NULL, pattern, FcMatchPattern);
         FcDefaultSubstitute(pattern);
@@ skipping 25 matching lines @@
             }
         }
 
         SkFontStyleSet_FC* sset = SkNEW_ARGS(SkFontStyleSet_FC,
                                              (trimmedMatches.begin(),
                                               trimmedMatches.count()));
         return sset;
     }
 
     virtual SkTypeface* onMatchFamilyStyle(const char familyName[],
-                                           const SkFontStyle&) const SK_OVERRIDE { return NULL; }
+                                           const SkFontStyle&) const override { return NULL; }
     virtual SkTypeface* onMatchFamilyStyleCharacter(const char familyName[], const SkFontStyle&,
                                                     const char* bcp47[], int bcp47Count,
-                                                    SkUnichar character) const SK_OVERRIDE {
+                                                    SkUnichar character) const override {
         return NULL;
     }
     virtual SkTypeface* onMatchFaceStyle(const SkTypeface*,
-                                         const SkFontStyle&) const SK_OVERRIDE { return NULL; }
+                                         const SkFontStyle&) const override { return NULL; }
 
-    SkTypeface* onCreateFromData(SkData*, int ttcIndex) const SK_OVERRIDE { return NULL; }
+    SkTypeface* onCreateFromData(SkData*, int ttcIndex) const override { return NULL; }
 
-    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) {
             return NULL;
         }
         if (length >= 1024 * 1024 * 1024) {
             return NULL;  // don't accept too large fonts (>= 1GB) for safety.
         }
 
         // TODO should the caller give us the style or should we get it from freetype?
         SkFontStyle style;
         bool isFixedWidth = false;
         if (!fScanner.scanFont(stream, 0, NULL, &style, &isFixedWidth)) {
             return NULL;
         }
 
         SkTypeface* face = FontConfigTypeface::Create(style, isFixedWidth, stream.detach());
         return face;
     }
 
-    SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const SK_OVERRIDE {
+    SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const override {
         SkAutoTDelete<SkStreamAsset> stream(SkStream::NewFromFile(path));
         return stream.get() ? this->createFromStream(stream.detach(), ttcIndex) : NULL;
     }
 
     virtual SkTypeface* onLegacyCreateTypeface(const char familyName[],
-                                               unsigned styleBits) const SK_OVERRIDE {
+                                               unsigned styleBits) const override {
         FCLocker lock;
         return FontConfigTypeface::LegacyCreateTypeface(familyName, (SkTypeface::Style)styleBits);
     }
 };
 
 SkFontMgr* SkFontMgr::Factory() {
     SkFontConfigInterface* fci = RefFCI();
     return fci ? SkNEW_ARGS(SkFontMgr_fontconfig, (fci)) : NULL;
 }