Keep track of fixed positioning in accessibility tree.

third_party/WebKit/Source/modules/accessibility/AXObject.cpp

 /*
  * Copyright (C) 2008, 2009, 2011 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.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 1472 matching lines @@
   if (!area)
     return;
 
   // TODO(bokan): This should potentially be a UserScroll.
   area->SetScrollOffset(ScrollOffset(offset.X(), offset.Y()),
                         kProgrammaticScroll);
 }
 
 void AXObject::GetRelativeBounds(AXObject** out_container,
                                  FloatRect& out_bounds_in_container,
-                                 SkMatrix44& out_container_transform) const {
+                                 SkMatrix44& out_container_transform,
+                                 bool& out_is_fixed_positioned) const {
   *out_container = nullptr;
   out_bounds_in_container = FloatRect();
   out_container_transform.setIdentity();
+  out_is_fixed_positioned = false;
+
+  if (GetSimpleRelativeBounds(out_container, out_bounds_in_container))
+    return;
 
   // First check if it has explicit bounds, for example if this element is tied
   // to a canvas path. When explicit coordinates are provided, the ID of the
   // explicit container element that the coordinates are relative to must be
   // provided too.
   if (!explicit_element_rect_.IsEmpty()) {
     *out_container = AxObjectCache().ObjectFromAXID(explicit_container_id_);
     if (*out_container) {
       out_bounds_in_container = FloatRect(explicit_element_rect_);
       return;
     }
   }
 
   LayoutObject* layout_object = LayoutObjectForRelativeBounds();
   if (!layout_object)
     return;
 
   if (IsWebArea()) {
     if (layout_object->GetFrame()->View()) {
       out_bounds_in_container.SetSize(
           FloatSize(layout_object->GetFrame()->View()->ContentsSize()));
     }
     return;
   }
 
+  // When the object is fixed-positioned, we just need to return our
+  // absolute coordinates and indicate that the position is fixed.
+  if (layout_object->IsFixedPositioned()) {
+    out_bounds_in_container = layout_object->AbsoluteBoundingBoxFloatRect();
+    *out_container = AxObjectCache().Root();
+    out_is_fixed_positioned = true;
+    return;
+  }
+
   // First compute the container. The container must be an ancestor in the
   // accessibility tree, and its LayoutObject must be an ancestor in the layout
   // tree. Get the first such ancestor that's either scrollable or has a paint
   // layer.
   AXObject* container = ParentObjectUnignored();
   LayoutObject* container_layout_object = nullptr;
   while (container) {
     container_layout_object = container->GetLayoutObject();
     if (container_layout_object && container_layout_object->IsBox() &&
         layout_object->IsDescendantOf(container_layout_object)) {
       if (container->IsScrollableContainer() ||
-          container_layout_object->HasLayer())
+          container_layout_object->HasLayer() ||
+          container_layout_object->IsFixedPositioned())
         break;
     }
 
     container = container->ParentObjectUnignored();
   }
 
   if (!container)
     return;
   *out_container = container;
   out_bounds_in_container =
@@ skipping 17 matching lines @@
     out_bounds_in_container.Move(transform.To2DTranslation());
   } else {
     out_container_transform = TransformationMatrix::ToSkMatrix44(transform);
   }
 }
 
 LayoutRect AXObject::GetBoundsInFrameCoordinates() const {
   AXObject* container = nullptr;
   FloatRect bounds;
   SkMatrix44 transform;
-  GetRelativeBounds(&container, bounds, transform);
+  bool is_fixed_positioned;
+  GetRelativeBounds(&container, bounds, transform, is_fixed_positioned);
   FloatRect computed_bounds(0, 0, bounds.Width(), bounds.Height());
   while (container && container != this) {
     computed_bounds.Move(bounds.X(), bounds.Y());
-    if (!container->IsWebArea()) {
+    if (!container->IsWebArea() && !is_fixed_positioned) {
       computed_bounds.Move(-container->GetScrollOffset().X(),
                            -container->GetScrollOffset().Y());
     }
     if (!transform.isIdentity()) {
       TransformationMatrix transformation_matrix(transform);
       transformation_matrix.MapRect(computed_bounds);
     }
-    container->GetRelativeBounds(&container, bounds, transform);
+    container->GetRelativeBounds(&container, bounds, transform,
+                                 is_fixed_positioned);
   }
   return LayoutRect(computed_bounds);
 }
 
 //
 // Modify or take an action on an object.
 //
 
 bool AXObject::Press() {
   Document* document = GetDocument();
@@ skipping 505 matching lines @@
 }
 
 DEFINE_TRACE(AXObject) {
   visitor->Trace(children_);
   visitor->Trace(parent_);
   visitor->Trace(cached_live_region_root_);
   visitor->Trace(ax_object_cache_);
 }
 
 }  // namespace blink