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

src/ports/SkRemotableFontMgr_win_dw.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 "SkDWrite.h"
 #include "SkDWriteFontFileStream.h"
@@ skipping 73 matching lines @@
 
     /** localeNameLength must include the null terminator. */
     SkRemotableFontMgr_DirectWrite(IDWriteFontCollection* fontCollection,
                                    WCHAR* localeName, int localeNameLength)
         : fFontCollection(SkRefComPtr(fontCollection))
         , fLocaleName(localeNameLength)
     {
         memcpy(fLocaleName.get(), localeName, localeNameLength * sizeof(WCHAR));
     }
 
-    SkDataTable* getFamilyNames() const SK_OVERRIDE {
+    SkDataTable* getFamilyNames() const override {
         int count = fFontCollection->GetFontFamilyCount();
 
         SkDataTableBuilder names(1024);
         for (int index = 0; index < count; ++index) {
             SkTScopedComPtr<IDWriteFontFamily> fontFamily;
             HRNM(fFontCollection->GetFontFamily(index, &fontFamily),
                  "Could not get requested family.");
 
             SkTScopedComPtr<IDWriteLocalizedStrings> familyNames;
             HRNM(fontFamily->GetFamilyNames(&familyNames), "Could not get family names.");
@@ skipping 46 matching lines @@
             SkASSERT(false);
         }
 
         int weight = font->GetWeight();
         int width = font->GetStretch();
 
         fontId->fFontStyle = SkFontStyle(weight, width, slant);
         return S_OK;
     }
 
-    SkRemotableFontIdentitySet* getIndex(int familyIndex) const SK_OVERRIDE {
+    SkRemotableFontIdentitySet* getIndex(int familyIndex) const override {
         SkTScopedComPtr<IDWriteFontFamily> fontFamily;
         HRNM(fFontCollection->GetFontFamily(familyIndex, &fontFamily),
              "Could not get requested family.");
 
         int count = fontFamily->GetFontCount();
         SkFontIdentity* fontIds;
         SkAutoTUnref<SkRemotableFontIdentitySet> fontIdSet(
             new SkRemotableFontIdentitySet(count, &fontIds));
         for (int fontIndex = 0; fontIndex < count; ++fontIndex) {
             SkTScopedComPtr<IDWriteFont> font;
             HRNM(fontFamily->GetFont(fontIndex, &font), "Could not get font.");
 
             HRN(FontToIdentity(font.get(), &fontIds[fontIndex]));
         }
         return fontIdSet.detach();
     }
 
     virtual SkFontIdentity matchIndexStyle(int familyIndex,
-                                           const SkFontStyle& pattern) const SK_OVERRIDE
+                                           const SkFontStyle& pattern) const override
     {
         SkFontIdentity identity = { SkFontIdentity::kInvalidDataId };
 
         SkTScopedComPtr<IDWriteFontFamily> fontFamily;
         HR_GENERAL(fFontCollection->GetFontFamily(familyIndex, &fontFamily),
                    "Could not get requested family.",
                    identity);
 
         const DWriteStyle dwStyle(pattern);
         SkTScopedComPtr<IDWriteFont> font;
@@ skipping 18 matching lines @@
         }
 
         size_t len = wcsnlen_s(metrics.lfMessageFont.lfFaceName, LF_FACESIZE) + 1;
         if (0 != wcsncpy_s(name->reset(len), len, metrics.lfMessageFont.lfFaceName, _TRUNCATE)) {
             return E_UNEXPECTED;
         }
 
         return S_OK;
     }
 
