skia/ext: Updated lazy_pixel_ref_utils style.

skia/ext/lazy_pixel_ref_utils.cc

 // Copyright 2013 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 "lazy_pixel_ref_utils.h"
 
 #include "SkCanvas.h"
 #include "SkData.h"
 #include "SkDevice.h"
 #include "SkDraw.h"
@@ skipping 11 matching lines @@
 
 // URI label for a lazily decoded SkPixelRef.
 const char kLabelLazyDecoded[] = "lazy";
 
 class LazyPixelRefSet {
  public:
   LazyPixelRefSet(
       std::vector<LazyPixelRefUtils::PositionLazyPixelRef>* pixel_refs)
       : pixel_refs_(pixel_refs) {}
 
-  void add(SkPixelRef* pixel_ref, const SkRect& rect) {
+  void Add(SkPixelRef* pixel_ref, const SkRect& rect) {
     // Only save lazy pixel refs.
     if (pixel_ref->getURI() &&
         !strcmp(pixel_ref->getURI(), kLabelLazyDecoded)) {
       LazyPixelRefUtils::PositionLazyPixelRef position_pixel_ref;
       position_pixel_ref.lazy_pixel_ref =
           static_cast<skia::LazyPixelRef*>(pixel_ref);
       position_pixel_ref.pixel_ref_rect = rect;
       pixel_refs_->push_back(position_pixel_ref);
     }
   }
 
  private:
   std::vector<LazyPixelRefUtils::PositionLazyPixelRef>* pixel_refs_;
 };
 
 class GatherPixelRefDevice : public SkDevice {
  public:
   GatherPixelRefDevice(const SkBitmap& bm, LazyPixelRefSet* lazy_pixel_ref_set)
       : SkDevice(bm), lazy_pixel_ref_set_(lazy_pixel_ref_set) {}
 
   virtual void clear(SkColor color) SK_OVERRIDE {}
   virtual void writePixels(const SkBitmap& bitmap,
                            int x,
                            int y,
                            SkCanvas::Config8888 config8888) SK_OVERRIDE {}
 
   virtual void drawPaint(const SkDraw& draw, const SkPaint& paint) SK_OVERRIDE {
     SkBitmap bitmap;
-    if (getBitmapFromPaint(paint, &bitmap)) {
+    if (GetBitmapFromPaint(paint, &bitmap)) {
       SkRect clip_rect = SkRect::Make(draw.fRC->getBounds());
       SkRect canvas_rect = SkRect::MakeWH(width(), height());
       SkRect paint_rect = SkRect::MakeEmpty();
       paint_rect.intersect(canvas_rect, clip_rect);
 
-      addBitmap(bitmap, paint_rect);
+      AddBitmap(bitmap, paint_rect);
     }
   }
 
   virtual void drawPoints(const SkDraw& draw,
                           SkCanvas::PointMode mode,
                           size_t count,
                           const SkPoint points[],
                           const SkPaint& paint) SK_OVERRIDE {
     SkBitmap bitmap;
-    if (!getBitmapFromPaint(paint, &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 {
     SkBitmap bitmap;
-    if (getBitmapFromPaint(paint, &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);
+      AddBitmap(bitmap, mapped_rect);
     }
   }
   virtual void drawOval(const SkDraw& draw,
                         const SkRect& rect,
                         const SkPaint& paint) SK_OVERRIDE {
     GatherPixelRefDevice::drawRect(draw, rect, paint);
   }
   virtual void drawRRect(const SkDraw& draw,
                          const SkRRect& rect,
                          const SkPaint& paint) SK_OVERRIDE {
     GatherPixelRefDevice::drawRect(draw, rect.rect(), paint);
   }
   virtual void drawPath(const SkDraw& draw,
                         const SkPath& path,
                         const SkPaint& paint,
-                        const SkMatrix* prePathMatrix,
-                        bool pathIsMutable) SK_OVERRIDE {
+                        const SkMatrix* pre_path_matrix,
+                        bool path_is_mutable) SK_OVERRIDE {
     SkBitmap bitmap;
-    if (!getBitmapFromPaint(paint, &bitmap))
+    if (!GetBitmapFromPaint(paint, &bitmap))
       return;
 
     SkRect path_bounds = path.getBounds();
     SkRect final_rect;
-    if (prePathMatrix != NULL)
-      prePathMatrix->mapRect(&final_rect, path_bounds);
+    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 SkIRect* srcRectOrNull,
+                          const SkIRect* src_rect_or_null,
                           const SkMatrix& matrix,
                           const SkPaint& paint) SK_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);
+    AddBitmap(bitmap, mapped_rect);
 
     SkBitmap paint_bitmap;
-    if (getBitmapFromPaint(paint, &paint_bitmap))
-      addBitmap(paint_bitmap, mapped_rect);
+    if (GetBitmapFromPaint(paint, &paint_bitmap))
+      AddBitmap(paint_bitmap, mapped_rect);
   }
   virtual void drawBitmapRect(const SkDraw& draw,
                               const SkBitmap& bitmap,
-                              const SkRect* srcOrNull,
+                              const SkRect* src_or_null,
                               const SkRect& dst,
                               const SkPaint& paint) SK_OVERRIDE {
     SkRect bitmap_rect = SkRect::MakeWH(bitmap.width(), bitmap.height());
     SkMatrix matrix;
     matrix.setRectToRect(bitmap_rect, dst, SkMatrix::kFill_ScaleToFit);
     GatherPixelRefDevice::drawBitmap(draw, bitmap, NULL, matrix, paint);
   }
   virtual void drawSprite(const SkDraw& draw,
                           const SkBitmap& bitmap,
                           int x,
                           int y,
                           const SkPaint& paint) SK_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);
+    AddBitmap(bitmap, mapped_rect);
     SkBitmap paint_bitmap;
-    if (getBitmapFromPaint(paint, &paint_bitmap))
-      addBitmap(paint_bitmap, mapped_rect);
+    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 {
     SkBitmap bitmap;
-    if (!getBitmapFromPaint(paint, &bitmap))
+    if (!GetBitmapFromPaint(paint, &bitmap))
       return;
 
     // Math is borrowed from SkBBoxRecord
     SkRect bounds;
     paint.measureText(text, len, &bounds);
     SkPaint::FontMetrics metrics;
     paint.getFontMetrics(&metrics);
 
     if (paint.isVerticalText()) {
       SkScalar h = bounds.fBottom - bounds.fTop;
       if (paint.getTextAlign() == SkPaint::kCenter_Align) {
         bounds.fTop -= h / 2;
         bounds.fBottom -= h / 2;
       }
       bounds.fBottom += metrics.fBottom;
       bounds.fTop += metrics.fTop;
-    }
-    else {
+    } else {
       SkScalar w = bounds.fRight - bounds.fLeft;
       if (paint.getTextAlign() == SkPaint::kCenter_Align) {
         bounds.fLeft -= w / 2;
         bounds.fRight -= w / 2;
       } else if (paint.getTextAlign() == SkPaint::kRight_Align) {
         bounds.fLeft -= w;
         bounds.fRight -= w;
       }
       bounds.fTop = metrics.fTop;
       bounds.fBottom = metrics.fBottom;
     }
 
     SkScalar pad = (metrics.fBottom - metrics.fTop) / 2;
     bounds.fLeft -= pad;
     bounds.fRight += pad;
     bounds.fLeft += x;
     bounds.fRight += x;
     bounds.fTop += y;
     bounds.fBottom += y;
 
     GatherPixelRefDevice::drawRect(draw, bounds, paint);
   }
   virtual void drawPosText(const SkDraw& draw,
                            const void* text,
                            size_t len,
                            const SkScalar pos[],
-                           SkScalar constY,
-                           int scalarsPerPos,
+                           SkScalar const_y,
+                           int scalars_per_pos,
                            const SkPaint& paint) SK_OVERRIDE {
     SkBitmap bitmap;
-    if (!getBitmapFromPaint(paint, &bitmap))
+    if (!GetBitmapFromPaint(paint, &bitmap))
       return;
 
     if (len == 0)
       return;
 
     // Similar to SkDraw asserts.
-    SkASSERT(scalarsPerPos == 1 || scalarsPerPos == 2);
+    SkASSERT(scalars_per_pos == 1 || scalars_per_pos == 2);
 
     SkPoint min_point;
     SkPoint max_point;
-    if (scalarsPerPos == 1) {
-      min_point.set(pos[0], constY);
-      max_point.set(pos[0], constY);
-    } else if (scalarsPerPos == 2) {
-      min_point.set(pos[0], constY + pos[1]);
-      max_point.set(pos[0], constY + pos[1]);
+    if (scalars_per_pos == 1) {
+      min_point.set(pos[0], const_y);
+      max_point.set(pos[0], const_y);
+    } else if (scalars_per_pos == 2) {
+      min_point.set(pos[0], const_y + pos[1]);
+      max_point.set(pos[0], const_y + pos[1]);
     }
 
     for (size_t i = 0; i < len; ++i) {
-      SkScalar x = pos[i * scalarsPerPos];
-      SkScalar y = constY;
-      if (scalarsPerPos == 2)
-        y += pos[i * scalarsPerPos + 1];
+      SkScalar x = pos[i * scalars_per_pos];
+      SkScalar y = const_y;
+      if (scalars_per_pos == 2)
+        y += pos[i * scalars_per_pos + 1];
 
-      min_point.set(
-        std::min(x, min_point.x()),
-        std::min(y, min_point.y()));
-      max_point.set(
-        std::max(x, max_point.x()),
-        std::max(y, max_point.y()));
+      min_point.set(std::min(x, min_point.x()), std::min(y, min_point.y()));
+      max_point.set(std::max(x, max_point.x()), std::max(y, max_point.y()));
     }
-    
+
     SkRect bounds = SkRect::MakeLTRB(
         min_point.x(), min_point.y(), max_point.x(), max_point.y());
 
     // Math is borrowed from SkBBoxRecord
     SkPaint::FontMetrics metrics;
     paint.getFontMetrics(&metrics);
 
     bounds.fTop += metrics.fTop;
     bounds.fBottom += metrics.fBottom;
 
     SkScalar pad = (metrics.fTop - metrics.fBottom) / 2;
     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 {
     SkBitmap bitmap;
-    if (!getBitmapFromPaint(paint, &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 vertexCount,
+                            int vertex_count,
                             const SkPoint verts[],
                             const SkPoint texs[],
                             const SkColor colors[],
                             SkXfermode* xmode,
                             const uint16_t indices[],
-                            int indexCount,
+                            int index_count,
                             const SkPaint& paint) SK_OVERRIDE {
     GatherPixelRefDevice::drawPoints(
-        draw, SkCanvas::kPolygon_PointMode, vertexCount, verts, paint);
+        draw, SkCanvas::kPolygon_PointMode, vertex_count, verts, paint);
   }
   virtual void drawDevice(const SkDraw&,
                           SkDevice*,
                           int x,
                           int y,
                           const SkPaint&) SK_OVERRIDE {}
 
  protected:
   virtual bool onReadPixels(const SkBitmap& bitmap,
                             int x,
                             int y,
                             SkCanvas::Config8888 config8888) SK_OVERRIDE {
     return false;
   }
 
  private:
   LazyPixelRefSet* lazy_pixel_ref_set_;
 
-  void addBitmap(const SkBitmap& bm, const SkRect& rect) {
-    lazy_pixel_ref_set_->add(bm.pixelRef(), rect);
+  void AddBitmap(const SkBitmap& bm, const SkRect& rect) {
+    lazy_pixel_ref_set_->Add(bm.pixelRef(), rect);
   }
 
-  bool getBitmapFromPaint(const SkPaint& paint, SkBitmap* bm) {
+  bool GetBitmapFromPaint(const SkPaint& paint, SkBitmap* bm) {
     SkShader* shader = paint.getShader();
     if (shader) {
       // Check whether the shader is a gradient in order to prevent generation
       // of bitmaps from gradient shaders, which implement asABitmap.
       if (SkShader::kNone_GradientType == shader->asAGradient(NULL))
         return shader->asABitmap(bm, NULL, NULL);
     }
     return false;
   }
-
 };
 
 class NoSaveLayerCanvas : public SkCanvas {
  public:
   NoSaveLayerCanvas(SkDevice* device) : INHERITED(device) {}
 
   // Turn saveLayer() into save() for speed, should not affect correctness.
   virtual int saveLayer(const SkRect* bounds,
                         const SkPaint* paint,
                         SaveFlags flags) SK_OVERRIDE {
@@ skipping 29 matching lines @@
 };
 
 }  // namespace
 
 void LazyPixelRefUtils::GatherPixelRefs(
     SkPicture* picture,
     std::vector<PositionLazyPixelRef>* lazy_pixel_refs) {
   lazy_pixel_refs->clear();
   LazyPixelRefSet pixel_ref_set(lazy_pixel_refs);
 
-  SkBitmap emptyBitmap;
-  emptyBitmap.setConfig(
+  SkBitmap empty_bitmap;
+  empty_bitmap.setConfig(
       SkBitmap::kNo_Config, picture->width(), picture->height());
 
-  GatherPixelRefDevice device(emptyBitmap, &pixel_ref_set);
+  GatherPixelRefDevice device(empty_bitmap, &pixel_ref_set);
   NoSaveLayerCanvas canvas(&device);
 
   canvas.clipRect(SkRect::MakeWH(picture->width(), picture->height()),
                   SkRegion::kIntersect_Op,
                   false);
   canvas.drawPicture(*picture);
 }
 
 }  // namespace skia