Drop SkPathContainsPoint in favor of SkPath::contains

third_party/WebKit/Source/platform/graphics/Path.cpp

 /*
  * Copyright (C) 2003, 2006 Apple Computer, Inc.  All rights reserved.
  *                     2006 Rob Buis <buis@kde.org>
  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2013 Google Inc. All rights reserved.
  * Copyright (C) 2013 Intel Corporation. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
@@ skipping 56 matching lines @@
     return *this;
 }
 
 bool Path::operator==(const Path& other) const
 {
     return m_path == other.m_path;
 }
 
 bool Path::contains(const FloatPoint& point) const
 {
-    return SkPathContainsPoint(m_path, point, m_path.getFillType());
+    return m_path.contains(WebCoreFloatToSkScalar(point.x()), WebCoreFloatToSkScalar(point.y()));
 }
 
 bool Path::contains(const FloatPoint& point, WindRule rule) const
 {
-    return SkPathContainsPoint(m_path, point, WebCoreWindRuleToSkFillType(rule));
+    SkPath::FillType previousFillType = m_path.getFillType();
+    const_cast<SkPath&>(m_path).setFillType(WebCoreWindRuleToSkFillType(rule));

[fs, 2015/12/18 15:43:44]

Yes, this is pretty horrendous...

[f(malita), 2015/12/18 15:56:22]

How about something like

  if (WebCoreWindRuleToSkFillType(rule) != m_path.getFillType()) {
      SkPath tmp(m_path);
      tmp.setFilType(...);
      return tmp.contains(...);
  }
  return m_path.contains(...);


(the copy should be cheap/shallow)

I bet we could also get rid of this version, but not sure how much effort it'd
take to stop side-caring windrule, so let's not worry about that for now :)

[fs, 2015/12/18 16:48:02]

Yes, maybe that's a reasonable trade-off - hopefully all the atomic(op)s won't
be too noticeable... Let's try it.
 
I was planning on maybe taking a pass over those once this had settled - some
should definitely be possible to push over to the other overload without to much
effort.

+    bool isInside = m_path.contains(WebCoreFloatToSkScalar(point.x()), WebCoreFloatToSkScalar(point.y()));
+    const_cast<SkPath&>(m_path).setFillType(previousFillType);
+    return isInside;
 }
 
 // FIXME: this method ignores the CTM and may yield inaccurate results for large scales.
 SkPath Path::strokePath(const StrokeData& strokeData) const
 {
     SkPaint paint;
     strokeData.setupPaint(&paint);
 
     // Skia stroke resolution scale. This is multiplied by 4 internally
     // (i.e. 1.0 corresponds to 1/4 pixel res).
     static const SkScalar kResScale = 0.3f;
 
     SkPath strokePath;
     paint.getFillPath(m_path, &strokePath, nullptr, kResScale);
 
     return strokePath;
 }
 
 bool Path::strokeContains(const FloatPoint& point, const StrokeData& strokeData) const
 {
-    return SkPathContainsPoint(strokePath(strokeData), point, SkPath::kWinding_FillType);
+    return strokePath(strokeData).contains(WebCoreFloatToSkScalar(point.x()), WebCoreFloatToSkScalar(point.y()));
 }
 
 FloatRect Path::boundingRect() const
 {
     return m_path.getBounds();
 }
 
 FloatRect Path::strokeBoundingRect(const StrokeData& strokeData) const
 {
     return strokePath(strokeData).getBounds();
@@ skipping 374 matching lines @@
 
 #if ENABLE(ASSERT)
 bool ellipseIsRenderable(float startAngle, float endAngle)
 {
     return (std::abs(endAngle - startAngle) < twoPiFloat)
         || WebCoreFloatNearlyEqual(std::abs(endAngle - startAngle), twoPiFloat);
 }
 #endif
 
 } // namespace blink