blink: Rename platform/ methods to prefix with get when they collide.

third_party/WebKit/Source/core/testing/Internals.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  * Copyright (C) 2013 Apple 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.
@@ skipping 186 matching lines @@
     if (node->isDocumentNode()) {
         // This can be removed after root layer scrolling is enabled.
         if (FrameView* frameView = toDocument(node)->view())
             return frameView->layoutViewportScrollableArea();
     }
 
     LayoutObject* layoutObject = node->layoutObject();
     if (!layoutObject || !layoutObject->isBox())
         return nullptr;
 
-    return toLayoutBox(layoutObject)->scrollableArea();
+    return toLayoutBox(layoutObject)->getScrollableArea();
 }
 
 const char* Internals::internalsId = "internals";
 
 Internals* Internals::create(ScriptState* scriptState)
 {
     return new Internals(scriptState);
 }
 
 Internals::~Internals()
@@ skipping 306 matching lines @@
     } else {
         exceptionState.throwDOMException(InvalidAccessError, "The element provided is not a image element.");
         return;
     }
 
     if (!resource || !resource->hasImage()) {
         exceptionState.throwDOMException(InvalidAccessError, "The image resource is not available.");
         return;
     }
 
-    Image* imageData = resource->image();
+    Image* imageData = resource->getImage();
     if (!imageData->isBitmapImage()) {
         exceptionState.throwDOMException(InvalidAccessError, "The image resource is not a BitmapImage type.");
         return;
     }
 
     imageData->advanceTime(deltaTimeInSeconds);
 }
 
 void Internals::advanceImageAnimation(Element* image, ExceptionState& exceptionState)
 {
     ASSERT(image);
 
     ImageResource* resource = nullptr;
     if (isHTMLImageElement(*image)) {
         resource = toHTMLImageElement(*image).cachedImage();
     } else if (isSVGImageElement(*image)) {
         resource = toSVGImageElement(*image).cachedImage();
     } else {
         exceptionState.throwDOMException(InvalidAccessError, "The element provided is not a image element.");
         return;
     }
 
     if (!resource || !resource->hasImage()) {
         exceptionState.throwDOMException(InvalidAccessError, "The image resource is not available.");
         return;
     }
 
-    Image* imageData = resource->image();
+    Image* imageData = resource->getImage();
     imageData->advanceAnimationForTesting();
 }
 
 bool Internals::hasShadowInsertionPoint(const Node* root, ExceptionState& exceptionState) const
 {
     ASSERT(root);
     if (!root->isShadowRoot()) {
         exceptionState.throwDOMException(InvalidAccessError, "The node argument is not a shadow root.");
         return false;
     }
@@ skipping 728 matching lines @@
         }
 
         LayoutRect rect;
         PaintLayer::mapRectToPaintBackingCoordinates(searchRoot->layoutObject(), rect);
         *layerOffset = IntSize(rect.x(), rect.y());
         return searchRoot;
     }
 
     // If the |graphicsLayer| is a scroller's scrollingContent layer,
     // consider this is a scrolling layer.
-    GraphicsLayer* layerForScrolling = searchRoot->scrollableArea() ? searchRoot->scrollableArea()->layerForScrolling() : 0;
+    GraphicsLayer* layerForScrolling = searchRoot->getScrollableArea() ? searchRoot->getScrollableArea()->layerForScrolling() : 0;
     if (graphicsLayer == layerForScrolling) {
         *layerType = "scrolling";
         return searchRoot;
     }
 
     if (searchRoot->compositingState() == PaintsIntoGroupedBacking) {
         GraphicsLayer* squashingLayer = searchRoot->groupedMapping()->squashingLayer();
         if (graphicsLayer == squashingLayer) {
             *layerType ="squashing";
             LayoutRect rect;
             PaintLayer::mapRectToPaintBackingCoordinates(searchRoot->layoutObject(), rect);
             *layerOffset = IntSize(rect.x(), rect.y());
             return searchRoot;
         }
     }
 
-    GraphicsLayer* layerForHorizontalScrollbar = searchRoot->scrollableArea() ? searchRoot->scrollableArea()->layerForHorizontalScrollbar() : 0;
+    GraphicsLayer* layerForHorizontalScrollbar = searchRoot->getScrollableArea() ? searchRoot->getScrollableArea()->layerForHorizontalScrollbar() : 0;
     if (graphicsLayer == layerForHorizontalScrollbar) {
         *layerType = "horizontalScrollbar";
         return searchRoot;
     }
 
-    GraphicsLayer* layerForVerticalScrollbar = searchRoot->scrollableArea() ? searchRoot->scrollableArea()->layerForVerticalScrollbar() : 0;
+    GraphicsLayer* layerForVerticalScrollbar = searchRoot->getScrollableArea() ? searchRoot->getScrollableArea()->layerForVerticalScrollbar() : 0;
     if (graphicsLayer == layerForVerticalScrollbar) {
         *layerType = "verticalScrollbar";
         return searchRoot;
     }
 
