Add interface to get relative bounding box rect of AX objects.

components/test_runner/web_ax_object_proxy.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/test_runner/web_ax_object_proxy.h"
 
 #include <stddef.h>
 
 #include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "gin/handle.h"
+#include "third_party/WebKit/public/platform/WebFloatRect.h"
 #include "third_party/WebKit/public/platform/WebPoint.h"
 #include "third_party/WebKit/public/platform/WebRect.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebKit.h"
+#include "third_party/skia/include/core/SkMatrix44.h"
+#include "ui/gfx/geometry/rect_f.h"
+#include "ui/gfx/transform.h"
 
 namespace test_runner {
 
 namespace {
 
 // Map role value to string, matching Safari/Mac platform implementation to
 // avoid rebaselining layout tests.
 std::string RoleToString(blink::WebAXRole role)
 {
   std::string result = "AXRole: AX";
@@ skipping 276 matching lines @@
   return language.insert(0, "AXLanguage: ");
 }
 
 std::string GetAttributes(const blink::WebAXObject& object) {
   std::string attributes(object.name().utf8());
   attributes.append("\n");
   attributes.append(GetRole(object));
   return attributes;
 }
 
+// New bounds calculation algorithm.  Retrieves the frame-relative bounds
+// of an object by calling getRelativeBounds and then applying the offsets
+// and transforms recursively on each container of this object.
+blink::WebRect BoundsForObject(const blink::WebAXObject& object) {
+  blink::WebAXObject container;
+  blink::WebFloatRect bounds;
+  SkMatrix44 matrix;
+  object.getRelativeBounds(container, bounds, matrix);
+  gfx::RectF boundsf(0, 0, bounds.width, bounds.height);

[aboxhall, 2016/06/09 23:05:30]

What does the 'f' in 'boundsf' connote? Just that it's a RectF?

[dmazzoni, 2016/06/10 16:55:39]

Yeah, that could be more clear. Changed to computedBounds to contrast it with
the bounds from just one object.

+  while (!container.isDetached()) {
+    boundsf.Offset(bounds.x, bounds.y);
+    boundsf.Offset(-container.scrollOffset().x, -container.scrollOffset().y);
+    if (!matrix.isIdentity()) {
+      gfx::Transform transform(matrix);
+      transform.TransformRect(&boundsf);
+    }
+    container.getRelativeBounds(container, bounds, matrix);
+  }
+  return blink::WebRect(boundsf.x(),
+                        boundsf.y(),
+                        boundsf.width(),
+                        boundsf.height());
+}
+
 blink::WebRect BoundsForCharacter(const blink::WebAXObject& object,
                                   int characterIndex) {
   DCHECK_EQ(object.role(), blink::WebAXRoleStaticText);
   int end = 0;
   for (unsigned i = 0; i < object.childCount(); i++) {
     blink::WebAXObject inline_text_box = object.childAt(i);
     DCHECK_EQ(inline_text_box.role(), blink::WebAXRoleInlineTextBox);
     int start = end;
     blink::WebString name = inline_text_box.name();
     end += name.length();
@@ skipping 221 matching lines @@
       .SetProperty("posInSet", &WebAXObjectProxy::PosInSet)
       .SetProperty("setSize", &WebAXObjectProxy::SetSize)
       .SetProperty("clickPointX", &WebAXObjectProxy::ClickPointX)
       .SetProperty("clickPointY", &WebAXObjectProxy::ClickPointY)
       .SetProperty("rowCount", &WebAXObjectProxy::RowCount)
       .SetProperty("rowHeadersCount", &WebAXObjectProxy::RowHeadersCount)
       .SetProperty("columnCount", &WebAXObjectProxy::ColumnCount)
       .SetProperty("columnHeadersCount", &WebAXObjectProxy::ColumnHeadersCount)
       .SetProperty("isClickable", &WebAXObjectProxy::IsClickable)
       .SetProperty("isButtonStateMixed", &WebAXObjectProxy::IsButtonStateMixed)
+      //
+      // NEW bounding rect calculation - high-level interface
+      //
+      .SetProperty("boundsX", &WebAXObjectProxy::BoundsX)
+      .SetProperty("boundsY", &WebAXObjectProxy::BoundsY)
+      .SetProperty("boundsWidth", &WebAXObjectProxy::BoundsWidth)
+      .SetProperty("boundsHeight", &WebAXObjectProxy::BoundsHeight)
       .SetMethod("allAttributes", &WebAXObjectProxy::AllAttributes)
       .SetMethod("attributesOfChildren",
                  &WebAXObjectProxy::AttributesOfChildren)
       .SetMethod("ariaControlsElementAtIndex",
                  &WebAXObjectProxy::AriaControlsElementAtIndex)
       .SetMethod("ariaFlowToElementAtIndex",
                  &WebAXObjectProxy::AriaFlowToElementAtIndex)
       .SetMethod("ariaOwnsElementAtIndex",
                  &WebAXObjectProxy::AriaOwnsElementAtIndex)
       .SetMethod("lineForIndex", &WebAXObjectProxy::LineForIndex)
@@ skipping 25 matching lines @@
       .SetMethod("isEqual", &WebAXObjectProxy::IsEqual)
       .SetMethod("setNotificationListener",
                  &WebAXObjectProxy::SetNotificationListener)
       .SetMethod("unsetNotificationListener",
                  &WebAXObjectProxy::UnsetNotificationListener)
       .SetMethod("takeFocus", &WebAXObjectProxy::TakeFocus)
       .SetMethod("scrollToMakeVisible", &WebAXObjectProxy::ScrollToMakeVisible)
       .SetMethod("scrollToMakeVisibleWithSubFocus",
                  &WebAXObjectProxy::ScrollToMakeVisibleWithSubFocus)
       .SetMethod("scrollToGlobalPoint", &WebAXObjectProxy::ScrollToGlobalPoint)
+      .SetMethod("scrollX", &WebAXObjectProxy::ScrollX)
+      .SetMethod("scrollY", &WebAXObjectProxy::ScrollY)
       .SetMethod("wordStart", &WebAXObjectProxy::WordStart)
       .SetMethod("wordEnd", &WebAXObjectProxy::WordEnd)
       .SetMethod("nextOnLine", &WebAXObjectProxy::NextOnLine)
       .SetMethod("previousOnLine", &WebAXObjectProxy::PreviousOnLine)
       .SetMethod("misspellingAtIndex", &WebAXObjectProxy::MisspellingAtIndex)
       // TODO(hajimehoshi): This is for backward compatibility. Remove them.
       .SetMethod("addNotificationListener",
                  &WebAXObjectProxy::SetNotificationListener)
       .SetMethod("removeNotificationListener",
                  &WebAXObjectProxy::UnsetNotificationListener)
       //
       // NEW accessible name and description accessors
       //
       .SetProperty("name", &WebAXObjectProxy::Name)
       .SetProperty("nameFrom", &WebAXObjectProxy::NameFrom)
       .SetMethod("nameElementCount", &WebAXObjectProxy::NameElementCount)
       .SetMethod("nameElementAtIndex", &WebAXObjectProxy::NameElementAtIndex)
       .SetProperty("description", &WebAXObjectProxy::Description)
       .SetProperty("descriptionFrom", &WebAXObjectProxy::DescriptionFrom)
       .SetProperty("misspellingsCount", &WebAXObjectProxy::MisspellingsCount)
       .SetMethod("descriptionElementCount",
                  &WebAXObjectProxy::DescriptionElementCount)
       .SetMethod("descriptionElementAtIndex",
-                 &WebAXObjectProxy::DescriptionElementAtIndex);
+                 &WebAXObjectProxy::DescriptionElementAtIndex)
+      //
+      // NEW bounding rect calculation - low-level interface
+      //
+      .SetMethod("offsetContainer",
+                 &WebAXObjectProxy::OffsetContainer)
+      .SetMethod("boundsInContainerX",
+                 &WebAXObjectProxy::BoundsInContainerX)
+      .SetMethod("boundsInContainerY",
+                 &WebAXObjectProxy::BoundsInContainerY)
+      .SetMethod("boundsInContainerWidth",
+                 &WebAXObjectProxy::BoundsInContainerWidth)
+      .SetMethod("boundsInContainerHeight",
+                 &WebAXObjectProxy::BoundsInContainerHeight)
+      .SetMethod("hasNonIdentityTransform",
+                 &WebAXObjectProxy::HasNonIdentityTransform);
 }
 
 v8::Local<v8::Object> WebAXObjectProxy::GetChildAtIndex(unsigned index) {
   return factory_->GetOrCreate(accessibility_object_.childAt(index));
 }
 
 bool WebAXObjectProxy::IsRoot() const {
   return false;
 }
 
@@ skipping 650 matching lines @@
   accessibility_object_.updateLayoutAndCheckValidity();
   accessibility_object_.scrollToMakeVisibleWithSubFocus(
       blink::WebRect(x, y, width, height));
 }
 
 void WebAXObjectProxy::ScrollToGlobalPoint(int x, int y) {
   accessibility_object_.updateLayoutAndCheckValidity();
   accessibility_object_.scrollToGlobalPoint(blink::WebPoint(x, y));
 }
 
+int WebAXObjectProxy::ScrollX() {
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return accessibility_object_.scrollOffset().x;
+}
+
+int WebAXObjectProxy::ScrollY() {
+  accessibility_object_.updateLayoutAndCheckValidity();
+  return accessibility_object_.scrollOffset().y;
+}
+
+int WebAXObjectProxy::BoundsX() {
+  return BoundsForObject(accessibility_object_).x;
+}
+
+int WebAXObjectProxy::BoundsY() {
+  return BoundsForObject(accessibility_object_).y;
+}
+
+int WebAXObjectProxy::BoundsWidth() {
+  return BoundsForObject(accessibility_object_).width;
+}
+
+int WebAXObjectProxy::BoundsHeight() {
+  return BoundsForObject(accessibility_object_).height;
+}
+
 int WebAXObjectProxy::WordStart(int character_index) {
   accessibility_object_.updateLayoutAndCheckValidity();
   if (accessibility_object_.role() != blink::WebAXRoleStaticText)
     return -1;
 
   int word_start = 0, word_end = 0;
   GetBoundariesForOneWord(accessibility_object_, character_index,
                           word_start, word_end);
   return word_start;
 }
@@ skipping 148 matching lines @@
   accessibility_object_.name(nameFrom, nameObjects);
   blink::WebAXDescriptionFrom descriptionFrom;
   blink::WebVector<blink::WebAXObject> descriptionObjects;
   accessibility_object_.description(
       nameFrom, descriptionFrom, descriptionObjects);
   if (index >= descriptionObjects.size())
     return v8::Local<v8::Object>();
   return factory_->GetOrCreate(descriptionObjects[index]);
 }
 
