Change from ClientRect to DOMRect.

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 20 matching lines @@
 
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptFunction.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/V8IteratorResultValue.h"
 #include "core/HTMLNames.h"
 #include "core/SVGNames.h"
 #include "core/animation/DocumentTimeline.h"
-#include "core/dom/ClientRect.h"
 #include "core/dom/ClientRectList.h"
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/DOMNodeIds.h"
 #include "core/dom/DOMStringList.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/Iterator.h"
 #include "core/dom/NodeComputedStyle.h"
 #include "core/dom/PseudoElement.h"
@@ skipping 20 matching lines @@
 #include "core/editing/spellcheck/SpellCheckRequester.h"
 #include "core/editing/spellcheck/SpellChecker.h"
 #include "core/frame/EventHandlerRegistry.h"
 #include "core/frame/FrameConsole.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/LocalFrameView.h"
 #include "core/frame/Settings.h"
 #include "core/frame/VisualViewport.h"
 #include "core/geometry/DOMPoint.h"
+#include "core/geometry/DOMRect.h"
 #include "core/html/HTMLContentElement.h"
 #include "core/html/HTMLIFrameElement.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/HTMLMediaElement.h"
 #include "core/html/HTMLSelectElement.h"
 #include "core/html/HTMLTextAreaElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/canvas/CanvasFontCache.h"
 #include "core/html/canvas/CanvasRenderingContext.h"
@@ skipping 770 matching lines @@
         ToLocalDOMWindow(page->GetChromeClient().PagePopupWindowForTesting());
     if (popup) {
       // We need to make the popup same origin so layout tests can access it.
       popup->document()->UpdateSecurityOrigin(document_->GetSecurityOrigin());
     }
     return popup;
   }
   return nullptr;
 }
 
