Initial support for accessible text fields and focus tracking in ARC++

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"
 #include "chrome/common/extensions/chrome_extension_messages.h"
 #include "components/exo/wm_helper.h"
 #include "ui/accessibility/platform/ax_android_constants.h"
 #include "ui/aura/window.h"
 
 namespace {
 
 ui::AXEvent ToAXEvent(arc::mojom::AccessibilityEventType arc_event_type) {
   switch (arc_event_type) {
     case arc::mojom::AccessibilityEventType::VIEW_FOCUSED:
+      return ui::AX_EVENT_FOCUS;

[hidehiko, 2017/03/21 03:43:23]

nit: unnecessary change.

[David Tseng, 2017/03/21 16:41:16]

Done.

     case arc::mojom::AccessibilityEventType::VIEW_ACCESSIBILITY_FOCUSED:
       return ui::AX_EVENT_FOCUS;
-    case arc::mojom::AccessibilityEventType::VIEW_ACCESSIBILITY_FOCUS_CLEARED:
-      return ui::AX_EVENT_BLUR;
     case arc::mojom::AccessibilityEventType::VIEW_CLICKED:
     case arc::mojom::AccessibilityEventType::VIEW_LONG_CLICKED:
       return ui::AX_EVENT_CLICKED;
     case arc::mojom::AccessibilityEventType::VIEW_TEXT_CHANGED:
       return ui::AX_EVENT_TEXT_CHANGED;
     case arc::mojom::AccessibilityEventType::VIEW_TEXT_SELECTION_CHANGED:
       return ui::AX_EVENT_TEXT_SELECTION_CHANGED;
     case arc::mojom::AccessibilityEventType::WINDOW_STATE_CHANGED:
     case arc::mojom::AccessibilityEventType::NOTIFICATION_STATE_CHANGED:
     case arc::mojom::AccessibilityEventType::WINDOW_CONTENT_CHANGED:
@@ skipping 41 matching lines @@
   if (!node->booleanProperties)
     return false;
 
   auto it = node->booleanProperties->find(prop);
   if (it == node->booleanProperties->end())
     return false;
 
   return it->second;
 }
 
+bool GetIntProperty(arc::mojom::AccessibilityNodeInfoData* node,
+                    arc::mojom::AccessibilityIntProperty prop,
+                    int32_t* out_value) {
+  if (!node->intProperties)
+    return false;
+
+  auto it = node->intProperties->find(prop);
+  if (it == node->intProperties->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)
     return false;
 
   auto it = node->stringProperties->find(prop);
   if (it == node->stringProperties->end())
     return false;
 
@@ skipping 116 matching lines @@
     int32_t id = event_data->nodeData[i]->id;
     tree_map_[id] = event_data->nodeData[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);
+
   if (params.event_type == ui::AX_EVENT_FOCUS)
-    focused_node_id_ = params.id;
-  else if (params.event_type == ui::AX_EVENT_BLUR)
-    focused_node_id_ = -1;
+    focused_node_id_ = event_data->sourceId;
+
   params.tree_id = tree_id_;
   params.id = event_data->sourceId;
 
   current_tree_serializer_->SerializeChanges(GetFromId(event_data->sourceId),
                                              &params.update);
 
   extensions::AutomationEventRouter* router =
       extensions::AutomationEventRouter::GetInstance();
   router->DispatchAccessibilityEvent(params);
 }
@@ skipping 63 matching lines @@
 mojom::AccessibilityNodeInfoData* AXTreeSourceArc::GetNull() const {
   return nullptr;
 }
 
 void AXTreeSourceArc::SerializeNode(mojom::AccessibilityNodeInfoData* node,
                                     ui::AXNodeData* out_data) const {
   if (!node)
     return;
   out_data->id = node->id;
 
+  using AXIntProperty = arc::mojom::AccessibilityIntProperty;
   using AXStringProperty = arc::mojom::AccessibilityStringProperty;
   std::string text;
   if (GetStringProperty(node, AXStringProperty::TEXT, &text))
     out_data->SetName(text);
   else if (GetStringProperty(node, AXStringProperty::CONTENT_DESCRIPTION,
                              &text))
     out_data->SetName(text);
 
   int32_t id = node->id;
   if (id == root_id_)
     out_data->role = ui::AX_ROLE_ROOT_WEB_AREA;
   else
     PopulateAXRole(node, out_data);
 
   PopulateAXState(node, out_data);
 
   const gfx::Rect bounds_in_screen = GetBounds(node);
   out_data->location.SetRect(bounds_in_screen.x(), bounds_in_screen.y(),
                              bounds_in_screen.width(),
                              bounds_in_screen.height());
 
   if (out_data->role == ui::AX_ROLE_TEXT_FIELD && !text.empty())
     out_data->AddStringAttribute(ui::AX_ATTR_VALUE, text);
+
+  // Integer properties.
+  int32_t val;
+  if (GetIntProperty(node, AXIntProperty::TEXT_SELECTION_START, &val) &&
+      val >= 0)

[Luis Héctor Chávez, 2017/03/17 22:13:20]

nit: add braces since the condition spans two lines.

[David Tseng, 2017/03/21 16:41:16]

STyle guide says
"In general, curly braces are not required for single-line statements, but they
are allowed if you like them; conditional or loop statements with complex
conditions or statements may be more readable with curly braces. Some projects
require that an if must always always have an accompanying brace."

and I've always omitted braces for single statement if's.
 

+    out_data->AddIntAttribute(ui::AX_ATTR_TEXT_SEL_START, val);
+
+  if (GetIntProperty(node, AXIntProperty::TEXT_SELECTION_END, &val) && val >= 0)
+    out_data->AddIntAttribute(ui::AX_ATTR_TEXT_SEL_END, val);
 }
 
 void AXTreeSourceArc::Reset() {
   tree_map_.clear();
   parent_map_.clear();
   current_tree_serializer_.reset(new AXTreeArcSerializer(this));
   root_id_ = -1;
   focused_node_id_ = -1;
   extensions::AutomationEventRouter* router =
       extensions::AutomationEventRouter::GetInstance();
   router->DispatchTreeDestroyedEvent(tree_id_, nullptr);
 }
 
 }  // namespace arc