+v8::Local<v8::Object> WebAXObjectProxy::OffsetContainer() {
+  accessibility_object_.updateLayoutAndCheckValidity();
+  blink::WebAXObject container;
+  blink::WebFloatRect bounds;
+  SkMatrix44 matrix;
+  accessibility_object_.getRelativeBounds(container, bounds, matrix);
+  return factory_->GetOrCreate(container);
+}
+
+int WebAXObjectProxy::BoundsInContainerX() {
+  accessibility_object_.updateLayoutAndCheckValidity();
+  blink::WebAXObject container;
+  blink::WebFloatRect bounds;
+  SkMatrix44 matrix;
+  accessibility_object_.getRelativeBounds(container, bounds, matrix);
+  return bounds.x;
+}
+
+int WebAXObjectProxy::BoundsInContainerY() {
+  accessibility_object_.updateLayoutAndCheckValidity();
+  blink::WebAXObject container;
+  blink::WebFloatRect bounds;
+  SkMatrix44 matrix;
+  accessibility_object_.getRelativeBounds(container, bounds, matrix);
+  return bounds.y;
+}
+
+int WebAXObjectProxy::BoundsInContainerWidth() {
+  accessibility_object_.updateLayoutAndCheckValidity();
+  blink::WebAXObject container;
+  blink::WebFloatRect bounds;
+  SkMatrix44 matrix;
+  accessibility_object_.getRelativeBounds(container, bounds, matrix);
+  return bounds.width;
+}
+
+int WebAXObjectProxy::BoundsInContainerHeight() {
+  accessibility_object_.updateLayoutAndCheckValidity();
+  blink::WebAXObject container;
+  blink::WebFloatRect bounds;
+  SkMatrix44 matrix;
+  accessibility_object_.getRelativeBounds(container, bounds, matrix);
+  return bounds.height;
+}
+
+bool WebAXObjectProxy::HasNonIdentityTransform() {
+  accessibility_object_.updateLayoutAndCheckValidity();
+  accessibility_object_.updateLayoutAndCheckValidity();
+  blink::WebAXObject container;
+  blink::WebFloatRect bounds;
+  SkMatrix44 matrix;
+  accessibility_object_.getRelativeBounds(container, bounds, matrix);
+  return !matrix.isIdentity();
+}
+
 RootWebAXObjectProxy::RootWebAXObjectProxy(
     const blink::WebAXObject &object, Factory *factory)
     : WebAXObjectProxy(object, factory) {
 }
 
 v8::Local<v8::Object> RootWebAXObjectProxy::GetChildAtIndex(unsigned index) {
   if (index)
     return v8::Local<v8::Object>();
 
   return factory()->GetOrCreate(accessibility_object());
@@ skipping 47 matching lines @@
   v8::Local<v8::Value> value_handle = gin::CreateHandle(
       isolate, new WebAXObjectProxy(object, this)).ToV8();
   if (value_handle.IsEmpty())
     return v8::Local<v8::Object>();
   v8::Local<v8::Object> handle = value_handle->ToObject(isolate);
   elements_.Append(handle);
   return handle;
 }
 
 }  // namespace test_runner