-    SkRemotableFontIdentitySet* matchName(const char familyName[]) const SK_OVERRIDE {
+    SkRemotableFontIdentitySet* matchName(const char familyName[]) const override {
         SkSMallocWCHAR dwFamilyName;
         if (NULL == familyName) {
             HR_GENERAL(getDefaultFontFamilyName(&dwFamilyName),
                        NULL, SkRemotableFontIdentitySet::NewEmpty());
         } else {
             HR_GENERAL(sk_cstring_to_wchar(familyName, &dwFamilyName),
                        NULL, SkRemotableFontIdentitySet::NewEmpty());
         }
 
         UINT32 index;
         BOOL exists;
         HR_GENERAL(fFontCollection->FindFamilyName(dwFamilyName.get(), &index, &exists),
                    "Failed while finding family by name.",
                    SkRemotableFontIdentitySet::NewEmpty());
         if (!exists) {
             return SkRemotableFontIdentitySet::NewEmpty();
         }
 
         return this->getIndex(index);
     }
 
     virtual SkFontIdentity matchNameStyle(const char familyName[],
-                                          const SkFontStyle& style) const SK_OVERRIDE
+                                          const SkFontStyle& style) const override
     {
         SkFontIdentity identity = { SkFontIdentity::kInvalidDataId };
 
         SkSMallocWCHAR dwFamilyName;
         if (NULL == familyName) {
             HR_GENERAL(getDefaultFontFamilyName(&dwFamilyName), NULL, identity);
         } else {
             HR_GENERAL(sk_cstring_to_wchar(familyName, &dwFamilyName), NULL, identity);
         }
 
@@ skipping 19 matching lines @@
         virtual ~FontFallbackRenderer() { }
 
         // IDWriteTextRenderer methods
         virtual HRESULT STDMETHODCALLTYPE DrawGlyphRun(
             void* clientDrawingContext,
             FLOAT baselineOriginX,
             FLOAT baselineOriginY,
             DWRITE_MEASURING_MODE measuringMode,
             DWRITE_GLYPH_RUN const* glyphRun,
             DWRITE_GLYPH_RUN_DESCRIPTION const* glyphRunDescription,
-            IUnknown* clientDrawingEffect) SK_OVERRIDE
+            IUnknown* clientDrawingEffect) override
         {
             SkTScopedComPtr<IDWriteFont> font;
             HRM(fOuter->fFontCollection->GetFontFromFontFace(glyphRun->fontFace, &font),
                 "Could not get font from font face.");
 
             // It is possible that the font passed does not actually have the requested character,
             // due to no font being found and getting the fallback font.
             // Check that the font actually contains the requested character.
             BOOL exists;
             HRM(font->HasCharacter(fCharacter, &exists), "Could not find character.");
 
             if (exists) {
                 HR(fOuter->FontToIdentity(font.get(), &fIdentity));
             }
 
             return S_OK;
         }
 
         virtual HRESULT STDMETHODCALLTYPE DrawUnderline(
             void* clientDrawingContext,
             FLOAT baselineOriginX,
             FLOAT baselineOriginY,
             DWRITE_UNDERLINE const* underline,
-            IUnknown* clientDrawingEffect) SK_OVERRIDE
+            IUnknown* clientDrawingEffect) override
         { return E_NOTIMPL; }
 
         virtual HRESULT STDMETHODCALLTYPE DrawStrikethrough(
             void* clientDrawingContext,
             FLOAT baselineOriginX,
             FLOAT baselineOriginY,
             DWRITE_STRIKETHROUGH const* strikethrough,
-            IUnknown* clientDrawingEffect) SK_OVERRIDE
+            IUnknown* clientDrawingEffect) override
         { return E_NOTIMPL; }
 
         virtual HRESULT STDMETHODCALLTYPE DrawInlineObject(
             void* clientDrawingContext,
             FLOAT originX,
             FLOAT originY,
             IDWriteInlineObject* inlineObject,
             BOOL isSideways,
             BOOL isRightToLeft,
-            IUnknown* clientDrawingEffect) SK_OVERRIDE
+            IUnknown* clientDrawingEffect) override
         { return E_NOTIMPL; }
 
         // IDWritePixelSnapping methods
         virtual HRESULT STDMETHODCALLTYPE IsPixelSnappingDisabled(
             void* clientDrawingContext,
-            BOOL* isDisabled) SK_OVERRIDE
+            BOOL* isDisabled) override
         {
             *isDisabled = FALSE;
             return S_OK;
         }
 
         virtual HRESULT STDMETHODCALLTYPE GetCurrentTransform(
             void* clientDrawingContext,
-            DWRITE_MATRIX* transform) SK_OVERRIDE
+            DWRITE_MATRIX* transform) override
         {
             const DWRITE_MATRIX ident = {1.0, 0.0, 0.0, 1.0, 0.0, 0.0};
             *transform = ident;
             return S_OK;
         }
 
         virtual HRESULT STDMETHODCALLTYPE GetPixelsPerDip(
             void* clientDrawingContext,
-            FLOAT* pixelsPerDip) SK_OVERRIDE
+            FLOAT* pixelsPerDip) override
         {
             *pixelsPerDip = 1.0f;
             return S_OK;
         }
 
         // IUnknown methods
