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

dm/DMSrcSink.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "DMSrcSink.h"
 #include "SamplePipeControllers.h"
 #include "SkCommonFlags.h"
@@ skipping 432 matching lines @@
     // We turn our arguments into a Src, then draw that Src into our Sink to fill bitmap or stream.
     struct ProxySrc : public Src {
         const Src&  fSrc;
         SkMatrix    fMatrix;
         SkISize     fSize;
 
         ProxySrc(const Src& src, SkMatrix matrix) : fSrc(src), fMatrix(matrix) {
             fSize = auto_compute_translate(&fMatrix, src.size().width(), src.size().height());
         }
 
-        Error draw(SkCanvas* canvas) const SK_OVERRIDE {
+        Error draw(SkCanvas* canvas) const override {
             canvas->concat(fMatrix);
             return fSrc.draw(canvas);
         }
-        SkISize size() const SK_OVERRIDE { return fSize; }
-        Name name() const SK_OVERRIDE { sk_throw(); return ""; }  // No one should be calling this.
+        SkISize size() const override { return fSize; }
+        Name name() const override { sk_throw(); return ""; }  // No one should be calling this.
     } proxy(src, fMatrix);
     return fSink->draw(proxy, bitmap, stream, log);
 }
 
 // Undoes any flip or 90 degree rotate without changing the scale of the bitmap.
 // This should be pixel-preserving.
 ViaUpright::ViaUpright(SkMatrix matrix, Sink* sink) : fMatrix(matrix), fSink(sink) {}
 
 Error ViaUpright::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
     Error err = fSink->draw(src, bitmap, stream, log);
@@ skipping 29 matching lines @@
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 ViaPipe::ViaPipe(Sink* sink) : fSink(sink) {}
 
 Error ViaPipe::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log) const {
     // We turn ourselves into another Src that draws our argument into bitmap/stream via pipe.
     struct ProxySrc : public Src {
         const Src& fSrc;
         ProxySrc(const Src& src) : fSrc(src) {}
 
-        Error draw(SkCanvas* canvas) const SK_OVERRIDE {
+        Error draw(SkCanvas* canvas) const override {
             SkISize size = this->size();
             PipeController controller(canvas, &SkImageDecoder::DecodeMemory);
             SkGPipeWriter pipe;
             const uint32_t kFlags = 0; // We mirror SkDeferredCanvas, which doesn't use any flags.
             return fSrc.draw(pipe.startRecording(&controller, kFlags, size.width(), size.height()));
         }
-        SkISize size() const SK_OVERRIDE { return fSrc.size(); }
-        Name name() const SK_OVERRIDE { sk_throw(); return ""; }  // No one should be calling this.
+        SkISize size() const override { return fSrc.size(); }
+        Name name() const override { sk_throw(); return ""; }  // No one should be calling this.
     } proxy(src);
     return fSink->draw(proxy, bitmap, stream, log);
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 ViaSerialization::ViaSerialization(Sink* sink) : fSink(sink) {}
 
 Error ViaSerialization::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkString* log)
     const {
@@ skipping 12 matching lines @@
     pic->serialize(&wStream);
     SkAutoTDelete<SkStream> rStream(wStream.detachAsStream());
     SkAutoTUnref<SkPicture> deserialized(SkPicture::CreateFromStream(rStream, &lazy_decode_bitmap));
 
     // Turn that deserialized picture into a Src, draw it into our Sink to fill bitmap or stream.
     struct ProxySrc : public Src {
         const SkPicture* fPic;
         const SkISize fSize;
         ProxySrc(const SkPicture* pic, SkISize size) : fPic(pic), fSize(size) {}
 
-        Error draw(SkCanvas* canvas) const SK_OVERRIDE {
+        Error draw(SkCanvas* canvas) const override {
             canvas->drawPicture(fPic);
             return "";
         }
-        SkISize size() const SK_OVERRIDE { return fSize; }
-        Name name() const SK_OVERRIDE { sk_throw(); return ""; }  // No one should be calling this.
+        SkISize size() const override { return fSize; }
+        Name name() const override { sk_throw(); return ""; }  // No one should be calling this.
     } proxy(deserialized, src.size());
     return fSink->draw(proxy, bitmap, stream, log);
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 ViaTiles::ViaTiles(int w, int h, SkBBHFactory* factory, Sink* sink)
     : fW(w)
     , fH(h)
     , fFactory(factory)
@@ skipping 11 matching lines @@
     SkAutoTUnref<SkPicture> pic(recorder.endRecording());
 
     // Turn that picture into a Src that draws into our Sink via tiles + MPD.
     struct ProxySrc : public Src {
         const int fW, fH;
         const SkPicture* fPic;
         const SkISize fSize;
         ProxySrc(int w, int h, const SkPicture* pic, SkISize size)
             : fW(w), fH(h), fPic(pic), fSize(size) {}
 
-        Error draw(SkCanvas* canvas) const SK_OVERRIDE {
+        Error draw(SkCanvas* canvas) const override {
             const int xTiles = (fSize.width()  + fW - 1) / fW,
                       yTiles = (fSize.height() + fH - 1) / fH;
             SkMultiPictureDraw mpd(xTiles*yTiles);
             SkTDArray<SkSurface*> surfaces;
             surfaces.setReserve(xTiles*yTiles);
 
             SkImageInfo info = canvas->imageInfo().makeWH(fW, fH);
             for (int j = 0; j < yTiles; j++) {
                 for (int i = 0; i < xTiles; i++) {
                     // This lets our ultimate Sink determine the best kind of surface.
@@ skipping 12 matching lines @@
             mpd.draw();
             for (int j = 0; j < yTiles; j++) {
                 for (int i = 0; i < xTiles; i++) {
                     SkAutoTUnref<SkImage> image(surfaces[i+xTiles*j]->newImageSnapshot());
                     canvas->drawImage(image, SkIntToScalar(i*fW), SkIntToScalar(j*fH));
                 }
             }
             surfaces.unrefAll();
             return "";
         }
-        SkISize size() const SK_OVERRIDE { return fSize; }
-        Name name() const SK_OVERRIDE { sk_throw(); return ""; }  // No one should be calling this.
+        SkISize size() const override { return fSize; }
+        Name name() const override { sk_throw(); return ""; }  // No one should be calling this.
     } proxy(fW, fH, pic, src.size());
     return fSink->draw(proxy, bitmap, stream, log);
 }
 
 }  // namespace DM