Fix image map focus ring painting

third_party/WebKit/Source/core/html/HTMLAreaElement.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2009, 2011 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
@@ skipping 30 matching lines @@
 {
     return LayoutUnit(value).toFloat();
 }
 
 }
 
 using namespace HTMLNames;
 
 inline HTMLAreaElement::HTMLAreaElement(Document& document)
     : HTMLAnchorElement(areaTag, document)
-    , m_lastSize(-1, -1)
     , m_shape(Rect)
 {
 }
 
 // An explicit empty destructor should be in HTMLAreaElement.cpp, because
 // if an implicit destructor is used or an empty destructor is defined in
 // HTMLAreaElement.h, when including HTMLAreaElement.h, msvc tries to expand
 // the destructor and causes a compile error because of lack of blink::Path
 // definition.
 HTMLAreaElement::~HTMLAreaElement()
 {
 }
 
 DEFINE_NODE_FACTORY(HTMLAreaElement)
 
 void HTMLAreaElement::parseAttribute(const QualifiedName& name, const AtomicString& oldValue, const AtomicString& value)
 {
     if (name == shapeAttr) {
         if (equalIgnoringASCIICase(value, "default")) {
             m_shape = Default;
         } else if (equalIgnoringASCIICase(value, "circle") || equalIgnoringASCIICase(value, "circ")) {
             m_shape = Circle;
         } else if (equalIgnoringASCIICase(value, "polygon") || equalIgnoringASCIICase(value, "poly")) {
             m_shape = Poly;
         } else {
             // The missing (and implicitly invalid) value default for the
             // 'shape' attribute is 'rect'.
             m_shape = Rect;
         }
-        invalidateCachedRegion();
+        invalidateCachedPath();
     } else if (name == coordsAttr) {
         m_coords = parseHTMLListOfFloatingPointNumbers(value.getString());
-        invalidateCachedRegion();
+        invalidateCachedPath();
     } else if (name == altAttr || name == accesskeyAttr) {
         // Do nothing.
     } else {
         HTMLAnchorElement::parseAttribute(name, oldValue, value);
     }
 }
 
-void HTMLAreaElement::invalidateCachedRegion()
+void HTMLAreaElement::invalidateCachedPath()
 {
-    m_lastSize = LayoutSize(-1, -1);
+    m_path = nullptr;
 }
 
