Fix computation of Automation API location offsets in WebViews.

chrome/renderer/extensions/automation_internal_custom_bindings.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 "chrome/renderer/extensions/automation_internal_custom_bindings.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 520 matching lines @@
                     TreeCache* cache, ui::AXNode* node) {
         std::string role_name = ui::ToString(node->data().role);
         result.Set(v8::String::NewFromUtf8(isolate, role_name.c_str()));
       });
   RouteNodeIDFunction(
       "GetLocation", [](v8::Isolate* isolate, v8::ReturnValue<v8::Value> result,
                         TreeCache* cache, ui::AXNode* node) {
         gfx::RectF local_bounds = ComputeLocalNodeBounds(cache, node);
         gfx::Rect global_bounds =
             ComputeGlobalNodeBounds(cache, node, local_bounds);
-        global_bounds.Offset(cache->location_offset);
         result.Set(RectToV8Object(isolate, global_bounds));
       });
   RouteNodeIDFunction(
       "GetLineStartOffsets",
       [](v8::Isolate* isolate, v8::ReturnValue<v8::Value> result,
          TreeCache* cache, ui::AXNode* node) {
         const std::vector<int> line_starts =
             node->GetOrComputeLineStartOffsets();
         v8::Local<v8::Array> array_result(
             v8::Array::New(isolate, line_starts.size()));
@@ skipping 19 matching lines @@
   // and return a property of the node.
 
   RouteNodeIDPlusRangeFunction(
       "GetBoundsForRange",
       [](v8::Isolate* isolate, v8::ReturnValue<v8::Value> result,
          TreeCache* cache, ui::AXNode* node, int start, int end) {
         gfx::RectF local_bounds = ComputeLocalNodeBounds(cache, node);
         if (node->data().role != ui::AX_ROLE_INLINE_TEXT_BOX) {
           gfx::Rect global_bounds =
               ComputeGlobalNodeBounds(cache, node, local_bounds);
-          global_bounds.Offset(cache->location_offset);
           result.Set(RectToV8Object(isolate, global_bounds));
         }
 
         // Use character offsets to compute the local bounds of this subrange.
         std::string name = node->data().GetStringAttribute(ui::AX_ATTR_NAME);
         std::vector<int> character_offsets =
             node->data().GetIntListAttribute(ui::AX_ATTR_CHARACTER_OFFSETS);
         int len =
             static_cast<int>(std::min(name.size(), character_offsets.size()));
         if (start >= 0 && start <= end && end <= len) {
@@ skipping 21 matching lines @@
               local_bounds.set_height(end_offset - start_offset);
               break;
           }
         }
 
         // Convert from local to global coordinates second, after subsetting,
         // because the local to global conversion might involve matrix
         // transformations.
         gfx::Rect global_bounds =
             ComputeGlobalNodeBounds(cache, node, local_bounds);
-        global_bounds.Offset(cache->location_offset);
         result.Set(RectToV8Object(isolate, global_bounds));
       });
 
   // Bindings that take a Tree ID and Node ID and string attribute name
   // and return a property of the node.
 
   RouteNodeIDPlusAttributeFunction(
       "GetStringAttribute",
       [](v8::Isolate* isolate, v8::ReturnValue<v8::Value> result,
          ui::AXNode* node, const std::string& attribute_name) {
@@ skipping 373 matching lines @@
     tree_change_observer_overall_filter_ |= 1 << observer.filter;
 }
 
 ui::AXNode* AutomationInternalCustomBindings::GetParent(
     ui::AXNode* node,
     TreeCache** in_out_cache) {
   if (node->parent())
     return node->parent();
 
   int parent_tree_id = (*in_out_cache)->tree.data().parent_tree_id;
+
+  // Try the desktop tree if the parent is unknown. If this tree really is
+  // a child of the desktop tree, we'll find its parent, and if not, the
+  // search, below, will fail until the real parent tree loads.
   if (parent_tree_id < 0)
-    return nullptr;
+    parent_tree_id = api::automation::kDesktopTreeID;
 
   TreeCache* parent_cache = GetTreeCacheFromTreeID(parent_tree_id);
   if (!parent_cache)
     return nullptr;
 
   // Try to use the cached parent node from the most recent time this
   // was called.
-  if (parent_cache->parent_node_id_from_parent_tree > 0) {
+  if ((*in_out_cache)->parent_node_id_from_parent_tree > 0) {
     ui::AXNode* parent = parent_cache->tree.GetFromId(
-        parent_cache->parent_node_id_from_parent_tree);
+        (*in_out_cache)->parent_node_id_from_parent_tree);
     if (parent) {
       int parent_child_tree_id =
           parent->data().GetIntAttribute(ui::AX_ATTR_CHILD_TREE_ID);
       if (parent_child_tree_id == (*in_out_cache)->tree_id) {
         *in_out_cache = parent_cache;
         return parent;
       }
     }
   }
 
@@ skipping 87 matching lines @@
     cache->parent_node_id_from_parent_tree = -1;
     cache->tree.SetDelegate(this);
     cache->owner = this;
     tree_id_to_tree_cache_map_.insert(std::make_pair(tree_id, cache));
     axtree_to_tree_cache_map_.insert(std::make_pair(&cache->tree, cache));
   } else {
     cache = iter->second;
   }
 
   // Update the internal state whether it's the active profile or not.
-  cache->location_offset = params.location_offset;
   deleted_node_ids_.clear();
   v8::Isolate* isolate = GetIsolate();
   v8::HandleScope handle_scope(isolate);
   v8::Context::Scope context_scope(context()->v8_context());
   v8::Local<v8::Array> args(v8::Array::New(GetIsolate(), 1U));
   if (!cache->tree.Unserialize(params.update)) {
     LOG(ERROR) << cache->tree.error();
     args->Set(0U, v8::Number::New(isolate, tree_id));
     context()->DispatchEvent(
         "automationInternal.onAccessibilityTreeSerializationError", args);
@@ skipping 246 matching lines @@
   v8::Local<v8::Array> args(v8::Array::New(GetIsolate(), 2U));
   args->Set(0U, v8::Integer::New(GetIsolate(), tree_id));
   v8::Local<v8::Array> nodes(v8::Array::New(GetIsolate(), ids.size()));
   args->Set(1U, nodes);
   for (size_t i = 0; i < ids.size(); ++i)
     nodes->Set(i, v8::Integer::New(GetIsolate(), ids[i]));
   context()->DispatchEvent("automationInternal.onNodesRemoved", args);
 }
 
 }  // namespace extensions