Use const path in SkPathContainsPoint

Source/core/platform/graphics/skia/SkiaUtils.cpp

 /*
  * Copyright (c) 2006,2007,2008, Google Inc. All rights reserved.
  * 
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  * 
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 121 matching lines @@
 {
     return SkPMColorToColor(pm);
 }
 
 void ClipRectToCanvas(const GraphicsContext* context, const SkRect& srcRect, SkRect* destRect)
 {
     if (!context->getClipBounds(destRect) || !destRect->intersect(srcRect))
         destRect->setEmpty();
 }
 
-bool SkPathContainsPoint(SkPath* originalPath, const FloatPoint& point, SkPath::FillType ft)
+bool SkPathContainsPoint(const SkPath& originalPath, const FloatPoint& point, SkPath::FillType ft)
 {
-    SkRect bounds = originalPath->getBounds();
+    SkRect bounds = originalPath.getBounds();
 
     // We can immediately return false if the point is outside the bounding
     // rect.  We don't use bounds.contains() here, since it would exclude
     // points on the right and bottom edges of the bounding rect, and we want
     // to include them.
     SkScalar fX = SkFloatToScalar(point.x());
     SkScalar fY = SkFloatToScalar(point.y());
     if (fX < bounds.fLeft || fX > bounds.fRight || fY < bounds.fTop || fY > bounds.fBottom)
         return false;
 
     // Scale the path to a large size before hit testing for two reasons:
     // 1) Skia has trouble with coordinates close to the max signed 16-bit values, so we scale larger paths down.
     //    TODO: when Skia is patched to work properly with large values, this will not be necessary.
     // 2) Skia does not support analytic hit testing, so we scale paths up to do raster hit testing with subpixel accuracy.
     SkScalar biggestCoord = std::max(std::max(std::max(bounds.fRight, bounds.fBottom), -bounds.fLeft), -bounds.fTop);
     if (SkScalarNearlyZero(biggestCoord))
         return false;
     biggestCoord = std::max(std::max(biggestCoord, fX + 1), fY + 1);
 
     const SkScalar kMaxCoordinate = SkIntToScalar(1 << 15);
     SkScalar scale = SkScalarDiv(kMaxCoordinate, biggestCoord);
 
     SkRegion rgn;  
     SkRegion clip;
     SkMatrix m;
-    SkPath scaledPath;
+    SkPath scaledPath(originalPath);
 
-    SkPath::FillType originalFillType = originalPath->getFillType();
-    originalPath->setFillType(ft);
-
+    scaledPath.setFillType(ft);
     m.setScale(scale, scale);
-    originalPath->transform(m, &scaledPath);
+    scaledPath.transform(m, 0);

[pdr., 2013/07/23 00:27:21]

Oh my, we create a transform just to scale the path? I bet there's another nice
speedup if we just add void path::scale(float, float)!

Just pointing this out in case you want to play in this space in a future patch
:)

 
     int x = static_cast<int>(floorf(0.5f + point.x() * scale));
     int y = static_cast<int>(floorf(0.5f + point.y() * scale));
     clip.setRect(x - 1, y - 1, x + 1, y + 1);
 
-    bool contains = rgn.setPath(scaledPath, clip);
-    originalPath->setFillType(originalFillType);
-    return contains;
+    return rgn.setPath(scaledPath, clip);
 }
 
 }  // namespace WebCore