Standardize usage of virtual/override/final in skia/

The Google C++ style guide states:

  Explicitly annotate overrides of virtual functions or virtual
  destructors with an override or (less frequently) final specifier.
  Older (pre-C++11) code will use the virtual keyword as an inferior
  alternative annotation. For clarity, use exactly one of override,
  final, or virtual when declaring an override.

To better conform to these guidelines, the following constructs have
been rewritten:

- if a base class has a virtual destructor, then:
    virtual ~Foo();                   ->  ~Foo() override;
- virtual void Foo() override;        ->  void Foo() override;
- virtual void Foo() override final;  ->  void Foo() final;

This patch was automatically generated. The clang plugin can generate
fixit hints, which are suggested edits when it is 100% sure it knows how
to fix a problem. The hints from the clang plugin were applied to the
source tree using the tool in https://codereview.chromium.org/598073004.

BUG=417463
R=junov@chromium.org

Review URL: https://codereview.chromium.org/665373005

Cr-Commit-Position: refs/heads/master@{#300701}

skia/ext/SkDiscardableMemory_chrome.h

@@ -13,12 +13,12 @@
 // base::DiscardableMemory.
 class SK_API SkDiscardableMemoryChrome : public SkDiscardableMemory {
 public:
-  virtual ~SkDiscardableMemoryChrome();
+ ~SkDiscardableMemoryChrome() override;
 
   // SkDiscardableMemory:
-  virtual bool lock() override;
-  virtual void* data() override;
-  virtual void unlock() override;
+ bool lock() override;
+ void* data() override;
+ void unlock() override;
 
 private:
   friend class SkDiscardableMemory;

skia/ext/analysis_canvas.h

@@ -18,7 +18,7 @@ namespace skia {
 class SK_API AnalysisCanvas : public SkCanvas, public SkDrawPictureCallback {
  public:
   AnalysisCanvas(int width, int height);
-  virtual ~AnalysisCanvas();
+  ~AnalysisCanvas() override;
 
   // Returns true when a SkColor can be used to represent result.
   bool GetColorIfSolid(SkColor* color) const;
@@ -27,92 +27,93 @@ class SK_API AnalysisCanvas : public SkCanvas, public SkDrawPictureCallback {
   void SetForceNotTransparent(bool flag);
 
   // SkDrawPictureCallback override.
-  virtual bool abortDrawing() override;
+  bool abortDrawing() override;
 
   // SkCanvas overrides.
-  virtual void clear(SkColor) override;
-  virtual void drawPaint(const SkPaint& paint) override;
-  virtual void drawPoints(PointMode,
-                          size_t count,
-                          const SkPoint pts[],
-                          const SkPaint&) override;
-  virtual void drawOval(const SkRect&, const SkPaint&) override;
-  virtual void drawRect(const SkRect&, const SkPaint&) override;
-  virtual void drawRRect(const SkRRect&, const SkPaint&) override;
-  virtual void drawPath(const SkPath& path, const SkPaint&) override;
-  virtual void drawBitmap(const SkBitmap&,
-                          SkScalar left,
-                          SkScalar top,
-                          const SkPaint* paint = NULL) override;
-  virtual void drawBitmapRectToRect(const SkBitmap&,
-                                    const SkRect* src,
-                                    const SkRect& dst,
-                                    const SkPaint* paint,
-                                    DrawBitmapRectFlags flags) override;
-  virtual void drawBitmapMatrix(const SkBitmap&,
-                                const SkMatrix&,
-                                const SkPaint* paint = NULL) override;
-  virtual void drawBitmapNine(const SkBitmap& bitmap,
-                              const SkIRect& center,
-                              const SkRect& dst,
-                              const SkPaint* paint = NULL) override;
-  virtual void drawSprite(const SkBitmap&, int left, int top,
-                          const SkPaint* paint = NULL) override;
-  virtual void drawVertices(VertexMode,
-                            int vertexCount,
-                            const SkPoint vertices[],
-                            const SkPoint texs[],
-                            const SkColor colors[],
-                            SkXfermode*,
-                            const uint16_t indices[],
-                            int indexCount,
-                            const SkPaint&) override;
+  void clear(SkColor) override;
+  void drawPaint(const SkPaint& paint) override;
+  void drawPoints(PointMode,
+                  size_t count,
+                  const SkPoint pts[],
+                  const SkPaint&) override;
+  void drawOval(const SkRect&, const SkPaint&) override;
+  void drawRect(const SkRect&, const SkPaint&) override;
+  void drawRRect(const SkRRect&, const SkPaint&) override;
+  void drawPath(const SkPath& path, const SkPaint&) override;
+  void drawBitmap(const SkBitmap&,
+                  SkScalar left,
+                  SkScalar top,
+                  const SkPaint* paint = NULL) override;
+  void drawBitmapRectToRect(const SkBitmap&,
+                            const SkRect* src,
+                            const SkRect& dst,
+                            const SkPaint* paint,
+                            DrawBitmapRectFlags flags) override;
+  void drawBitmapMatrix(const SkBitmap&,
+                        const SkMatrix&,
+                        const SkPaint* paint = NULL) override;
+  void drawBitmapNine(const SkBitmap& bitmap,
+                      const SkIRect& center,
+                      const SkRect& dst,
+                      const SkPaint* paint = NULL) override;
+  void drawSprite(const SkBitmap&,
+                  int left,
+                  int top,
+                  const SkPaint* paint = NULL) override;
+  void drawVertices(VertexMode,
+                    int vertexCount,
+                    const SkPoint vertices[],
+                    const SkPoint texs[],
+                    const SkColor colors[],
+                    SkXfermode*,
+                    const uint16_t indices[],
+                    int indexCount,
+                    const SkPaint&) override;
 
  protected:
-  virtual void willSave() override;
-  virtual SaveLayerStrategy willSaveLayer(const SkRect*,
-                                          const SkPaint*,
-                                          SaveFlags) override;
-  virtual void willRestore() override;
-
-  virtual void onClipRect(const SkRect& rect,
-                          SkRegion::Op op,
-                          ClipEdgeStyle edge_style) override;
-  virtual void onClipRRect(const SkRRect& rrect,
-                           SkRegion::Op op,
-                           ClipEdgeStyle edge_style) override;
-  virtual void onClipPath(const SkPath& path,
-                          SkRegion::Op op,
-                          ClipEdgeStyle edge_style) override;
-  virtual void onClipRegion(const SkRegion& deviceRgn,
-                            SkRegion::Op op) override;
-
-  virtual void onDrawText(const void* text,
-                          size_t byteLength,
-                          SkScalar x,
-                          SkScalar y,
-                          const SkPaint&) override;
-  virtual void onDrawPosText(const void* text,
-                             size_t byteLength,
-                             const SkPoint pos[],
-                             const SkPaint&) override;
-  virtual void onDrawPosTextH(const void* text,
-                              size_t byteLength,
-                              const SkScalar xpos[],
-                              SkScalar constY,
-                              const SkPaint&) override;
-  virtual void onDrawTextOnPath(const void* text,
-                                size_t byteLength,
-                                const SkPath& path,
-                                const SkMatrix* matrix,
-                                const SkPaint&) override;
-  virtual void onDrawTextBlob(const SkTextBlob* blob,
-                              SkScalar x,
-                              SkScalar y,
-                              const SkPaint& paint) override;
-  virtual void onDrawDRRect(const SkRRect& outer,
-                            const SkRRect& inner,
-                            const SkPaint&) override;
+  void willSave() override;
+  SaveLayerStrategy willSaveLayer(const SkRect*,
+                                  const SkPaint*,
+                                  SaveFlags) override;
+  void willRestore() override;
+
+  void onClipRect(const SkRect& rect,
+                  SkRegion::Op op,
+                  ClipEdgeStyle edge_style) override;
+  void onClipRRect(const SkRRect& rrect,
+                   SkRegion::Op op,
+                   ClipEdgeStyle edge_style) override;
+  void onClipPath(const SkPath& path,
+                  SkRegion::Op op,
+                  ClipEdgeStyle edge_style) override;
+  void onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) override;
+
+  void onDrawText(const void* text,
+                  size_t byteLength,
+                  SkScalar x,
+                  SkScalar y,
+                  const SkPaint&) override;
+  void onDrawPosText(const void* text,
+                     size_t byteLength,
+                     const SkPoint pos[],
+                     const SkPaint&) override;
+  void onDrawPosTextH(const void* text,
+                      size_t byteLength,
+                      const SkScalar xpos[],
+                      SkScalar constY,
+                      const SkPaint&) override;
+  void onDrawTextOnPath(const void* text,
+                        size_t byteLength,
+                        const SkPath& path,
+                        const SkMatrix* matrix,
+                        const SkPaint&) override;
+  void onDrawTextBlob(const SkTextBlob* blob,
+                      SkScalar x,
+                      SkScalar y,
+                      const SkPaint& paint) override;
+  void onDrawDRRect(const SkRRect& outer,
+                    const SkRRect& inner,
+                    const SkPaint&) override;
 
   void OnComplexClip();
 

skia/ext/benchmarking_canvas.cc

@@ -29,8 +29,7 @@ public:
     setProxy(canvas_.get());
   }
 
-  virtual ~TimingCanvas() {
-  }
+  ~TimingCanvas() override {}
 
   double GetTime(size_t index) {
     TimingsMap::const_iterator timing_info = timings_map_.find(index);
@@ -40,149 +39,172 @@ public:
   }
 
   // SkCanvas overrides.
-  virtual void willSave() override {
+  void willSave() override {
     AutoStamper stamper(this);
     SkProxyCanvas::willSave();
   }
 
-  virtual SaveLayerStrategy willSaveLayer(const SkRect* bounds,
-                                          const SkPaint* paint,
-                                          SaveFlags flags) override {
+  SaveLayerStrategy willSaveLayer(const SkRect* bounds,
+                                  const SkPaint* paint,
+                                  SaveFlags flags) override {
     AutoStamper stamper(this);
     return SkProxyCanvas::willSaveLayer(bounds, paint, flags);
   }
 
-  virtual void willRestore() override {
+  void willRestore() override {
     AutoStamper stamper(this);
     SkProxyCanvas::willRestore();
   }
 
-  virtual void drawPaint(const SkPaint& paint) override {
+  void drawPaint(const SkPaint& paint) override {
     AutoStamper stamper(this);
     SkProxyCanvas::drawPaint(paint);
   }
 
-  virtual void drawPoints(PointMode mode, size_t count, const SkPoint pts[],
-                          const SkPaint& paint) override {
+  void drawPoints(PointMode mode,
+                  size_t count,
+                  const SkPoint pts[],
+                  const SkPaint& paint) override {
     AutoStamper stamper(this);
     SkProxyCanvas::drawPoints(mode, count, pts, paint);
   }
 
-  virtual void drawOval(const SkRect& rect, const SkPaint& paint) override {
+  void drawOval(const SkRect& rect, const SkPaint& paint) override {
     AutoStamper stamper(this);
     SkProxyCanvas::drawOval(rect, paint);
   }
 
-  virtual void drawRect(const SkRect& rect, const SkPaint& paint) override {
+  void drawRect(const SkRect& rect, const SkPaint& paint) override {
     AutoStamper stamper(this);
     SkProxyCanvas::drawRect(rect, paint);
   }
 
-  virtual void drawRRect(const SkRRect& rrect, const SkPaint& paint) override {
+  void drawRRect(const SkRRect& rrect, const SkPaint& paint) override {
     AutoStamper stamper(this);
     SkProxyCanvas::drawRRect(rrect, paint);
   }
 
-  virtual void drawPath(const SkPath& path, const SkPaint& paint) override {
+  void drawPath(const SkPath& path, const SkPaint& paint) override {
     AutoStamper stamper(this);
     SkProxyCanvas::drawPath(path, paint);
   }
 
-  virtual void drawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top,
-                          const SkPaint* paint = NULL) override {
+  void drawBitmap(const SkBitmap& bitmap,
+                  SkScalar left,
+                  SkScalar top,
+                  const SkPaint* paint = NULL) override {
     AutoStamper stamper(this);
     SkProxyCanvas::drawBitmap(bitmap, left, top, paint);
   }
 
-  virtual void drawBitmapRectToRect(const SkBitmap& bitmap, const SkRect* src,
-                                    const SkRect& dst,
-                                    const SkPaint* paint,
-                                    DrawBitmapRectFlags flags) override {
+  void drawBitmapRectToRect(const SkBitmap& bitmap,
+                            const SkRect* src,
+                            const SkRect& dst,
+                            const SkPaint* paint,
+                            DrawBitmapRectFlags flags) override {
     AutoStamper stamper(this);
     SkProxyCanvas::drawBitmapRectToRect(bitmap, src, dst, paint, flags);
   }
 
-  virtual void drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& m,
-                                const SkPaint* paint = NULL) override {
+  void drawBitmapMatrix(const SkBitmap& bitmap,
+                        const SkMatrix& m,
+                        const SkPaint* paint = NULL) override {
     AutoStamper stamper(this);
     SkProxyCanvas::drawBitmapMatrix(bitmap, m, paint);
   }
 
-  virtual void drawSprite(const SkBitmap& bitmap, int left, int top,
-                          const SkPaint* paint = NULL) override {
+  void drawSprite(const SkBitmap& bitmap,
+                  int left,
+                  int top,
+                  const SkPaint* paint = NULL) override {
     AutoStamper stamper(this);
     SkProxyCanvas::drawSprite(bitmap, left, top, paint);
   }
 
-  virtual void drawVertices(VertexMode vmode, int vertexCount,
-                            const SkPoint vertices[], const SkPoint texs[],
-                            const SkColor colors[], SkXfermode* xmode,
-                            const uint16_t indices[], int indexCount,
-                            const SkPaint& paint) override {
+  void drawVertices(VertexMode vmode,
+                    int vertexCount,
+                    const SkPoint vertices[],
+                    const SkPoint texs[],
+                    const SkColor colors[],
+                    SkXfermode* xmode,
+                    const uint16_t indices[],
+                    int indexCount,
+                    const SkPaint& paint) override {
     AutoStamper stamper(this);
     SkProxyCanvas::drawVertices(vmode, vertexCount, vertices, texs, colors,
                                 xmode, indices, indexCount, paint);
   }
 
-  virtual void drawData(const void* data, size_t length) override {
+  void drawData(const void* data, size_t length) override {
     AutoStamper stamper(this);
     SkProxyCanvas::drawData(data, length);
   }
 
 protected:
-  virtual void onDrawText(const void* text, size_t byteLength, SkScalar x,
-                          SkScalar y, const SkPaint& paint) override {
+ void onDrawText(const void* text,
+                 size_t byteLength,
+                 SkScalar x,
+                 SkScalar y,
+                 const SkPaint& paint) override {
     AutoStamper stamper(this);
     SkProxyCanvas::onDrawText(text, byteLength, x, y, paint);
   }
 
-  virtual void onDrawPosText(const void* text, size_t byteLength,
-                             const SkPoint pos[],
-                             const SkPaint& paint) override {
+  void onDrawPosText(const void* text,
+                     size_t byteLength,
+                     const SkPoint pos[],
+                     const SkPaint& paint) override {
     AutoStamper stamper(this);
     SkProxyCanvas::onDrawPosText(text, byteLength, pos, paint);
   }
 
-  virtual void onDrawPosTextH(const void* text, size_t byteLength,
-                              const SkScalar xpos[], SkScalar constY,
-                              const SkPaint& paint) override {
+  void onDrawPosTextH(const void* text,
+                      size_t byteLength,
+                      const SkScalar xpos[],
+                      SkScalar constY,
+                      const SkPaint& paint) override {
     AutoStamper stamper(this);
     SkProxyCanvas::onDrawPosTextH(text, byteLength, xpos, constY, paint);
   }
 
-  virtual void onDrawTextOnPath(const void* text, size_t byteLength,
-                                const SkPath& path, const SkMatrix* matrix,
-                                const SkPaint& paint) override {
+  void onDrawTextOnPath(const void* text,
+                        size_t byteLength,
+                        const SkPath& path,
+                        const SkMatrix* matrix,
+                        const SkPaint& paint) override {
     AutoStamper stamper(this);
     SkProxyCanvas::onDrawTextOnPath(text, byteLength, path, matrix, paint);
   }
 
-  virtual void onClipRect(const SkRect& rect, SkRegion::Op op,
-                          ClipEdgeStyle edge_style) override {
+  void onClipRect(const SkRect& rect,
+                  SkRegion::Op op,
+                  ClipEdgeStyle edge_style) override {
     AutoStamper stamper(this);
     SkProxyCanvas::onClipRect(rect, op, edge_style);
   }
 
-  virtual void onClipRRect(const SkRRect& rrect, SkRegion::Op op,
-                          ClipEdgeStyle edge_style) override {
+  void onClipRRect(const SkRRect& rrect,
+                   SkRegion::Op op,
+                   ClipEdgeStyle edge_style) override {
     AutoStamper stamper(this);
     SkProxyCanvas::onClipRRect(rrect, op, edge_style);
   }
 
-  virtual void onClipPath(const SkPath& path, SkRegion::Op op,
-                          ClipEdgeStyle edge_style) override {
+  void onClipPath(const SkPath& path,
+                  SkRegion::Op op,
+                  ClipEdgeStyle edge_style) override {
     AutoStamper stamper(this);
     SkProxyCanvas::onClipPath(path, op, edge_style);
   }
 
-  virtual void onClipRegion(const SkRegion& region,
-                            SkRegion::Op op) override {
+  void onClipRegion(const SkRegion& region, SkRegion::Op op) override {
     AutoStamper stamper(this);
     SkProxyCanvas::onClipRegion(region, op);
   }
 
-  virtual void onDrawPicture(const SkPicture* picture, const SkMatrix* matrix,
-                             const SkPaint* paint) override {
+  void onDrawPicture(const SkPicture* picture,
+                     const SkMatrix* matrix,
+                     const SkPaint* paint) override {
     AutoStamper stamper(this);
     SkProxyCanvas::onDrawPicture(picture, matrix, paint);
   }

skia/ext/benchmarking_canvas.h

@@ -17,7 +17,7 @@ class TimingCanvas;
 class SK_API BenchmarkingCanvas : public SkNWayCanvas {
 public:
   BenchmarkingCanvas(int width, int height);
-  virtual ~BenchmarkingCanvas();
+  ~BenchmarkingCanvas() override;
 
   // Returns the number of draw commands executed on this canvas.
   size_t CommandCount() const;

skia/ext/bitmap_platform_device_mac.h

@@ -48,23 +48,25 @@ class SK_API BitmapPlatformDevice : public SkBitmapDevice, public PlatformDevice
                                               int width, int height,
                                               bool is_opaque);
 
-  virtual ~BitmapPlatformDevice();
+  ~BitmapPlatformDevice() override;
 
   // PlatformDevice overrides
-  virtual CGContextRef GetBitmapContext() override;
-  virtual void DrawToNativeContext(CGContextRef context, int x, int y,
-                                   const CGRect* src_rect) override;
+  CGContextRef GetBitmapContext() override;
+  void DrawToNativeContext(CGContextRef context,
+                           int x,
+                           int y,
+                           const CGRect* src_rect) override;
 
   // SkBaseDevice overrides
-  virtual void setMatrixClip(const SkMatrix& transform, const SkRegion& region,
-                             const SkClipStack&) override;
+  void setMatrixClip(const SkMatrix& transform,
+                     const SkRegion& region,
+                     const SkClipStack&) override;
 
  protected:
   BitmapPlatformDevice(CGContextRef context,
                        const SkBitmap& bitmap);
 
-  virtual SkBaseDevice* onCreateDevice(const SkImageInfo& info,
-                                       Usage usage) override;
+  SkBaseDevice* onCreateDevice(const SkImageInfo& info, Usage usage) override;
 
  private:
   void ReleaseBitmapContext();

skia/ext/event_tracer_impl.cc

@@ -9,23 +9,20 @@
 namespace skia {
 
 class SkChromiumEventTracer: public SkEventTracer {
-  virtual const uint8_t* getCategoryGroupEnabled(const char* name) override;
-  virtual const char* getCategoryGroupName(
-      const uint8_t* categoryEnabledFlag) override;
-  virtual SkEventTracer::Handle
-    addTraceEvent(char phase,
-                  const uint8_t* categoryEnabledFlag,
-                  const char* name,
-                  uint64_t id,
-                  int32_t numArgs,
-                  const char** argNames,
-                  const uint8_t* argTypes,
-                  const uint64_t* argValues,
-                  uint8_t flags) override;
-  virtual void
-    updateTraceEventDuration(const uint8_t* categoryEnabledFlag,
-                             const char *name,
-                             SkEventTracer::Handle handle) override;
+  const uint8_t* getCategoryGroupEnabled(const char* name) override;
+  const char* getCategoryGroupName(const uint8_t* categoryEnabledFlag) override;
+  SkEventTracer::Handle addTraceEvent(char phase,
+                                      const uint8_t* categoryEnabledFlag,
+                                      const char* name,
+                                      uint64_t id,
+                                      int32_t numArgs,
+                                      const char** argNames,
+                                      const uint8_t* argTypes,
+                                      const uint64_t* argValues,
+                                      uint8_t flags) override;
+  void updateTraceEventDuration(const uint8_t* categoryEnabledFlag,
+                                const char* name,
+                                SkEventTracer::Handle handle) override;
 };
 
 const uint8_t*

skia/ext/lazy_pixel_ref.h

@@ -15,7 +15,7 @@ namespace skia {
 class SK_API LazyPixelRef : public SkPixelRef {
  public:
   explicit LazyPixelRef(const SkImageInfo& info);
-  virtual ~LazyPixelRef();
+  ~LazyPixelRef() override;
 
   struct PrepareParams {
     // Clipping rect for this pixel ref.

skia/ext/opacity_draw_filter.h

@@ -19,8 +19,8 @@ namespace skia {
 class SK_API OpacityDrawFilter : public SkDrawFilter {
  public:
   OpacityDrawFilter(float opacity, bool disable_image_filtering);
-  virtual ~OpacityDrawFilter();
-  virtual bool filter(SkPaint* paint, SkDrawFilter::Type type) override;
+  ~OpacityDrawFilter() override;
+  bool filter(SkPaint* paint, SkDrawFilter::Type type) override;
 
  private:
   int alpha_;

skia/ext/pixel_ref_utils.cc

@@ -51,8 +51,8 @@ class GatherPixelRefDevice : public SkBitmapDevice {
                        DiscardablePixelRefSet* pixel_ref_set)
       : SkBitmapDevice(bm), pixel_ref_set_(pixel_ref_set) {}
 
-  virtual void clear(SkColor color) override {}
-  virtual void drawPaint(const SkDraw& draw, const SkPaint& paint) override {
+  void clear(SkColor color) override {}
+  void drawPaint(const SkDraw& draw, const SkPaint& paint) override {
     SkBitmap bitmap;
     if (GetBitmapFromPaint(paint, &bitmap)) {
       SkRect clip_rect = SkRect::Make(draw.fRC->getBounds());
@@ -60,11 +60,11 @@ class GatherPixelRefDevice : public SkBitmapDevice {
     }
   }
 
-  virtual void drawPoints(const SkDraw& draw,
-                          SkCanvas::PointMode mode,
-                          size_t count,
-                          const SkPoint points[],
-                          const SkPaint& paint) override {
+  void drawPoints(const SkDraw& draw,
+                  SkCanvas::PointMode mode,
+                  size_t count,
+                  const SkPoint points[],
+                  const SkPaint& paint) override {
     SkBitmap bitmap;
     if (!GetBitmapFromPaint(paint, &bitmap))
       return;
@@ -87,9 +87,9 @@ class GatherPixelRefDevice : public SkBitmapDevice {
 
     GatherPixelRefDevice::drawRect(draw, bounds, paint);
   }
-  virtual void drawRect(const SkDraw& draw,
-                        const SkRect& rect,
-                        const SkPaint& paint) override {
+  void drawRect(const SkDraw& draw,
+                const SkRect& rect,
+                const SkPaint& paint) override {
     SkBitmap bitmap;
     if (GetBitmapFromPaint(paint, &bitmap)) {
       SkRect mapped_rect;
@@ -98,21 +98,21 @@ class GatherPixelRefDevice : public SkBitmapDevice {
       AddBitmap(bitmap, mapped_rect);
     }
   }
-  virtual void drawOval(const SkDraw& draw,
-                        const SkRect& rect,
-                        const SkPaint& paint) override {
+  void drawOval(const SkDraw& draw,
+                const SkRect& rect,
+                const SkPaint& paint) override {
     GatherPixelRefDevice::drawRect(draw, rect, paint);
   }
-  virtual void drawRRect(const SkDraw& draw,
-                         const SkRRect& rect,
-                         const SkPaint& paint) override {
+  void drawRRect(const SkDraw& draw,
+                 const SkRRect& rect,
+                 const SkPaint& paint) override {
     GatherPixelRefDevice::drawRect(draw, rect.rect(), paint);
   }
-  virtual void drawPath(const SkDraw& draw,
-                        const SkPath& path,
-                        const SkPaint& paint,
-                        const SkMatrix* pre_path_matrix,
-                        bool path_is_mutable) override {
+  void drawPath(const SkDraw& draw,
+                const SkPath& path,
+                const SkPaint& paint,
+                const SkMatrix* pre_path_matrix,
+                bool path_is_mutable) override {
     SkBitmap bitmap;
     if (!GetBitmapFromPaint(paint, &bitmap))
       return;
@@ -126,10 +126,10 @@ class GatherPixelRefDevice : public SkBitmapDevice {
 
     GatherPixelRefDevice::drawRect(draw, final_rect, paint);
   }
-  virtual void drawBitmap(const SkDraw& draw,
-                          const SkBitmap& bitmap,
-                          const SkMatrix& matrix,
-                          const SkPaint& paint) override {
+  void drawBitmap(const SkDraw& draw,
+                  const SkBitmap& bitmap,
+                  const SkMatrix& matrix,
+                  const SkPaint& paint) override {
     SkMatrix total_matrix;
     total_matrix.setConcat(*draw.fMatrix, matrix);
 
@@ -142,22 +142,22 @@ class GatherPixelRefDevice : public SkBitmapDevice {
     if (GetBitmapFromPaint(paint, &paint_bitmap))
       AddBitmap(paint_bitmap, mapped_rect);
   }
-  virtual void drawBitmapRect(const SkDraw& draw,
-                              const SkBitmap& bitmap,
-                              const SkRect* src_or_null,
-                              const SkRect& dst,
-                              const SkPaint& paint,
-                              SkCanvas::DrawBitmapRectFlags flags) override {
+  void drawBitmapRect(const SkDraw& draw,
+                      const SkBitmap& bitmap,
+                      const SkRect* src_or_null,
+                      const SkRect& dst,
+                      const SkPaint& paint,
+                      SkCanvas::DrawBitmapRectFlags flags) override {
     SkRect bitmap_rect = SkRect::MakeWH(bitmap.width(), bitmap.height());
     SkMatrix matrix;
     matrix.setRectToRect(bitmap_rect, dst, SkMatrix::kFill_ScaleToFit);
     GatherPixelRefDevice::drawBitmap(draw, bitmap, matrix, paint);
   }
-  virtual void drawSprite(const SkDraw& draw,
-                          const SkBitmap& bitmap,
-                          int x,
-                          int y,
-                          const SkPaint& paint) override {
+  void drawSprite(const SkDraw& draw,
+                  const SkBitmap& bitmap,
+                  int x,
+                  int y,
+                  const SkPaint& paint) override {
     // Sprites aren't affected by current matrix, so we can't reuse drawRect.
     SkMatrix matrix;
     matrix.setTranslate(x, y);
@@ -171,12 +171,12 @@ class GatherPixelRefDevice : public SkBitmapDevice {
     if (GetBitmapFromPaint(paint, &paint_bitmap))
       AddBitmap(paint_bitmap, mapped_rect);
   }
-  virtual void drawText(const SkDraw& draw,
-                        const void* text,
-                        size_t len,
-                        SkScalar x,
-                        SkScalar y,
-                        const SkPaint& paint) override {
+  void drawText(const SkDraw& draw,
+                const void* text,
+                size_t len,
+                SkScalar x,
+                SkScalar y,
+                const SkPaint& paint) override {
     SkBitmap bitmap;
     if (!GetBitmapFromPaint(paint, &bitmap))
       return;
@@ -218,13 +218,13 @@ class GatherPixelRefDevice : public SkBitmapDevice {
 
     GatherPixelRefDevice::drawRect(draw, bounds, paint);
   }
-  virtual void drawPosText(const SkDraw& draw,
-                           const void* text,
-                           size_t len,
-                           const SkScalar pos[],
-                           int scalars_per_pos,
-                           const SkPoint& offset,
-                           const SkPaint& paint) override {
+  void drawPosText(const SkDraw& draw,
+                   const void* text,
+                   size_t len,
+                   const SkScalar pos[],
+                   int scalars_per_pos,
+                   const SkPoint& offset,
+                   const SkPaint& paint) override {
     SkBitmap bitmap;
     if (!GetBitmapFromPaint(paint, &bitmap))
       return;
@@ -263,12 +263,12 @@ class GatherPixelRefDevice : public SkBitmapDevice {
 
     GatherPixelRefDevice::drawRect(draw, bounds, paint);
   }
-  virtual void drawTextOnPath(const SkDraw& draw,
-                              const void* text,
-                              size_t len,
-                              const SkPath& path,
-                              const SkMatrix* matrix,
-                              const SkPaint& paint) override {
+  void drawTextOnPath(const SkDraw& draw,
+                      const void* text,
+                      size_t len,
+                      const SkPath& path,
+                      const SkMatrix* matrix,
+                      const SkPaint& paint) override {
     SkBitmap bitmap;
     if (!GetBitmapFromPaint(paint, &bitmap))
       return;
@@ -286,39 +286,39 @@ class GatherPixelRefDevice : public SkBitmapDevice {
 
     GatherPixelRefDevice::drawRect(draw, bounds, paint);
   }
-  virtual void drawVertices(const SkDraw& draw,
-                            SkCanvas::VertexMode,
-                            int vertex_count,
-                            const SkPoint verts[],
-                            const SkPoint texs[],
-                            const SkColor colors[],
-                            SkXfermode* xmode,
-                            const uint16_t indices[],
-                            int index_count,
-                            const SkPaint& paint) override {
+  void drawVertices(const SkDraw& draw,
+                    SkCanvas::VertexMode,
+                    int vertex_count,
+                    const SkPoint verts[],
+                    const SkPoint texs[],
+                    const SkColor colors[],
+                    SkXfermode* xmode,
+                    const uint16_t indices[],
+                    int index_count,
+                    const SkPaint& paint) override {
     GatherPixelRefDevice::drawPoints(
         draw, SkCanvas::kPolygon_PointMode, vertex_count, verts, paint);
   }
-  virtual void drawDevice(const SkDraw&,
-                          SkBaseDevice*,
-                          int x,
-                          int y,
-                          const SkPaint&) override {}
+  void drawDevice(const SkDraw&,
+                  SkBaseDevice*,
+                  int x,
+                  int y,
+                  const SkPaint&) override {}
 
  protected:
-  virtual bool onReadPixels(const SkImageInfo& info,
-                            void* pixels,
-                            size_t rowBytes,
-                            int x,
-                            int y) override {
+  bool onReadPixels(const SkImageInfo& info,
+                    void* pixels,
+                    size_t rowBytes,
+                    int x,
+                    int y) override {
     return false;
   }
 
-  virtual bool onWritePixels(const SkImageInfo& info,
-                             const void* pixels,
-                             size_t rowBytes,
-                             int x,
-                             int y) override {
+  bool onWritePixels(const SkImageInfo& info,
+                     const void* pixels,
+                     size_t rowBytes,
+                     int x,
+                     int y) override {
     return false;
   }
 

skia/ext/pixel_ref_utils_unittest.cc

@@ -34,20 +34,18 @@ class TestDiscardableShader : public SkShader {
     CreateBitmap(gfx::Size(50, 50), "discardable", &bitmap_);
   }
 
-  virtual SkShader::BitmapType asABitmap(SkBitmap* bitmap,
-                                         SkMatrix* matrix,
-                                         TileMode xy[2]) const override {
+  SkShader::BitmapType asABitmap(SkBitmap* bitmap,
+                                 SkMatrix* matrix,
+                                 TileMode xy[2]) const override {
     if (bitmap)
       *bitmap = bitmap_;
     return SkShader::kDefault_BitmapType;
   }
 
   // not indended to return an actual context. Just need to supply this.
-  virtual size_t contextSize() const override {
-    return sizeof(SkShader::Context);
-  }
+  size_t contextSize() const override { return sizeof(SkShader::Context); }
 
-  virtual void flatten(SkWriteBuffer&) const override {}
+  void flatten(SkWriteBuffer&) const override {}
 
   SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(TestDiscardableShader);
 

skia/ext/vector_platform_device_skia.h

@@ -23,24 +23,24 @@ class VectorPlatformDeviceSkia : public SkPDFDevice, public PlatformDevice {
   SK_API VectorPlatformDeviceSkia(const SkISize& pageSize,
                                   const SkISize& contentSize,
                                   const SkMatrix& initialTransform);
-  virtual ~VectorPlatformDeviceSkia();
+  ~VectorPlatformDeviceSkia() override;
 
   // PlatformDevice methods.
-  virtual bool SupportsPlatformPaint() override;
+  bool SupportsPlatformPaint() override;
 
-  virtual PlatformSurface BeginPlatformPaint() override;
-  virtual void EndPlatformPaint() override;
+  PlatformSurface BeginPlatformPaint() override;
+  void EndPlatformPaint() override;
 #if defined(OS_WIN)
   virtual void DrawToNativeContext(HDC dc,
                                    int x,
                                    int y,
                                    const RECT* src_rect) override;
 #elif defined(OS_MACOSX)
-  virtual void DrawToNativeContext(CGContext* context,
-                                   int x,
-                                   int y,
-                                   const CGRect* src_rect) override;
-  virtual CGContextRef GetBitmapContext() override;
+  void DrawToNativeContext(CGContext* context,
+                           int x,
+                           int y,
+                           const CGRect* src_rect) override;
+  CGContextRef GetBitmapContext() override;
 #elif defined(OS_POSIX)
   virtual void DrawToNativeContext(PlatformSurface surface,
                                    int x,