Replace OVERRIDE with its C++11 counterparts in src/skia

skia/ext/pixel_ref_utils.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "skia/ext/pixel_ref_utils.h"
 
 #include <algorithm>
 
 #include "third_party/skia/include/core/SkBitmapDevice.h"
 #include "third_party/skia/include/core/SkCanvas.h"
@@ skipping 33 matching lines @@
  private:
   std::vector<PixelRefUtils::PositionPixelRef>* pixel_refs_;
 };
 
 class GatherPixelRefDevice : public SkBitmapDevice {
  public:
   GatherPixelRefDevice(const SkBitmap& bm,
                        DiscardablePixelRefSet* pixel_ref_set)
       : SkBitmapDevice(bm), pixel_ref_set_(pixel_ref_set) {}
 
-  virtual void clear(SkColor color) SK_OVERRIDE {}
-  virtual void drawPaint(const SkDraw& draw, const SkPaint& paint) SK_OVERRIDE {
+  virtual void clear(SkColor color) override {}
+  virtual void drawPaint(const SkDraw& draw, const SkPaint& paint) override {
     SkBitmap bitmap;
     if (GetBitmapFromPaint(paint, &bitmap)) {
       SkRect clip_rect = SkRect::Make(draw.fRC->getBounds());
       AddBitmap(bitmap, clip_rect);
     }
   }
 
   virtual void drawPoints(const SkDraw& draw,
                           SkCanvas::PointMode mode,
                           size_t count,
                           const SkPoint points[],
-                          const SkPaint& paint) SK_OVERRIDE {
+                          const SkPaint& paint) override {
     SkBitmap bitmap;
     if (!GetBitmapFromPaint(paint, &bitmap))
       return;
 
     if (count == 0)
       return;
 
     SkPoint min_point = points[0];
     SkPoint max_point = points[0];
     for (size_t i = 1; i < count; ++i) {
       const SkPoint& point = points[i];
       min_point.set(std::min(min_point.x(), point.x()),
                     std::min(min_point.y(), point.y()));
       max_point.set(std::max(max_point.x(), point.x()),
                     std::max(max_point.y(), point.y()));
     }
 
     SkRect bounds = SkRect::MakeLTRB(
         min_point.x(), min_point.y(), max_point.x(), max_point.y());
 
     GatherPixelRefDevice::drawRect(draw, bounds, paint);
   }
   virtual void drawRect(const SkDraw& draw,
                         const SkRect& rect,
-                        const SkPaint& paint) SK_OVERRIDE {
+                        const SkPaint& paint) override {
     SkBitmap bitmap;
     if (GetBitmapFromPaint(paint, &bitmap)) {
       SkRect mapped_rect;
       draw.fMatrix->mapRect(&mapped_rect, rect);
       mapped_rect.intersect(SkRect::Make(draw.fRC->getBounds()));
       AddBitmap(bitmap, mapped_rect);
     }
   }
   virtual void drawOval(const SkDraw& draw,
                         const SkRect& rect,
-                        const SkPaint& paint) SK_OVERRIDE {
+                        const SkPaint& paint) override {
     GatherPixelRefDevice::drawRect(draw, rect, paint);
   }
   virtual void drawRRect(const SkDraw& draw,
                          const SkRRect& rect,
-                         const SkPaint& paint) SK_OVERRIDE {
+                         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) SK_OVERRIDE {
+                        bool path_is_mutable) override {
     SkBitmap bitmap;
     if (!GetBitmapFromPaint(paint, &bitmap))
       return;
 
     SkRect path_bounds = path.getBounds();
     SkRect final_rect;
     if (pre_path_matrix != NULL)
       pre_path_matrix->mapRect(&final_rect, path_bounds);
     else
       final_rect = path_bounds;
 
     GatherPixelRefDevice::drawRect(draw, final_rect, paint);
   }
   virtual void drawBitmap(const SkDraw& draw,
                           const SkBitmap& bitmap,
                           const SkMatrix& matrix,
-                          const SkPaint& paint) SK_OVERRIDE {
+                          const SkPaint& paint) override {
     SkMatrix total_matrix;
     total_matrix.setConcat(*draw.fMatrix, matrix);
 
     SkRect bitmap_rect = SkRect::MakeWH(bitmap.width(), bitmap.height());
     SkRect mapped_rect;
     total_matrix.mapRect(&mapped_rect, bitmap_rect);
     AddBitmap(bitmap, mapped_rect);
 
     SkBitmap paint_bitmap;
     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) SK_OVERRIDE {
+                              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) SK_OVERRIDE {
+                          const SkPaint& paint) override {
     // Sprites aren't affected by current matrix, so we can't reuse drawRect.
     SkMatrix matrix;
     matrix.setTranslate(x, y);
 
     SkRect bitmap_rect = SkRect::MakeWH(bitmap.width(), bitmap.height());
     SkRect mapped_rect;
     matrix.mapRect(&mapped_rect, bitmap_rect);
 
     AddBitmap(bitmap, mapped_rect);
     SkBitmap paint_bitmap;
     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) SK_OVERRIDE {
+                        const SkPaint& paint) override {
     SkBitmap bitmap;
     if (!GetBitmapFromPaint(paint, &bitmap))
       return;
 
     // Math is borrowed from SkBBoxRecord
     SkRect bounds;
     paint.measureText(text, len, &bounds);
     SkPaint::FontMetrics metrics;
     paint.getFontMetrics(&metrics);
 
@@ skipping 27 matching lines @@
     bounds.fBottom += y;
 
     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) SK_OVERRIDE {
+                           const SkPaint& paint) override {
     SkBitmap bitmap;
     if (!GetBitmapFromPaint(paint, &bitmap))
       return;
 
     if (len == 0)
       return;
 
     // Similar to SkDraw asserts.
     SkASSERT(scalars_per_pos == 1 || scalars_per_pos == 2);
 
@@ skipping 23 matching lines @@
     bounds.fLeft += pad;
     bounds.fRight -= pad;
 
     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) SK_OVERRIDE {
+                              const SkPaint& paint) override {
     SkBitmap bitmap;
     if (!GetBitmapFromPaint(paint, &bitmap))
       return;
 
     // Math is borrowed from SkBBoxRecord
     SkRect bounds = path.getBounds();
     SkPaint::FontMetrics metrics;
     paint.getFontMetrics(&metrics);
 
     SkScalar pad = metrics.fTop;
     bounds.fLeft += pad;
     bounds.fRight -= pad;
     bounds.fTop += pad;
     bounds.fBottom -= pad;
 
     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) SK_OVERRIDE {
+                            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&) SK_OVERRIDE {}
+                          const SkPaint&) override {}
 
  protected:
   virtual bool onReadPixels(const SkImageInfo& info,
                             void* pixels,
                             size_t rowBytes,
                             int x,
-                            int y) SK_OVERRIDE {
+                            int y) override {
     return false;
   }
 
   virtual bool onWritePixels(const SkImageInfo& info,
                              const void* pixels,
                              size_t rowBytes,
                              int x,
-                             int y) SK_OVERRIDE {
+                             int y) override {
     return false;
   }
 
  private:
   DiscardablePixelRefSet* pixel_ref_set_;
 
   void AddBitmap(const SkBitmap& bm, const SkRect& rect) {
     SkRect canvas_rect = SkRect::MakeWH(width(), height());
     SkRect paint_rect = SkRect::MakeEmpty();
     paint_rect.intersect(rect, canvas_rect);
@@ skipping 26 matching lines @@
   GatherPixelRefDevice device(empty_bitmap, &pixel_ref_set);
   SkNoSaveLayerCanvas canvas(&device);
 
   canvas.clipRect(SkRect::MakeWH(picture->width(), picture->height()),
                   SkRegion::kIntersect_Op,
                   false);
   canvas.drawPicture(picture);
 }
 
 }  // namespace skia