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,38 +27,40 @@ 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,
+  void clear(SkColor) override;
+  void drawPaint(const SkPaint& paint) override;
+  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&,
+  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;
-  virtual void drawBitmapRectToRect(const SkBitmap&,
+  void drawBitmapRectToRect(const SkBitmap&,
                             const SkRect* src,
                             const SkRect& dst,
                             const SkPaint* paint,
                             DrawBitmapRectFlags flags) override;
-  virtual void drawBitmapMatrix(const SkBitmap&,
+  void drawBitmapMatrix(const SkBitmap&,
                         const SkMatrix&,
                         const SkPaint* paint = NULL) override;
-  virtual void drawBitmapNine(const SkBitmap& bitmap,
+  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,
+  void drawSprite(const SkBitmap&,
+                  int left,
+                  int top,
                   const SkPaint* paint = NULL) override;
-  virtual void drawVertices(VertexMode,
+  void drawVertices(VertexMode,
                     int vertexCount,
                     const SkPoint vertices[],
                     const SkPoint texs[],
@@ -69,48 +71,47 @@ class SK_API AnalysisCanvas : public SkCanvas, public SkDrawPictureCallback {
                     const SkPaint&) override;
 
  protected:
-  virtual void willSave() override;
-  virtual SaveLayerStrategy willSaveLayer(const SkRect*,
+  void willSave() override;
+  SaveLayerStrategy willSaveLayer(const SkRect*,
                                   const SkPaint*,
                                   SaveFlags) override;
-  virtual void willRestore() override;
+  void willRestore() override;
 
-  virtual void onClipRect(const SkRect& rect,
+  void onClipRect(const SkRect& rect,
                   SkRegion::Op op,
                   ClipEdgeStyle edge_style) override;
-  virtual void onClipRRect(const SkRRect& rrect,
+  void onClipRRect(const SkRRect& rrect,
                    SkRegion::Op op,
                    ClipEdgeStyle edge_style) override;
-  virtual void onClipPath(const SkPath& path,
+  void onClipPath(const SkPath& path,
                   SkRegion::Op op,
                   ClipEdgeStyle edge_style) override;
-  virtual void onClipRegion(const SkRegion& deviceRgn,
-                            SkRegion::Op op) override;
+  void onClipRegion(const SkRegion& deviceRgn, SkRegion::Op op) override;
 
-  virtual void onDrawText(const void* text,
+  void onDrawText(const void* text,
                   size_t byteLength,
                   SkScalar x,
                   SkScalar y,
                   const SkPaint&) override;
-  virtual void onDrawPosText(const void* text,
+  void onDrawPosText(const void* text,
                      size_t byteLength,
                      const SkPoint pos[],
                      const SkPaint&) override;
-  virtual void onDrawPosTextH(const void* text,
+  void onDrawPosTextH(const void* text,
                       size_t byteLength,
                       const SkScalar xpos[],
                       SkScalar constY,
                       const SkPaint&) override;
-  virtual void onDrawTextOnPath(const void* text,
+  void onDrawTextOnPath(const void* text,
                         size_t byteLength,
                         const SkPath& path,
                         const SkMatrix* matrix,
                         const SkPaint&) override;
-  virtual void onDrawTextBlob(const SkTextBlob* blob,
+  void onDrawTextBlob(const SkTextBlob* blob,
                       SkScalar x,
                       SkScalar y,
                       const SkPaint& paint) override;
-  virtual void onDrawDRRect(const SkRRect& outer,
+  void onDrawDRRect(const SkRRect& outer,
                     const SkRRect& inner,
                     const SkPaint&) override;
 

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,61 +39,66 @@ public:
   }
 
   // SkCanvas overrides.
-  virtual void willSave() override {
+  void willSave() override {
     AutoStamper stamper(this);
     SkProxyCanvas::willSave();
   }
 
-  virtual SaveLayerStrategy willSaveLayer(const SkRect* bounds,
+  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[],
+  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,
+  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,
+  void drawBitmapRectToRect(const SkBitmap& bitmap,
+                            const SkRect* src,
                             const SkRect& dst,
                             const SkPaint* paint,
                             DrawBitmapRectFlags flags) override {
@@ -102,86 +106,104 @@ public:
     SkProxyCanvas::drawBitmapRectToRect(bitmap, src, dst, paint, flags);
   }
 
-  virtual void drawBitmapMatrix(const SkBitmap& bitmap, const SkMatrix& m,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,11 +9,9 @@
 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* 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,
@@ -22,9 +20,8 @@ class SkChromiumEventTracer: public SkEventTracer {
                                       const uint8_t* argTypes,
                                       const uint64_t* argValues,
                                       uint8_t flags) override;
-  virtual void
-    updateTraceEventDuration(const uint8_t* categoryEnabledFlag,
-                             const char *name,
+  void updateTraceEventDuration(const uint8_t* categoryEnabledFlag,
+                                const char* name,
                                 SkEventTracer::Handle handle) override;
 };
 

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,7 +60,7 @@ class GatherPixelRefDevice : public SkBitmapDevice {
     }
   }
 
-  virtual void drawPoints(const SkDraw& draw,
+  void drawPoints(const SkDraw& draw,
                   SkCanvas::PointMode mode,
                   size_t count,
                   const SkPoint points[],
@@ -87,7 +87,7 @@ class GatherPixelRefDevice : public SkBitmapDevice {
 
     GatherPixelRefDevice::drawRect(draw, bounds, paint);
   }
-  virtual void drawRect(const SkDraw& draw,
+  void drawRect(const SkDraw& draw,
                 const SkRect& rect,
                 const SkPaint& paint) override {
     SkBitmap bitmap;
@@ -98,17 +98,17 @@ class GatherPixelRefDevice : public SkBitmapDevice {
       AddBitmap(bitmap, mapped_rect);
     }
   }
-  virtual void drawOval(const SkDraw& draw,
+  void drawOval(const SkDraw& draw,
                 const SkRect& rect,
                 const SkPaint& paint) override {
     GatherPixelRefDevice::drawRect(draw, rect, paint);
   }
-  virtual void drawRRect(const SkDraw& draw,
+  void drawRRect(const SkDraw& draw,
                  const SkRRect& rect,
                  const SkPaint& paint) override {
     GatherPixelRefDevice::drawRect(draw, rect.rect(), paint);
   }
-  virtual void drawPath(const SkDraw& draw,
+  void drawPath(const SkDraw& draw,
                 const SkPath& path,
                 const SkPaint& paint,
                 const SkMatrix* pre_path_matrix,
@@ -126,7 +126,7 @@ class GatherPixelRefDevice : public SkBitmapDevice {
 
     GatherPixelRefDevice::drawRect(draw, final_rect, paint);
   }
-  virtual void drawBitmap(const SkDraw& draw,
+  void drawBitmap(const SkDraw& draw,
                   const SkBitmap& bitmap,
                   const SkMatrix& matrix,
                   const SkPaint& paint) override {
@@ -142,7 +142,7 @@ class GatherPixelRefDevice : public SkBitmapDevice {
     if (GetBitmapFromPaint(paint, &paint_bitmap))
       AddBitmap(paint_bitmap, mapped_rect);
   }
-  virtual void drawBitmapRect(const SkDraw& draw,
+  void drawBitmapRect(const SkDraw& draw,
                       const SkBitmap& bitmap,
                       const SkRect* src_or_null,
                       const SkRect& dst,
@@ -153,7 +153,7 @@ class GatherPixelRefDevice : public SkBitmapDevice {
     matrix.setRectToRect(bitmap_rect, dst, SkMatrix::kFill_ScaleToFit);
     GatherPixelRefDevice::drawBitmap(draw, bitmap, matrix, paint);
   }
-  virtual void drawSprite(const SkDraw& draw,
+  void drawSprite(const SkDraw& draw,
                   const SkBitmap& bitmap,
                   int x,
                   int y,
@@ -171,7 +171,7 @@ class GatherPixelRefDevice : public SkBitmapDevice {
     if (GetBitmapFromPaint(paint, &paint_bitmap))
       AddBitmap(paint_bitmap, mapped_rect);
   }
-  virtual void drawText(const SkDraw& draw,
+  void drawText(const SkDraw& draw,
                 const void* text,
                 size_t len,
                 SkScalar x,
@@ -218,7 +218,7 @@ class GatherPixelRefDevice : public SkBitmapDevice {
 
     GatherPixelRefDevice::drawRect(draw, bounds, paint);
   }
-  virtual void drawPosText(const SkDraw& draw,
+  void drawPosText(const SkDraw& draw,
                    const void* text,
                    size_t len,
                    const SkScalar pos[],
@@ -263,7 +263,7 @@ class GatherPixelRefDevice : public SkBitmapDevice {
 
     GatherPixelRefDevice::drawRect(draw, bounds, paint);
   }
-  virtual void drawTextOnPath(const SkDraw& draw,
+  void drawTextOnPath(const SkDraw& draw,
                       const void* text,
                       size_t len,
                       const SkPath& path,
@@ -286,7 +286,7 @@ class GatherPixelRefDevice : public SkBitmapDevice {
 
     GatherPixelRefDevice::drawRect(draw, bounds, paint);
   }
-  virtual void drawVertices(const SkDraw& draw,
+  void drawVertices(const SkDraw& draw,
                     SkCanvas::VertexMode,
                     int vertex_count,
                     const SkPoint verts[],
@@ -299,14 +299,14 @@ class GatherPixelRefDevice : public SkBitmapDevice {
     GatherPixelRefDevice::drawPoints(
         draw, SkCanvas::kPolygon_PointMode, vertex_count, verts, paint);
   }
-  virtual void drawDevice(const SkDraw&,
+  void drawDevice(const SkDraw&,
                   SkBaseDevice*,
                   int x,
                   int y,
                   const SkPaint&) override {}
 
  protected:
-  virtual bool onReadPixels(const SkImageInfo& info,
+  bool onReadPixels(const SkImageInfo& info,
                     void* pixels,
                     size_t rowBytes,
                     int x,
@@ -314,7 +314,7 @@ class GatherPixelRefDevice : public SkBitmapDevice {
     return false;
   }
 
-  virtual bool onWritePixels(const SkImageInfo& info,
+  bool onWritePixels(const SkImageInfo& info,
                      const void* pixels,
                      size_t rowBytes,
                      int x,

skia/ext/pixel_ref_utils_unittest.cc

@@ -34,7 +34,7 @@ class TestDiscardableShader : public SkShader {
     CreateBitmap(gfx::Size(50, 50), "discardable", &bitmap_);
   }
 
-  virtual SkShader::BitmapType asABitmap(SkBitmap* bitmap,
+  SkShader::BitmapType asABitmap(SkBitmap* bitmap,
                                  SkMatrix* matrix,
                                  TileMode xy[2]) const override {
     if (bitmap)
@@ -43,11 +43,9 @@ class TestDiscardableShader : public SkShader {
   }
 
   // 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,
+  void DrawToNativeContext(CGContext* context,
                            int x,
                            int y,
                            const CGRect* src_rect) override;
-  virtual CGContextRef GetBitmapContext() override;
+  CGContextRef GetBitmapContext() override;
 #elif defined(OS_POSIX)
   virtual void DrawToNativeContext(PlatformSurface surface,
                                    int x,