Move some AX attrs from AXNodeData to AXTreeData.

content/browser/frame_host/render_frame_host_impl.cc

 // Copyright 2013 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 "content/browser/frame_host/render_frame_host_impl.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
@@ skipping 1152 matching lines @@
     frame_tree_node_->ResetForNewProcess();
 
   // Reset state for the current RenderFrameHost once the FrameTreeNode has been
   // reset.
   SetRenderFrameCreated(false);
   InvalidateMojoConnection();
 
   // Execute any pending AX tree snapshot callbacks with an empty response,
   // since we're never going to get a response from this renderer.
   for (const auto& iter : ax_tree_snapshot_callbacks_)
-    iter.second.Run(ui::AXTreeUpdate<ui::AXNodeData>());
+    iter.second.Run(ui::AXTreeUpdate());
   ax_tree_snapshot_callbacks_.clear();
 
   // Note: don't add any more code at this point in the function because
   // |this| may be deleted. Any additional cleanup should happen before
   // the last block of code here.
 }
 
 void RenderFrameHostImpl::OnSwappedOut() {
   // Ignore spurious swap out ack.
   if (rfh_state_ != STATE_PENDING_SWAP_OUT)
@@ skipping 232 matching lines @@
       GetOrCreateBrowserAccessibilityManager();
 
     std::vector<AXEventNotificationDetails> details;
     details.reserve(params.size());
     for (size_t i = 0; i < params.size(); ++i) {
       const AccessibilityHostMsg_EventParams& param = params[i];
       AXEventNotificationDetails detail;
       detail.event_type = param.event_type;
       detail.id = param.id;
       detail.ax_tree_id = GetAXTreeID();
+      if (param.update.has_tree_data) {
+        detail.update.has_tree_data = true;
+        AXContentTreeDataToAXTreeData(param.update.tree_data,
+                                      &detail.update.tree_data);
+      }
       detail.update.node_id_to_clear = param.update.node_id_to_clear;
       detail.update.nodes.resize(param.update.nodes.size());
       for (size_t i = 0; i < param.update.nodes.size(); ++i) {
         AXContentNodeDataToAXNodeData(param.update.nodes[i],
                                       &detail.update.nodes[i]);
       }
       details.push_back(detail);
     }
 
     if (accessibility_mode & AccessibilityModeFlagPlatform) {
@@ skipping 61 matching lines @@
     if (manager) {
       manager->OnFindInPageResult(
           params.request_id, params.match_index, params.start_id,
           params.start_offset, params.end_id, params.end_offset);
     }
   }
 }
 
 void RenderFrameHostImpl::OnAccessibilitySnapshotResponse(
     int callback_id,
-    const ui::AXTreeUpdate<AXContentNodeData>& snapshot) {
+    const AXContentTreeUpdate& snapshot) {
   const auto& it = ax_tree_snapshot_callbacks_.find(callback_id);
   if (it != ax_tree_snapshot_callbacks_.end()) {
-    ui::AXTreeUpdate<ui::AXNodeData> dst_snapshot;
+    ui::AXTreeUpdate dst_snapshot;
     dst_snapshot.nodes.resize(snapshot.nodes.size());
     for (size_t i = 0; i < snapshot.nodes.size(); ++i) {
       AXContentNodeDataToAXNodeData(snapshot.nodes[i],
                                     &dst_snapshot.nodes[i]);
     }
+    if (snapshot.has_tree_data) {
+      AXContentTreeDataToAXTreeData(snapshot.tree_data,
+                                    &dst_snapshot.tree_data);
+    }
     it->second.Run(dst_snapshot);
     ax_tree_snapshot_callbacks_.erase(it);
   } else {
     NOTREACHED() << "Received AX tree snapshot response for unknown id";
   }
 }
 
 void RenderFrameHostImpl::OnToggleFullscreen(bool enter_fullscreen) {
   if (enter_fullscreen)
     delegate_->EnterFullscreenMode(GetLastCommittedURL().GetOrigin());
@@ skipping 716 matching lines @@
     ui::AXNodeData* dst) {
   // Copy the common fields.
   *dst = src;
 
   // Map content-specific attributes based on routing IDs or browser plugin
   // instance IDs to generic attributes with global AXTreeIDs.
   for (auto iter : src.content_int_attributes) {
     AXContentIntAttribute attr = iter.first;
     int32 value = iter.second;
     switch (attr) {
-      case AX_CONTENT_ATTR_ROUTING_ID:
-        dst->int_attributes.push_back(std::make_pair(
-            ui::AX_ATTR_TREE_ID, RoutingIDToAXTreeID(value)));
-        break;
-      case AX_CONTENT_ATTR_PARENT_ROUTING_ID:
-        dst->int_attributes.push_back(std::make_pair(
-            ui::AX_ATTR_PARENT_TREE_ID, RoutingIDToAXTreeID(value)));
-        break;
       case AX_CONTENT_ATTR_CHILD_ROUTING_ID:
         dst->int_attributes.push_back(std::make_pair(
             ui::AX_ATTR_CHILD_TREE_ID, RoutingIDToAXTreeID(value)));
         break;
       case AX_CONTENT_ATTR_CHILD_BROWSER_PLUGIN_INSTANCE_ID:
         dst->int_attributes.push_back(std::make_pair(
             ui::AX_ATTR_CHILD_TREE_ID,
             BrowserPluginInstanceIDToAXTreeID(value)));
         break;
       case AX_CONTENT_INT_ATTRIBUTE_LAST:
         NOTREACHED();
         break;
     }
   }
 }
 
+void RenderFrameHostImpl::AXContentTreeDataToAXTreeData(
+    const AXContentTreeData& src,
+    ui::AXTreeData* dst) {
+  // Copy the common fields.
+  *dst = src;
+
+  if (src.routing_id != -1)
+    dst->tree_id = RoutingIDToAXTreeID(src.routing_id);
+
+  if (src.parent_routing_id != -1)
+    dst->parent_tree_id = RoutingIDToAXTreeID(src.parent_routing_id);
+}
+
 }  // namespace content