Revert of Fix pointer-events:all when stroke="none"

Source/core/rendering/svg/RenderSVGShape.cpp

 /*
  * Copyright (C) 2004, 2005, 2007 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2008 Rob Buis <buis@kde.org>
  * Copyright (C) 2005, 2007 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Google, Inc.
  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  * Copyright (C) 2009 Jeff Schiller <codedread@gmail.com>
  * Copyright (C) 2011 Renata Hodovan <reni@webkit.org>
  * Copyright (C) 2011 University of Szeged
@@ skipping 46 matching lines @@
 void RenderSVGShape::updateShapeFromElement()
 {
     m_path.clear();
     m_path = adoptPtr(new Path);
     ASSERT(RenderSVGShape::isShapeEmpty());
 
     updatePathFromGraphicsElement(toSVGGraphicsElement(element()), path());
     processMarkerPositions();
 
     m_fillBoundingBox = calculateObjectBoundingBox();
-    m_hitTestStrokeBoundingBox = calculateHitTestStrokeBoundingBox();
-    m_strokeBoundingBox = style()->svgStyle().hasStroke() ? m_hitTestStrokeBoundingBox : m_fillBoundingBox;
+    m_strokeBoundingBox = calculateStrokeBoundingBox();
 }
 
 bool RenderSVGShape::shapeDependentStrokeContains(const FloatPoint& point)
 {
     ASSERT(m_path);
     StrokeData strokeData;
     SVGRenderSupport::applyStrokeStyleToStrokeData(&strokeData, style(), this);
 
     if (hasNonScalingStroke()) {
         AffineTransform nonScalingTransform = nonScalingStrokeTransform();
@@ skipping 16 matching lines @@
         return false;
 
     if (requiresFill && !SVGPaintServer::existsForRenderer(*this, style(), ApplyToFillMode))
         return false;
 
     return shapeDependentFillContains(point, fillRule);
 }
 
 bool RenderSVGShape::strokeContains(const FloatPoint& point, bool requiresStroke)
 {
-    if (requiresStroke) {
-        if (!strokeBoundingBox().contains(point))
-            return false;
+    if (!strokeBoundingBox().contains(point))
+        return false;
 
-        if (!SVGPaintServer::existsForRenderer(*this, style(), ApplyToStrokeMode))
-            return false;
-    } else {
-        if (!hitTestStrokeBoundingBox().contains(point))
-            return false;
-    }
+    if (requiresStroke && !SVGPaintServer::existsForRenderer(*this, style(), ApplyToStrokeMode))
+        return false;
 
     return shapeDependentStrokeContains(point);
 }
 
 void RenderSVGShape::updateLocalTransform()
 {
     SVGGraphicsElement* graphicsElement = toSVGGraphicsElement(element());
     if (graphicsElement->hasAnimatedLocalTransform()) {
         if (m_localTransform)
             m_localTransform->setTransform(graphicsElement->calculateAnimatedLocalTransform());
@@ skipping 95 matching lines @@
             return true;
     }
     return false;
 }
 
 FloatRect RenderSVGShape::calculateObjectBoundingBox() const
 {
     return path().boundingRect();
 }
 
-FloatRect RenderSVGShape::calculateHitTestStrokeBoundingBox() const
+FloatRect RenderSVGShape::calculateStrokeBoundingBox() const
 {
     ASSERT(m_path);
     FloatRect strokeBoundingBox = m_fillBoundingBox;
 
-    StrokeData strokeData;
-    SVGRenderSupport::applyStrokeStyleToStrokeData(&strokeData, style(), this);
-    if (hasNonScalingStroke()) {
-        AffineTransform nonScalingTransform = nonScalingStrokeTransform();
-        if (nonScalingTransform.isInvertible()) {
-            Path* usePath = nonScalingStrokePath(m_path.get(), nonScalingTransform);
-            FloatRect strokeBoundingRect = usePath->strokeBoundingRect(strokeData);
-            strokeBoundingRect = nonScalingTransform.inverse().mapRect(strokeBoundingRect);
-            strokeBoundingBox.unite(strokeBoundingRect);
+    if (style()->svgStyle().hasStroke()) {
+        StrokeData strokeData;
+        SVGRenderSupport::applyStrokeStyleToStrokeData(&strokeData, style(), this);
+        if (hasNonScalingStroke()) {
+            AffineTransform nonScalingTransform = nonScalingStrokeTransform();
+            if (nonScalingTransform.isInvertible()) {
+                Path* usePath = nonScalingStrokePath(m_path.get(), nonScalingTransform);
+                FloatRect strokeBoundingRect = usePath->strokeBoundingRect(strokeData);
+                strokeBoundingRect = nonScalingTransform.inverse().mapRect(strokeBoundingRect);
+                strokeBoundingBox.unite(strokeBoundingRect);
+            }
+        } else {
+            strokeBoundingBox.unite(path().strokeBoundingRect(strokeData));
         }
-    } else {
-        strokeBoundingBox.unite(path().strokeBoundingRect(strokeData));
     }
 
     return strokeBoundingBox;
 }
 
 void RenderSVGShape::updatePaintInvalidationBoundingBox()
 {
     m_paintInvalidationBoundingBox = strokeBoundingBox();
     if (strokeWidth() < 1.0f && !m_paintInvalidationBoundingBox.isEmpty())
         m_paintInvalidationBoundingBox.inflate(1);
     SVGRenderSupport::intersectPaintInvalidationRectWithResources(this, m_paintInvalidationBoundingBox);
 }
 
 float RenderSVGShape::strokeWidth() const
 {
     SVGLengthContext lengthContext(element());
     return style()->svgStyle().strokeWidth()->value(lengthContext);
 }
 
 }