Rename renderer() to layoutObject().

Source/modules/accessibility/AXObjectCacheImpl.cpp

 /*
  * Copyright (C) 2014, 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 188 matching lines @@
         return 0;
 
     return m_objects.get(axID);
 }
 
 AXObject* AXObjectCacheImpl::get(Node* node)
 {
     if (!node)
         return 0;
 
-    AXID layoutID = node->renderer() ? m_layoutObjectMapping.get(node->renderer()) : 0;
+    AXID layoutID = node->layoutObject() ? m_layoutObjectMapping.get(node->layoutObject()) : 0;
     ASSERT(!HashTraits<AXID>::isDeletedValue(layoutID));
 
     AXID nodeID = m_nodeObjectMapping.get(node);
     ASSERT(!HashTraits<AXID>::isDeletedValue(nodeID));
 
-    if (node->renderer() && nodeID && !layoutID) {
+    if (node->layoutObject() && nodeID && !layoutID) {
         // This can happen if an AXNodeObject is created for a node that's not
         // laid out, but later something changes and it gets a layoutObject (like if it's
         // reparented).
         remove(nodeID);
         return 0;
     }
 
     if (layoutID)
         return m_objects.get(layoutID);
 
@@ skipping 123 matching lines @@
 }
 
 AXObject* AXObjectCacheImpl::getOrCreate(Node* node)
 {
     if (!node)
         return 0;
 
     if (AXObject* obj = get(node))
         return obj;
 
-    if (node->renderer())
-        return getOrCreate(node->renderer());
+    if (node->layoutObject())
+        return getOrCreate(node->layoutObject());
 
     if (!node->parentElement())
         return 0;
 
     // It's only allowed to create an AXObject from a Node if it's in a canvas subtree.
     // Or if it's a hidden element, but we still want to expose it because of other ARIA attributes.
     bool inCanvasSubtree = node->parentElement()->isInCanvasSubtree();
-    bool isHidden = !node->renderer() && isNodeAriaVisible(node);
+    bool isHidden = !node->layoutObject() && isNodeAriaVisible(node);
     if (!inCanvasSubtree && !isHidden)
         return 0;
 
     RefPtr<AXObject> newObj = createFromNode(node);
 
     // Will crash later if we have two objects for the same node.
     ASSERT(!get(node));
 
     getAXID(newObj.get());
 
@@ skipping 138 matching lines @@
     if (!node)
         return;
 
     removeNodeForUse(node);
 
     // This is all safe even if we didn't have a mapping.
     AXID axID = m_nodeObjectMapping.get(node);
     remove(axID);
     m_nodeObjectMapping.remove(node);
 
-    if (node->renderer()) {
-        remove(node->renderer());
+    if (node->layoutObject()) {
+        remove(node->layoutObject());
         return;
     }
 }
 
 void AXObjectCacheImpl::remove(Widget* view)
 {
     if (!view)
         return;
 
     AXID axID = m_widgetObjectMapping.get(view);
@@ skipping 151 matching lines @@
             continue;
 
         if (!obj->axObjectCache())
             continue;
 
 #if ENABLE(ASSERT)
         // Make sure none of the layout views are in the process of being layed out.
         // Notifications should only be sent after the layoutObject has finished
         if (obj->isAXLayoutObject()) {
             AXLayoutObject* layoutObj = toAXLayoutObject(obj);
-            LayoutObject* layoutObject = layoutObj->renderer();
+            LayoutObject* layoutObject = layoutObj->layoutObject();
             if (layoutObject && layoutObject->view())
                 ASSERT(!layoutObject->view()->layoutState());
         }
 #endif
 
         AXNotification notification = m_notificationsToPost[i].second;
         postPlatformNotification(obj, notification);
 
         if (notification == AXChildrenChanged && obj->parentObjectIfExists() && obj->lastKnownIsIgnoredValue() != obj->accessibilityIsIgnored())
             childrenChanged(obj->parentObject());
@@ skipping 218 matching lines @@
     }
 
     return result;
 }
 
 AXObject* AXObjectCacheImpl::firstAccessibleObjectFromNode(const Node* node)
 {
     if (!node)
         return 0;
 
-    AXObject* accessibleObject = getOrCreate(node->renderer());
+    AXObject* accessibleObject = getOrCreate(node->layoutObject());
     while (accessibleObject && accessibleObject->accessibilityIsIgnored()) {
         node = NodeTraversal::next(*node);
 
-        while (node && !node->renderer())
+        while (node && !node->layoutObject())
             node = NodeTraversal::nextSkippingChildren(*node);
 
         if (!node)
             return 0;
 
-        accessibleObject = getOrCreate(node->renderer());
+        accessibleObject = getOrCreate(node->layoutObject());
     }
 
     return accessibleObject;
 }
 
 bool AXObjectCacheImpl::nodeIsTextControl(const Node* node)
 {
     if (!node)
         return false;
 
@@ skipping 161 matching lines @@
 void AXObjectCacheImpl::setCanvasObjectBounds(Element* element, const LayoutRect& rect)
 {
     AXObject* obj = getOrCreate(element);
     if (!obj)
         return;
 
     obj->setElementRect(rect);
 }
 
 } // namespace blink