-        ULONG STDMETHODCALLTYPE AddRef() SK_OVERRIDE {
+        ULONG STDMETHODCALLTYPE AddRef() override {
             return InterlockedIncrement(&fRefCount);
         }
 
-        ULONG STDMETHODCALLTYPE Release() SK_OVERRIDE {
+        ULONG STDMETHODCALLTYPE Release() override {
             ULONG newCount = InterlockedDecrement(&fRefCount);
             if (0 == newCount) {
                 delete this;
             }
             return newCount;
         }
 
         virtual HRESULT STDMETHODCALLTYPE QueryInterface(
-            IID const& riid, void** ppvObject) SK_OVERRIDE
+            IID const& riid, void** ppvObject) override
         {
             if (__uuidof(IUnknown) == riid ||
                 __uuidof(IDWritePixelSnapping) == riid ||
                 __uuidof(IDWriteTextRenderer) == riid)
             {
                 *ppvObject = this;
                 this->AddRef();
                 return S_OK;
             }
             *ppvObject = NULL;
             return E_FAIL;
         }
 
         const SkFontIdentity FallbackIdentity() { return fIdentity; }
 
     protected:
         ULONG fRefCount;
         SkAutoTUnref<const SkRemotableFontMgr_DirectWrite> fOuter;
         UINT32 fCharacter;
         SkFontIdentity fIdentity;
     };
 
     virtual SkFontIdentity matchNameStyleCharacter(const char familyName[],
                                                    const SkFontStyle& pattern,
                                                    const char* bcp47[], int bcp47Count,
-                                                   SkUnichar character) const SK_OVERRIDE
+                                                   SkUnichar character) const override
     {
         SkFontIdentity identity = { SkFontIdentity::kInvalidDataId };
 
         IDWriteFactory* dwFactory = sk_get_dwrite_factory();
         if (NULL == dwFactory) {
             return identity;
         }
 
         // TODO: use IDWriteFactory2::GetSystemFontFallback when available.
 
@@ skipping 41 matching lines @@
         SkTScopedComPtr<FontFallbackRenderer> fontFallbackRenderer(
             new FontFallbackRenderer(this, character));
 
         HR_GENERAL(fallbackLayout->Draw(NULL, fontFallbackRenderer.get(), 50.0f, 50.0f),
                    "Could not draw layout with renderer.",
                    identity);
 
         return fontFallbackRenderer->FallbackIdentity();
     }
 
-    SkStreamAsset* getData(int dataId) const SK_OVERRIDE {
+    SkStreamAsset* getData(int dataId) const override {
         SkAutoMutexAcquire ama(fDataIdCacheMutex);
         if (dataId >= fDataIdCache.count()) {
             return NULL;
         }
         const DataId& id = fDataIdCache[dataId];
 
         SkTScopedComPtr<IDWriteFontFileLoader> loader;
         HRNM(id.fLoader->QueryInterface(&loader), "QuerryInterface IDWriteFontFileLoader failed");
 
         SkTScopedComPtr<IDWriteFontFileStream> fontFileStream;
@@ skipping 32 matching lines @@
     } else {
         localeNameLen = getUserDefaultLocaleNameProc(localeNameStorage, LOCALE_NAME_MAX_LENGTH);
         if (localeNameLen) {
             localeName = localeNameStorage;
         };
     }
 
     return SkNEW_ARGS(SkRemotableFontMgr_DirectWrite, (sysFontCollection.get(),
                                                        localeName, localeNameLen));
 }