Rename PaintLayer::enclosingElement -> PaintLayer::enclosingNode

third_party/WebKit/Source/core/paint/PaintLayer.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 1528 matching lines @@
     // Now determine if the result is inside an anchor - if the urlElement isn't already set.
     Node* node = result.innerNode();
     if (node && !result.URLElement())
         result.setURLElement(node->enclosingLinkEventParentOrSelf());
 
     // Now return whether we were inside this layer (this will always be true for the root
     // layer).
     return insideLayer;
 }
 
-Node* PaintLayer::enclosingElement() const
+Node* PaintLayer::enclosingNode() const
 {
     for (LayoutObject* r = layoutObject(); r; r = r->parent()) {
         if (Node* e = r->node())
             return e;
     }
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 bool PaintLayer::isInTopLayer() const
@@ skipping 345 matching lines @@
         // We hit something anonymous, and we didn't find a DOM node ancestor in this layer.
 
         if (layoutObject()->isLayoutFlowThread()) {
             // For a flow thread it's safe to just say that we didn't hit anything. That means that
             // we'll continue as normally, and eventually hit a column set sibling instead. Column
             // sets are also anonymous, but, unlike flow threads, they don't establish layers, so
             // we'll fall back and hit the multicol container parent (which should have a DOM node).
             return false;
         }
 
-        Node* e = enclosingElement();
+        Node* e = enclosingNode();
         // FIXME: should be a call to result.setNodeAndPosition. What we would really want to do here is to
         // return and look for the nearest non-anonymous ancestor, and ignore aunts and uncles on
         // our way. It's bad to look for it manually like we do here, and give up on setting a local
         // point in the result, because that has bad implications for text selection and
         // caretRangeFromPoint(). See crbug.com/461791
         if (!result.innerNode())
             result.setInnerNode(e);
 
     }
     return true;
@@ skipping 622 matching lines @@
 bool PaintLayer::scrollsOverflow() const
 {
     if (PaintLayerScrollableArea* scrollableArea = this->scrollableArea())
         return scrollableArea->scrollsOverflow();
 
     return false;
 }
 
 namespace {
 
-FilterOperations computeFilterOperationsHandleReferenceFilters(const FilterOperations& filters, float effectiveZoom, Node* enclosingElement)
+FilterOperations computeFilterOperationsHandleReferenceFilters(const FilterOperations& filters, float effectiveZoom, Node* enclosingNode)
 {
     if (filters.hasReferenceFilter()) {
         for (size_t i = 0; i < filters.size(); ++i) {
             FilterOperation* filterOperation = filters.operations().at(i).get();
             if (filterOperation->type() != FilterOperation::REFERENCE)
                 continue;
             ReferenceFilterOperation& referenceOperation = toReferenceFilterOperation(*filterOperation);
             // FIXME: Cache the Filter if it didn't change.
-            RefPtrWillBeRawPtr<Filter> referenceFilter = ReferenceFilterBuilder::build(effectiveZoom, toElement(enclosingElement), nullptr, referenceOperation);
+            RefPtrWillBeRawPtr<Filter> referenceFilter = ReferenceFilterBuilder::build(effectiveZoom, toElement(enclosingNode), nullptr, referenceOperation);
             referenceOperation.setFilter(referenceFilter.release());
         }
     }
 
     return filters;
 }
 
 } // unnamed namespace
 
 FilterOperations PaintLayer::computeFilterOperations(const ComputedStyle& style) const
 {
-    return computeFilterOperationsHandleReferenceFilters(style.filter(), style.effectiveZoom(), enclosingElement());
+    return computeFilterOperationsHandleReferenceFilters(style.filter(), style.effectiveZoom(), enclosingNode());
 }
 
 FilterOperations PaintLayer::computeBackdropFilterOperations(const ComputedStyle& style) const
 {
-    return computeFilterOperationsHandleReferenceFilters(style.backdropFilter(), style.effectiveZoom(), enclosingElement());
+    return computeFilterOperationsHandleReferenceFilters(style.backdropFilter(), style.effectiveZoom(), enclosingNode());
 }
 
 void PaintLayer::updateOrRemoveFilterClients()
 {
     if (!hasFilter()) {
         removeFilterInfoIfNeeded();
         return;
     }
 
     if (layoutObject()->style()->filter().hasReferenceFilter())
@@ skipping 13 matching lines @@
 
     // Should have been added by updateOrRemoveFilterEffectBuilder().
     ASSERT(filterInfo);
 
     if (filterInfo->builder())
         return filterInfo->builder();
 
     filterInfo->setBuilder(FilterEffectBuilder::create());
 
     float zoom = layoutObject()->style() ? layoutObject()->style()->effectiveZoom() : 1.0f;
-    if (!filterInfo->builder()->build(toElement(enclosingElement()), computeFilterOperations(layoutObject()->styleRef()), zoom))
+    if (!filterInfo->builder()->build(toElement(enclosingNode()), computeFilterOperations(layoutObject()->styleRef()), zoom))
         filterInfo->setBuilder(nullptr);
 
     return filterInfo->builder();
 }
 
 FilterEffect* PaintLayer::lastFilterEffect() const
 {
     FilterEffectBuilder* builder = updateFilterEffectBuilder();
     if (!builder)
         return nullptr;
@@ skipping 151 matching lines @@
 
 void showLayerTree(const blink::LayoutObject* layoutObject)
 {
     if (!layoutObject) {
         fprintf(stderr, "Cannot showLayerTree. Root is (nil)\n");
         return;
     }
     showLayerTree(layoutObject->enclosingLayer());
 }
 #endif