Rename (updateLayout/updateStyle).*.() to updateStyleAndLayout.*.()

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 284 matching lines @@
     v8::Local<v8::Value> observedValue = scriptValue.v8Value();
     ASSERT(!observedValue.IsEmpty());
     if (observedValue->IsNull() || observedValue->IsUndefined()) {
         V8ThrowException::throwTypeError(v8::Isolate::GetCurrent(), "value to observe is null or undefined");
         return nullptr;
     }
 
     return GCObservation::create(observedValue);
 }
 
-unsigned Internals::updateStyleAndReturnAffectedElementCount(ExceptionState& exceptionState) const
+unsigned Internals::updateStyleAndLayoutAndReturnAffectedElementCount(ExceptionState& exceptionState) const
 {
     Document* document = contextDocument();
     if (!document) {
         exceptionState.throwDOMException(InvalidAccessError, "No context document is available.");
         return 0;
     }
 
     unsigned beforeCount = document->styleEngine().styleForElementCount();
-    document->updateLayoutTree();
+    document->updateStyleAndLayoutTree();
     return document->styleEngine().styleForElementCount() - beforeCount;
 }
 
 unsigned Internals::needsLayoutCount(ExceptionState& exceptionState) const
 {
     LocalFrame* contextFrame = frame();
     if (!contextFrame) {
         exceptionState.throwDOMException(InvalidAccessError, "No context frame is available.");
         return 0;
     }
@@ skipping 489 matching lines @@
         return ClientRect::create();
     }
 
     return ClientRect::create(document->frame()->selection().absoluteCaretBounds());
 }
 
 ClientRect* Internals::boundingBox(Element* element)
 {
     ASSERT(element);
 
-    element->document().updateLayoutIgnorePendingStylesheets();
+    element->document().updateStyleAndLayoutIgnorePendingStylesheets();
     LayoutObject* layoutObject = element->layoutObject();
     if (!layoutObject)
         return ClientRect::create();
     return ClientRect::create(layoutObject->absoluteBoundingBoxRectIgnoringTransforms());
 }
 
 unsigned Internals::markerCountForNode(Node* node, const String& markerType, ExceptionState& exceptionState)
 {
     ASSERT(node);
     DocumentMarker::MarkerTypes markerTypes = 0;
@@ skipping 50 matching lines @@
 {
     DocumentMarker* marker = markerAt(node, markerType, index, exceptionState);
     if (!marker)
         return String();
     return marker->description();
 }
 
 void Internals::addTextMatchMarker(const Range* range, bool isActive)
 {
     ASSERT(range);
-    range->ownerDocument().updateLayoutIgnorePendingStylesheets();
+    range->ownerDocument().updateStyleAndLayoutIgnorePendingStylesheets();
     range->ownerDocument().markers().addTextMatchMarker(range, isActive);
 }
 
 void Internals::setMarkersActive(Node* node, unsigned startOffset, unsigned endOffset, bool active)
 {
     ASSERT(node);
     node->document().markers().setMarkersActive(node, startOffset, endOffset, active);
 }
 
 void Internals::setMarkedTextMatchesAreHighlighted(Document* document, bool highlight)
@@ skipping 21 matching lines @@
 }
 
 String Internals::viewportAsText(Document* document, float, int availableWidth, int availableHeight, ExceptionState& exceptionState)
 {
     ASSERT(document);
     if (!document->page()) {
         exceptionState.throwDOMException(InvalidAccessError, "The document provided is invalid.");
         return String();
     }
 
-    document->updateLayoutIgnorePendingStylesheets();
+    document->updateStyleAndLayoutIgnorePendingStylesheets();
 
     Page* page = document->page();
 
     // Update initial viewport size.
     IntSize initialViewportSize(availableWidth, availableHeight);
     document->page()->deprecatedLocalMainFrame()->view()->setFrameRect(IntRect(IntPoint::zero(), initialViewportSize));
 
     ViewportDescription description = page->viewportDescription();
     PageScaleConstraints constraints = description.resolve(FloatSize(initialViewportSize), Length());
 
@@ skipping 88 matching lines @@
         return;
     }
     toHTMLFormControlElement(element)->setAutofilled(enabled);
 }
 
 Range* Internals::rangeFromLocationAndLength(Element* scope, int rangeLocation, int rangeLength)
 {
     ASSERT(scope);
 
     // TextIterator depends on Layout information, make sure layout it up to date.
-    scope->document().updateLayoutIgnorePendingStylesheets();
+    scope->document().updateStyleAndLayoutIgnorePendingStylesheets();
 
     return createRange(PlainTextRange(rangeLocation, rangeLocation + rangeLength).createRange(*scope));
 }
 
 unsigned Internals::locationFromRange(Element* scope, const Range* range)
 {
     ASSERT(scope && range);
     // PlainTextRange depends on Layout information, make sure layout it up to date.
-    scope->document().updateLayoutIgnorePendingStylesheets();
+    scope->document().updateStyleAndLayoutIgnorePendingStylesheets();
 
     return PlainTextRange::create(*scope, *range).start();
 }
 
 unsigned Internals::lengthFromRange(Element* scope, const Range* range)
 {
     ASSERT(scope && range);
     // PlainTextRange depends on Layout information, make sure layout it up to date.
-    scope->document().updateLayoutIgnorePendingStylesheets();
+    scope->document().updateStyleAndLayoutIgnorePendingStylesheets();
 
     return PlainTextRange::create(*scope, *range).length();
 }
 
 String Internals::rangeAsText(const Range* range)
 {
     ASSERT(range);
     return range->text();
 }
 
 // FIXME: The next four functions are very similar - combine them once
 // bestClickableNode/bestContextMenuNode have been combined..
 
 DOMPoint* Internals::touchPositionAdjustedToBestClickableNode(long x, long y, long width, long height, Document* document, ExceptionState& exceptionState)
 {
     ASSERT(document);
     if (!document->frame()) {
         exceptionState.throwDOMException(InvalidAccessError, "The document provided is invalid.");
         return 0;
     }
 
-    document->updateLayout();
+    document->updateStyleAndLayout();
 
     IntSize radius(width / 2, height / 2);
     IntPoint point(x + radius.width(), y + radius.height());
 
     EventHandler& eventHandler = document->frame()->eventHandler();
     IntPoint hitTestPoint = document->frame()->view()->rootFrameToContents(point);
     HitTestResult result = eventHandler.hitTestResultAtPoint(hitTestPoint, HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::ListBased, LayoutSize(radius));
 
     Node* targetNode = 0;
     IntPoint adjustedPoint;
 
     bool foundNode = eventHandler.bestClickableNodeForHitTestResult(result, adjustedPoint, targetNode);
     if (foundNode)
         return DOMPoint::create(adjustedPoint.x(), adjustedPoint.y());
 
     return 0;
 }
 
 Node* Internals::touchNodeAdjustedToBestClickableNode(long x, long y, long width, long height, Document* document, ExceptionState& exceptionState)
 {
     ASSERT(document);
     if (!document->frame()) {
         exceptionState.throwDOMException(InvalidAccessError, "The document provided is invalid.");
         return 0;
     }
 
-    document->updateLayout();
+    document->updateStyleAndLayout();
 
     IntSize radius(width / 2, height / 2);
     IntPoint point(x + radius.width(), y + radius.height());
 
     EventHandler& eventHandler = document->frame()->eventHandler();
     IntPoint hitTestPoint = document->frame()->view()->rootFrameToContents(point);
     HitTestResult result = eventHandler.hitTestResultAtPoint(hitTestPoint, HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::ListBased, LayoutSize(radius));
 
     Node* targetNode = 0;
     IntPoint adjustedPoint;
     document->frame()->eventHandler().bestClickableNodeForHitTestResult(result, adjustedPoint, targetNode);
     return targetNode;
 }
 
 DOMPoint* Internals::touchPositionAdjustedToBestContextMenuNode(long x, long y, long width, long height, Document* document, ExceptionState& exceptionState)
 {
     ASSERT(document);
     if (!document->frame()) {
         exceptionState.throwDOMException(InvalidAccessError, "The document provided is invalid.");
         return 0;
     }
 
-    document->updateLayout();
+    document->updateStyleAndLayout();
 
     IntSize radius(width / 2, height / 2);
     IntPoint point(x + radius.width(), y + radius.height());
 
     EventHandler& eventHandler = document->frame()->eventHandler();
     IntPoint hitTestPoint = document->frame()->view()->rootFrameToContents(point);
     HitTestResult result = eventHandler.hitTestResultAtPoint(hitTestPoint, HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::ListBased, LayoutSize(radius));
 
     Node* targetNode = 0;
     IntPoint adjustedPoint;
 
     bool foundNode = eventHandler.bestContextMenuNodeForHitTestResult(result, adjustedPoint, targetNode);
     if (foundNode)
         return DOMPoint::create(adjustedPoint.x(), adjustedPoint.y());
 
     return DOMPoint::create(x, y);
 }
 
 Node* Internals::touchNodeAdjustedToBestContextMenuNode(long x, long y, long width, long height, Document* document, ExceptionState& exceptionState)
 {
     ASSERT(document);
     if (!document->frame()) {
         exceptionState.throwDOMException(InvalidAccessError, "The document provided is invalid.");
         return 0;
     }
 
-    document->updateLayout();
+    document->updateStyleAndLayout();
 
     IntSize radius(width / 2, height / 2);
     IntPoint point(x + radius.width(), y + radius.height());
 
     EventHandler& eventHandler = document->frame()->eventHandler();
     IntPoint hitTestPoint = document->frame()->view()->rootFrameToContents(point);
     HitTestResult result = eventHandler.hitTestResultAtPoint(hitTestPoint, HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::ListBased, LayoutSize(radius));
 
     Node* targetNode = 0;
     IntPoint adjustedPoint;
     eventHandler.bestContextMenuNodeForHitTestResult(result, adjustedPoint, targetNode);
     return targetNode;
 }
 
 ClientRect* Internals::bestZoomableAreaForTouchPoint(long x, long y, long width, long height, Document* document, ExceptionState& exceptionState)
 {
     ASSERT(document);
     if (!document->frame()) {
         exceptionState.throwDOMException(InvalidAccessError, "The document provided is invalid.");
         return nullptr;
     }
 
-    document->updateLayout();
+    document->updateStyleAndLayout();
 
     IntSize radius(width / 2, height / 2);
     IntPoint point(x + radius.width(), y + radius.height());
 
     Node* targetNode = 0;
     IntRect zoomableArea;
     bool foundNode = document->frame()->eventHandler().bestZoomableAreaForTouchPoint(point, radius, zoomableArea, targetNode);
     if (foundNode)
         return ClientRect::create(zoomableArea);
 
@@ skipping 490 matching lines @@
     }
 
     document->view()->updateAllLifecyclePhases();
 
     return document->frame()->layerTreeAsText(flags);
 }
 
 String Internals::elementLayerTreeAsText(Element* element, unsigned flags, ExceptionState& exceptionState) const
 {
     ASSERT(element);
-    element->document().updateLayout();
+    element->document().updateStyleAndLayout();
 
     LayoutObject* layoutObject = element->layoutObject();
     if (!layoutObject || !layoutObject->isBox()) {
         exceptionState.throwDOMException(InvalidAccessError, layoutObject ? "The provided element's layoutObject is not a box." : "The provided element has no layoutObject.");
         return String();
     }
 
     PaintLayer* layer = toLayoutBox(layoutObject)->layer();
     if (!layer
         || !layer->hasCompositedLayerMapping()
@@ skipping 260 matching lines @@
     if (!document->view()) {
         exceptionState.throwDOMException(InvalidAccessError, "The document provided is invalid.");
         return;
     }
 
     FrameView* frameView = document->view();
     frameView->updateAllLifecyclePhases();
     frameView->setTracksPaintInvalidations(false);
 }
 
-void Internals::updateLayoutIgnorePendingStylesheetsAndRunPostLayoutTasks(Node* node, ExceptionState& exceptionState)
+void Internals::updateStyleAndLayoutIgnorePendingStylesheetsAndRunPostLayoutTasks(Node* node, ExceptionState& exceptionState)
 {
     Document* document;
     if (!node) {
         document = contextDocument();
     } else if (node->isDocumentNode()) {
         document = toDocument(node);
     } else if (isHTMLIFrameElement(*node)) {
         document = toHTMLIFrameElement(*node).contentDocument();
     } else {
         exceptionState.throwTypeError("The node provided is neither a document nor an IFrame.");
         return;
     }
-    document->updateLayoutIgnorePendingStylesheets(Document::RunPostLayoutTasksSynchronously);
+    document->updateStyleAndLayoutIgnorePendingStylesheets(Document::RunPostLayoutTasksSynchronously);
 }
 
 void Internals::forceFullRepaint(Document* document, ExceptionState& exceptionState)
 {
     ASSERT(document);
     if (!document->view()) {
         exceptionState.throwDOMException(InvalidAccessError, "The document provided is invalid.");
         return;
     }
 
@@ skipping 38 matching lines @@
 }
 
 ClientRectList* Internals::annotatedRegions(Document* document, bool draggable, ExceptionState& exceptionState)
 {
     ASSERT(document);
     if (!document->view()) {
         exceptionState.throwDOMException(InvalidAccessError, "The document provided is invalid.");
         return ClientRectList::create();
     }
 
-    document->updateLayout();
+    document->updateStyleAndLayout();
     document->view()->updateDocumentAnnotatedRegions();
     Vector<AnnotatedRegionValue> regions = document->annotatedRegions();
 
     Vector<FloatQuad> quads;
     for (size_t i = 0; i < regions.size(); ++i) {
         if (regions[i].draggable == draggable)
             quads.append(FloatQuad(FloatRect(regions[i].bounds)));
     }
     return ClientRectList::create(quads);
 }
@@ skipping 521 matching lines @@
 }
 
 String Internals::getProgrammaticScrollAnimationState(Node* node) const
 {
     if (ScrollableArea* scrollableArea = scrollableAreaForNode(node))
         return scrollableArea->programmaticScrollAnimator().runStateAsText();
     return String();
 }
 
 } // namespace blink