-bool HTMLAreaElement::pointInArea(LayoutPoint location, const LayoutSize& containerSize)
+bool HTMLAreaElement::pointInArea(const LayoutPoint& location, const LayoutObject* containerObject) const
 {
-    if (m_lastSize != containerSize) {
-        m_region = adoptPtr(new Path(getRegion(containerSize)));
-        m_lastSize = containerSize;
+    return getPath(containerObject).contains(FloatPoint(location));
+}
+
+LayoutRect HTMLAreaElement::computeAbsoluteRect(const LayoutObject* containerObject) const
+{
+    if (!containerObject)
+        return LayoutRect();
+
+    // FIXME: This doesn't work correctly with transforms.
+    FloatPoint absPos = containerObject->localToAbsolute();
+
+    Path path = getPath(containerObject);
+    path.translate(toFloatSize(absPos));
+    return enclosingLayoutRect(path.boundingRect());
+}
+
+Path HTMLAreaElement::getPath(const LayoutObject* containerObject) const
+{
+    if (!containerObject)
+        return Path();
+
+    // Always recompute for default shape because it depends on container object's size
+    // and is cheap.
+    if (m_shape == Default) {
+        Path path;
+        // No need to zoom because it is already applied in containerObject->borderBoxRect().
+        if (containerObject->isBox())
+            path.addRect(FloatRect(toLayoutBox(containerObject)->borderBoxRect()));
+        m_path = nullptr;
+        return path;
     }
 
-    return m_region->contains(FloatPoint(location));
-}
+    Path path;
+    if (m_path) {
+        path = *m_path;
+    } else {
+        if (m_coords.isEmpty())
+            return path;
 
-Path HTMLAreaElement::computePath(const LayoutObject* obj) const
-{
-    if (!obj)
-        return Path();
+        switch (m_shape) {
+        case Poly:
+            if (m_coords.size() >= 6) {
+                int numPoints = m_coords.size() / 2;
+                path.moveTo(FloatPoint(clampCoordinate(m_coords[0]), clampCoordinate(m_coords[1])));
+                for (int i = 1; i < numPoints; ++i)
+                    path.addLineTo(FloatPoint(clampCoordinate(m_coords[i * 2]), clampCoordinate(m_coords[i * 2 + 1])));
+                path.closeSubpath();
+                path.setWindRule(RULE_EVENODD);
+            }
+            break;
+        case Circle:
+            if (m_coords.size() >= 3 && m_coords[2] > 0) {
+                float r = clampCoordinate(m_coords[2]);
+                path.addEllipse(FloatRect(clampCoordinate(m_coords[0]) - r, clampCoordinate(m_coords[1]) - r, 2 * r, 2 * r));
+            }
+            break;
+        case Rect:
+            if (m_coords.size() >= 4) {
+                float x0 = clampCoordinate(m_coords[0]);
+                float y0 = clampCoordinate(m_coords[1]);
+                float x1 = clampCoordinate(m_coords[2]);
+                float y1 = clampCoordinate(m_coords[3]);
+                path.addRect(FloatRect(x0, y0, x1 - x0, y1 - y0));
+            }
+            break;
+        default:
+            ASSERT_NOT_REACHED();
+            break;
+        }
 
-    // FIXME: This doesn't work correctly with transforms.
-    FloatPoint absPos = obj->localToAbsolute();
+        // Cache the original path, not depending on containerObject.
+        m_path = adoptPtr(new Path(path));
+    }
 
-    // Default should default to the size of the containing object.
-    LayoutSize size = m_lastSize;
-    if (m_shape == Default)
-        size = obj->absoluteClippedOverflowRect().size();
-
-    Path p = getRegion(size);
-    float zoomFactor = obj->style()->effectiveZoom();
+    // Zoom the path into coordinates of the container object.
+    float zoomFactor = containerObject->styleRef().effectiveZoom();
     if (zoomFactor != 1.0f) {
         AffineTransform zoomTransform;
         zoomTransform.scale(zoomFactor);
-        p.transform(zoomTransform);
+        path.transform(zoomTransform);
     }
-
-    p.translate(toFloatSize(absPos));
-    return p;
-}
-
-LayoutRect HTMLAreaElement::computeRect(const LayoutObject* obj) const
-{
-    return enclosingLayoutRect(computePath(obj).boundingRect());
-}
-
-Path HTMLAreaElement::getRegion(const LayoutSize& size) const
-{
-    if (m_coords.isEmpty() && m_shape != Default)
-        return Path();
-
-    Path path;
-    switch (m_shape) {
-    case Poly:
-        if (m_coords.size() >= 6) {
-            int numPoints = m_coords.size() / 2;
-            path.moveTo(FloatPoint(clampCoordinate(m_coords[0]), clampCoordinate(m_coords[1])));
-            for (int i = 1; i < numPoints; ++i)
-                path.addLineTo(FloatPoint(clampCoordinate(m_coords[i * 2]), clampCoordinate(m_coords[i * 2 + 1])));
-            path.closeSubpath();
-            path.setWindRule(RULE_EVENODD);
-        }
-        break;
-    case Circle:
-        if (m_coords.size() >= 3 && m_coords[2] > 0) {
-            float r = clampCoordinate(m_coords[2]);
-            path.addEllipse(FloatRect(clampCoordinate(m_coords[0]) - r, clampCoordinate(m_coords[1]) - r, 2 * r, 2 * r));
-        }
-        break;
-    case Rect:
-        if (m_coords.size() >= 4) {
-            float x0 = clampCoordinate(m_coords[0]);
-            float y0 = clampCoordinate(m_coords[1]);
-            float x1 = clampCoordinate(m_coords[2]);
-            float y1 = clampCoordinate(m_coords[3]);
-            path.addRect(FloatRect(x0, y0, x1 - x0, y1 - y0));
-        }
-        break;
-    case Default:
-        path.addRect(FloatRect(FloatPoint(0, 0), FloatSize(size)));
-        break;
-    }
-
     return path;
 }
 
 HTMLImageElement* HTMLAreaElement::imageElement() const
 {
     if (HTMLMapElement* mapElement = Traversal<HTMLMapElement>::firstAncestor(*this))
         return mapElement->imageElement();
     return nullptr;
 }
 
@@ skipping 38 matching lines @@
 {
     document().updateLayoutTreeForNode(this);
     if (!isFocusable())
         return;
 
     if (HTMLImageElement* imageElement = this->imageElement())
         imageElement->updateFocusAppearance(selectionBehavior);
 }
 
 } // namespace blink