-    GraphicsLayer* layerForScrollCorner = searchRoot->scrollableArea() ? searchRoot->scrollableArea()->layerForScrollCorner() : 0;
+    GraphicsLayer* layerForScrollCorner = searchRoot->getScrollableArea() ? searchRoot->getScrollableArea()->layerForScrollCorner() : 0;
     if (graphicsLayer == layerForScrollCorner) {
         *layerType = "scrollCorner";
         return searchRoot;
     }
 
     // Search right to left to increase the chances that we'll choose the top-most layers in a
     // grouped mapping for squashing.
     for (PaintLayer* child = searchRoot->lastChild(); child; child = child->previousSibling()) {
         PaintLayer* foundLayer = findLayerForGraphicsLayer(child, graphicsLayer, layerOffset, layerType);
         if (foundLayer)
@@ skipping 637 matching lines @@
 
     if (LayoutView *layoutView = document->layoutView())
         layoutView->invalidatePaintForViewAndCompositedLayers();
 }
 
 void Internals::startTrackingPaintInvalidationObjects()
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
     GraphicsLayer* graphicsLayer = toLocalFrame(frame()->page()->mainFrame())->view()->layoutView()->layer()->graphicsLayerBacking();
     if (graphicsLayer->drawsContent())
-        graphicsLayer->paintController().startTrackingPaintInvalidationObjects();
+        graphicsLayer->getPaintController().startTrackingPaintInvalidationObjects();
 }
 
 void Internals::stopTrackingPaintInvalidationObjects()
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
     GraphicsLayer* graphicsLayer = toLocalFrame(frame()->page()->mainFrame())->view()->layoutView()->layer()->graphicsLayerBacking();
     if (graphicsLayer->drawsContent())
-        graphicsLayer->paintController().stopTrackingPaintInvalidationObjects();
+        graphicsLayer->getPaintController().stopTrackingPaintInvalidationObjects();
 }
 
 Vector<String> Internals::trackedPaintInvalidationObjects()
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
     GraphicsLayer* graphicsLayer = toLocalFrame(frame()->page()->mainFrame())->view()->layoutView()->layer()->graphicsLayerBacking();
     if (!graphicsLayer->drawsContent())
         return Vector<String>();
-    return graphicsLayer->paintController().trackedPaintInvalidationObjects();
+    return graphicsLayer->getPaintController().trackedPaintInvalidationObjects();
 }
 
 ClientRectList* Internals::draggableRegions(Document* document, ExceptionState& exceptionState)
 {
     return annotatedRegions(document, true, exceptionState);
 }
 
 ClientRectList* Internals::nonDraggableRegions(Document* document, ExceptionState& exceptionState)
 {
     return annotatedRegions(document, false, exceptionState);
@@ skipping 76 matching lines @@
 {
     Cursor cursor = frame()->page()->chromeClient().lastSetCursorForTesting();
 
     StringBuilder result;
     result.appendLiteral("type=");
     result.append(cursorTypeToString(cursor.getType()));
     result.appendLiteral(" hotSpot=");
     result.appendNumber(cursor.hotSpot().x());
     result.append(',');
     result.appendNumber(cursor.hotSpot().y());
-    if (cursor.image()) {
-        IntSize size = cursor.image()->size();
+    if (cursor.getImage()) {
+        IntSize size = cursor.getImage()->size();
         result.appendLiteral(" image=");
         result.appendNumber(size.width());
         result.append('x');
         result.appendNumber(size.height());
     }
     if (cursor.imageScaleFactor() != 1) {
         result.appendLiteral(" scale=");
         NumberToStringBuffer buffer;
         result.append(numberToFixedPrecisionString(cursor.imageScaleFactor(), 8, buffer, true));
     }
@@ skipping 81 matching lines @@
 
 int Internals::selectPopupItemStyleFontHeight(Node* node, int itemIndex)
 {
     if (!node || !isHTMLSelectElement(*node))
         return false;
 
     HTMLSelectElement& select = toHTMLSelectElement(*node);
     if (itemIndex < 0 || static_cast<size_t>(itemIndex) >= select.listItems().size())
         return false;
     const ComputedStyle* itemStyle = select.itemComputedStyle(*select.listItems()[itemIndex]);
-    return itemStyle ? itemStyle->font().fontMetrics().height() : 0;
+    return itemStyle ? itemStyle->font().getFontMetrics().height() : 0;
 }
 
 void Internals::resetTypeAheadSession(HTMLSelectElement* select)
 {
     ASSERT(select);
     select->resetTypeAheadSessionForTesting();
 }
 
 bool Internals::loseSharedGraphicsContext3D()
 {
@@ skipping 238 matching lines @@
     return expandedIntSize(frame()->host()->visualViewport().visibleRect().size()).height();
 }
 
 int Internals::visualViewportWidth()
 {
     return expandedIntSize(frame()->host()->visualViewport().visibleRect().size()).width();
 }
 
 double Internals::visualViewportScrollX()
 {
-    return frame()->view()->scrollableArea()->scrollPositionDouble().x();
+    return frame()->view()->getScrollableArea()->scrollPositionDouble().x();
 }
 
 double Internals::visualViewportScrollY()
 {
-    return frame()->view()->scrollableArea()->scrollPositionDouble().y();
+    return frame()->view()->getScrollableArea()->scrollPositionDouble().y();
 }
 
 ValueIterable<int>::IterationSource* Internals::startIteration(ScriptState*, ExceptionState&)
 {
     return new InternalsIterationSource();
 }
 
 bool Internals::isUseCounted(Document* document, int useCounterId)
 {
     if (useCounterId < 0 || useCounterId >= UseCounter::NumberOfFeatures)
@@ skipping 76 matching lines @@
 }
 
 int Internals::getScrollAnimationState(Node* node) const
 {
     if (ScrollableArea* scrollableArea = scrollableAreaForNode(node))
         return static_cast<int>(scrollableArea->scrollAnimator().m_runState);
     return -1;
 }
 
 } // namespace blink