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)
 {
-    if (m_lastSize != containerSize) {
-        m_region = adoptPtr(new Path(getRegion(containerSize)));
-        m_lastSize = containerSize;
-    }
-
-    return m_region->contains(FloatPoint(location));
+    return getPath().contains(FloatPoint(location));
 }
 
-Path HTMLAreaElement::computePath(const LayoutObject* obj) const
+LayoutRect HTMLAreaElement::computeAbsoluteRect() const
 {
-    if (!obj)
-        return Path();
+    LayoutObject* object = imageElementLayoutObject();
+    if (!object)
+        return LayoutRect();
 
     // FIXME: This doesn't work correctly with transforms.
-    FloatPoint absPos = obj->localToAbsolute();
+    FloatPoint absPos = object->localToAbsolute();
 
-    // 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();
+    Path p = getPath();
+    float zoomFactor = object->styleRef().effectiveZoom();
     if (zoomFactor != 1.0f) {
         AffineTransform zoomTransform;
         zoomTransform.scale(zoomFactor);
         p.transform(zoomTransform);
     }
 
     p.translate(toFloatSize(absPos));
-    return p;
+    return enclosingLayoutRect(p.boundingRect());
 }
 
-LayoutRect HTMLAreaElement::computeRect(const LayoutObject* obj) const
+const Path& HTMLAreaElement::getPath() const
 {
-    return enclosingLayoutRect(computePath(obj).boundingRect());
-}
+    if (m_path)
+        return *m_path;
 
-Path HTMLAreaElement::getRegion(const LayoutSize& size) const
-{
+    m_path = adoptPtr(new Path);
+
     if (m_coords.isEmpty() && m_shape != Default)
-        return Path();
+        return *m_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])));
+            m_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);
+                m_path->addLineTo(FloatPoint(clampCoordinate(m_coords[i * 2]), clampCoordinate(m_coords[i * 2 + 1])));
+            m_path->closeSubpath();
+            m_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));
+            m_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));
+            m_path->addRect(FloatRect(x0, y0, x1 - x0, y1 - y0));
         }
         break;
     case Default:
-        path.addRect(FloatRect(FloatPoint(0, 0), FloatSize(size)));
+        if (LayoutObject* object = imageElementLayoutObject()) {
+            if (object->isBox())
+                m_path->addRect(FloatRect(toLayoutBox(object)->contentBoxRect()));
+        }
         break;
     }
 
-    return path;
+    return *m_path;
 }
 
 HTMLImageElement* HTMLAreaElement::imageElement() const
 {
     if (HTMLMapElement* mapElement = Traversal<HTMLMapElement>::firstAncestor(*this))
         return mapElement->imageElement();
     return nullptr;
 }
 
+LayoutObject* HTMLAreaElement::imageElementLayoutObject() const
+{
+    if (HTMLImageElement* imageElement = this->imageElement())
+        return imageElement->layoutObject();
+    return nullptr;
+}
+
 bool HTMLAreaElement::isKeyboardFocusable() const
 {
     return isFocusable();
 }
 
 bool HTMLAreaElement::isMouseFocusable() const
 {
     return isFocusable();
 }
 
@@ skipping 28 matching lines @@
 {
     document().updateLayoutTreeForNode(this);
     if (!isFocusable())
         return;
 
     if (HTMLImageElement* imageElement = this->imageElement())
         imageElement->updateFocusAppearance(selectionBehavior);
 }
 
 } // namespace blink