-ClientRect* Internals::absoluteCaretBounds(ExceptionState& exception_state) {
+DOMRect* Internals::absoluteCaretBounds(ExceptionState& exception_state) {
   if (!GetFrame()) {
     exception_state.ThrowDOMException(
         kInvalidAccessError, "The document's frame cannot be retrieved.");
-    return ClientRect::Create();
+    return DOMRect::Create();
   }
 
   document_->UpdateStyleAndLayoutIgnorePendingStylesheets();
-  return ClientRect::Create(GetFrame()->Selection().AbsoluteCaretBounds());
+  return DOMRect::Create(GetFrame()->Selection().AbsoluteCaretBounds());
 }
 
 String Internals::textAffinity() {
   if (GetFrame()
           ->GetPage()
           ->GetFocusController()
           .FocusedFrame()
           ->Selection()
           .GetSelectionInDOMTree()
           .Affinity() == TextAffinity::kUpstream) {
     return "Upstream";
   }
   return "Downstream";
 }
 
-ClientRect* Internals::boundingBox(Element* element) {
+DOMRect* Internals::boundingBox(Element* element) {
   DCHECK(element);
 
   element->GetDocument().UpdateStyleAndLayoutIgnorePendingStylesheets();
   LayoutObject* layout_object = element->GetLayoutObject();
   if (!layout_object)
-    return ClientRect::Create();
-  return ClientRect::Create(
+    return DOMRect::Create();
+  return DOMRect::Create(
       layout_object->AbsoluteBoundingBoxRectIgnoringTransforms());
 }
 
 void Internals::setMarker(Document* document,
                           const Range* range,
                           const String& marker_type,
                           ExceptionState& exception_state) {
   if (!document) {
     exception_state.ThrowDOMException(kInvalidAccessError,
                                       "No context document is available.");
@@ skipping 579 matching lines @@
           HitTestRequest::kListBased,
       LayoutSize(radius));
 
   Node* target_node = 0;
   IntPoint adjusted_point;
   event_handler.BestContextMenuNodeForHitTestResult(result, adjusted_point,
                                                     target_node);
   return target_node;
 }
 
-ClientRect* Internals::bestZoomableAreaForTouchPoint(
+DOMRect* Internals::bestZoomableAreaForTouchPoint(
     long x,
     long y,
     long width,
     long height,
     Document* document,
     ExceptionState& exception_state) {
   DCHECK(document);
   if (!document->GetFrame()) {
     exception_state.ThrowDOMException(kInvalidAccessError,
                                       "The document provided is invalid.");
     return nullptr;
   }
 
   document->UpdateStyleAndLayout();
 
   IntSize radius(width / 2, height / 2);
   IntPoint point(x + radius.Width(), y + radius.Height());
 
   Node* target_node = 0;
   IntRect zoomable_area;
   bool found_node =
       document->GetFrame()->GetEventHandler().BestZoomableAreaForTouchPoint(
           point, radius, zoomable_area, target_node);
   if (found_node)
-    return ClientRect::Create(zoomable_area);
+    return DOMRect::Create(zoomable_area);
 
   return nullptr;
 }
 
 int Internals::lastSpellCheckRequestSequence(Document* document,
                                              ExceptionState& exception_state) {
   SpellCheckRequester* requester = GetSpellCheckRequester(document);
 
   if (!requester) {
     exception_state.ThrowDOMException(
@@ skipping 303 matching lines @@
   if (!layer_rects.empty()) {
     MergeRects(layer_rects);
     String layer_type;
     IntSize layer_offset;
     PaintLayer* paint_layer = FindLayerForGraphicsLayer(
         compositor->RootLayer(), graphics_layer, &layer_offset, &layer_type);
     Node* node = paint_layer ? paint_layer->GetLayoutObject().GetNode() : 0;
     for (size_t i = 0; i < layer_rects.size(); ++i) {
       if (!layer_rects[i].IsEmpty()) {
         rects->Append(node, layer_type, layer_offset.Width(),
-                      layer_offset.Height(),
-                      ClientRect::Create(layer_rects[i]));
+                      layer_offset.Height(), DOMRect::Create(layer_rects[i]));
       }
     }
   }
 
   size_t num_children = graphics_layer->Children().size();
   for (size_t i = 0; i < num_children; ++i)
     AccumulateLayerRectList(compositor, graphics_layer->Children()[i], rects);
 }
 
 LayerRectList* Internals::touchEventTargetLayerRects(
@@ skipping 974 matching lines @@
 unsigned Internals::visibleSelectionFocusOffset() {
   if (!GetFrame())
     return 0;
   Position position = GetFrame()
                           ->Selection()
                           .ComputeVisibleSelectionInDOMTreeDeprecated()
                           .Extent();
   return position.IsNull() ? 0 : position.ComputeOffsetInContainerNode();
 }
 
-ClientRect* Internals::selectionBounds(ExceptionState& exception_state) {
+DOMRect* Internals::selectionBounds(ExceptionState& exception_state) {
   if (!GetFrame()) {
     exception_state.ThrowDOMException(
         kInvalidAccessError, "The document's frame cannot be retrieved.");
     return nullptr;
   }
 
-  return ClientRect::Create(FloatRect(GetFrame()->Selection().Bounds()));
+  return DOMRect::Create(FloatRect(GetFrame()->Selection().Bounds()));
 }
 
 String Internals::markerTextForListItem(Element* element) {
   DCHECK(element);
   return blink::MarkerTextForListItem(element);
 }
 
 String Internals::getImageSourceURL(Element* element) {
   DCHECK(element);
   return element->ImageSourceURL();
@@ skipping 509 matching lines @@
     return scrollable_area->GetScrollAnimator().RunStateAsText();
   return String();
 }
 
 String Internals::getProgrammaticScrollAnimationState(Node* node) const {
   if (ScrollableArea* scrollable_area = ScrollableAreaForNode(node))
     return scrollable_area->GetProgrammaticScrollAnimator().RunStateAsText();
   return String();
 }
 
-ClientRect* Internals::visualRect(Node* node) {
+DOMRect* Internals::visualRect(Node* node) {
   if (!node || !node->GetLayoutObject())
-    return ClientRect::Create();
+    return DOMRect::Create();
 
-  return ClientRect::Create(FloatRect(node->GetLayoutObject()->VisualRect()));
+  return DOMRect::Create(FloatRect(node->GetLayoutObject()->VisualRect()));
 }
 
 void Internals::crash() {
   CHECK(false) << "Intentional crash";
 }
 
 void Internals::setIsLowEndDevice(bool is_low_end_device) {
   MemoryCoordinator::SetIsLowEndDeviceForTesting(is_low_end_device);
 }
 
 }  // namespace blink