Convert accessibility_helper.mojom to snake casing

chrome/browser/chromeos/arc/accessibility/ax_tree_source_arc.cc

 // Copyright 2017 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/browser/chromeos/arc/accessibility/ax_tree_source_arc.h"
 
 #include <string>
 
 #include "chrome/browser/extensions/api/automation_internal/automation_event_router.h"
 #include "chrome/browser/ui/aura/accessibility/automation_manager_aura.h"
@@ skipping 47 matching lines @@
   }
   return ui::AX_EVENT_CHILDREN_CHANGED;
 }
 
 const gfx::Rect GetBounds(arc::mojom::AccessibilityNodeInfoData* node) {
   exo::WMHelper* wm_helper = exo::WMHelper::GetInstance();
   if (!wm_helper)
     return gfx::Rect();
 
   aura::Window* focused_window = wm_helper->GetFocusedWindow();
-  gfx::Rect bounds_in_screen = node->boundsInScreen;
+  gfx::Rect bounds_in_screen = node->bounds_in_screen;
   if (focused_window) {
     aura::Window* toplevel_window = focused_window->GetToplevelWindow();
     return gfx::ScaleToEnclosingRect(
         bounds_in_screen,
         1.0f / toplevel_window->layer()->device_scale_factor());
   }
   return bounds_in_screen;
 }
 
 bool GetBooleanProperty(arc::mojom::AccessibilityNodeInfoData* node,
                         arc::mojom::AccessibilityBooleanProperty prop) {
-  if (!node->booleanProperties)
+  if (!node->boolean_properties)
     return false;
 
-  auto it = node->booleanProperties->find(prop);
-  if (it == node->booleanProperties->end())
+  auto it = node->boolean_properties->find(prop);
+  if (it == node->boolean_properties->end())
     return false;
 
   return it->second;
 }
 
 bool GetIntProperty(arc::mojom::AccessibilityNodeInfoData* node,
                     arc::mojom::AccessibilityIntProperty prop,
                     int32_t* out_value) {
-  if (!node->intProperties)
+  if (!node->int_properties)
     return false;
 
-  auto it = node->intProperties->find(prop);
-  if (it == node->intProperties->end())
+  auto it = node->int_properties->find(prop);
+  if (it == node->int_properties->end())
     return false;
 
   *out_value = it->second;
   return true;
 }
 
 bool GetStringProperty(arc::mojom::AccessibilityNodeInfoData* node,
                        arc::mojom::AccessibilityStringProperty prop,
                        std::string* out_value) {
-  if (!node->stringProperties)
+  if (!node->string_properties)
     return false;
 
-  auto it = node->stringProperties->find(prop);
-  if (it == node->stringProperties->end())
+  auto it = node->string_properties->find(prop);
+  if (it == node->string_properties->end())
     return false;
 
   *out_value = it->second;
   return true;
 }
 
 void PopulateAXRole(arc::mojom::AccessibilityNodeInfoData* node,
                     ui::AXNodeData* out_data) {
   std::string class_name;
   GetStringProperty(node, arc::mojom::AccessibilityStringProperty::CLASS_NAME,
@@ skipping 117 matching lines @@
 
 AXTreeSourceArc::~AXTreeSourceArc() {
   Reset();
 }
 
 void AXTreeSourceArc::NotifyAccessibilityEvent(
     mojom::AccessibilityEventData* event_data) {
   tree_map_.clear();
   parent_map_.clear();
   root_id_ = -1;
-  for (size_t i = 0; i < event_data->nodeData.size(); ++i) {
-    if (!event_data->nodeData[i]->intListProperties)
+  for (size_t i = 0; i < event_data->node_data.size(); ++i) {
+    if (!event_data->node_data[i]->int_list_properties)
       continue;
-    auto it = event_data->nodeData[i]->intListProperties->find(
+    auto it = event_data->node_data[i]->int_list_properties->find(
         arc::mojom::AccessibilityIntListProperty::CHILD_NODE_IDS);
-    if (it != event_data->nodeData[i]->intListProperties->end()) {
+    if (it != event_data->node_data[i]->int_list_properties->end()) {
       for (size_t j = 0; j < it->second.size(); ++j)
-        parent_map_[it->second[j]] = event_data->nodeData[i]->id;
+        parent_map_[it->second[j]] = event_data->node_data[i]->id;
     }
   }
 
-  for (size_t i = 0; i < event_data->nodeData.size(); ++i) {
-    int32_t id = event_data->nodeData[i]->id;
-    tree_map_[id] = event_data->nodeData[i].get();
+  for (size_t i = 0; i < event_data->node_data.size(); ++i) {
+    int32_t id = event_data->node_data[i]->id;
+    tree_map_[id] = event_data->node_data[i].get();
     if (parent_map_.find(id) == parent_map_.end()) {
       CHECK_EQ(-1, root_id_) << "Duplicated root";
       root_id_ = id;
     }
   }
 
   ExtensionMsg_AccessibilityEventParams params;
-  params.event_type = ToAXEvent(event_data->eventType);
+  params.event_type = ToAXEvent(event_data->event_type);
 
   if (params.event_type == ui::AX_EVENT_FOCUS)
-    focused_node_id_ = event_data->sourceId;
+    focused_node_id_ = event_data->source_id;
 
   params.tree_id = tree_id();
-  params.id = event_data->sourceId;
+  params.id = event_data->source_id;
 
-  current_tree_serializer_->SerializeChanges(GetFromId(event_data->sourceId),
+  current_tree_serializer_->SerializeChanges(GetFromId(event_data->source_id),
                                              &params.update);
 
   extensions::AutomationEventRouter* router =
       extensions::AutomationEventRouter::GetInstance();
   router->DispatchAccessibilityEvent(params);
 }
 
 void AXTreeSourceArc::Focus(aura::Window* window) {
   views::Widget* widget = views::Widget::GetWidgetForNativeView(window);
   if (!widget || !widget->GetContentsView())
@@ skipping 26 matching lines @@
 
 int32_t AXTreeSourceArc::GetId(mojom::AccessibilityNodeInfoData* node) const {
   if (!node)
     return -1;
   return node->id;
 }
 
 void AXTreeSourceArc::GetChildren(
     mojom::AccessibilityNodeInfoData* node,
     std::vector<mojom::AccessibilityNodeInfoData*>* out_children) const {
-  if (!node || !node->intListProperties)
+  if (!node || !node->int_list_properties)
     return;
 
-  auto it = node->intListProperties->find(
+  auto it = node->int_list_properties->find(
       arc::mojom::AccessibilityIntListProperty::CHILD_NODE_IDS);
-  if (it == node->intListProperties->end())
+  if (it == node->int_list_properties->end())
     return;
 
   for (size_t i = 0; i < it->second.size(); ++i) {
     out_children->push_back(GetFromId(it->second[i]));
   }
 }
 
 mojom::AccessibilityNodeInfoData* AXTreeSourceArc::GetParent(
     mojom::AccessibilityNodeInfoData* node) const {
   if (!node)
@@ skipping 72 matching lines @@
   focused_node_id_ = -1;
   extensions::AutomationEventRouter* router =
       extensions::AutomationEventRouter::GetInstance();
   if (!router)
     return;
 
   router->DispatchTreeDestroyedEvent(tree_id(), nullptr);
 }
 
 }  // namespace arc