Expand Chrome OS ARC support to create one tree source per package

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"
+#include "ui/views/focus/focus_manager.h"
+#include "ui/views/view.h"
+#include "ui/views/widget/widget.h"
 
 namespace {
 
+// This class keeps focus on a |ShellSurface| without interfering with default
+// focus management in |ShellSurface|. For example, touch causes the
+// |ShellSurface| to lose focus to its ancestor containing View.
+class FocusStealer : public views::View {
+ public:
+  explicit FocusStealer(int32_t id) : id_(id) { set_owned_by_client(); }
+
+  void Steal() {
+    SetFocusBehavior(views::View::FocusBehavior::ALWAYS);
+    RequestFocus();
+    parent()->NotifyAccessibilityEvent(ui::AX_EVENT_CHILDREN_CHANGED, false);
+    NotifyAccessibilityEvent(ui::AX_EVENT_FOCUS, false);
+  }
+
+  // views::View overrides.
+  void GetAccessibleNodeData(ui::AXNodeData* node_data) override {
+    node_data->AddIntAttribute(ui::AX_ATTR_CHILD_TREE_ID, id_);
+    node_data->role = ui::AX_ROLE_CLIENT;
+  }
+
+ private:
+  int32_t id_;

[Luis Héctor Chávez, 2017/04/25 15:27:00]

nit: const int32_t id_;

[David Tseng, 2017/04/25 22:48:02]

Done.

+  DISALLOW_COPY_AND_ASSIGN(FocusStealer);
+};
+
 ui::AXEvent ToAXEvent(arc::mojom::AccessibilityEventType arc_event_type) {
   switch (arc_event_type) {
     case arc::mojom::AccessibilityEventType::VIEW_FOCUSED:
     case arc::mojom::AccessibilityEventType::VIEW_ACCESSIBILITY_FOCUSED:
       return ui::AX_EVENT_FOCUS;
     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;
@@ skipping 166 matching lines @@
   }
 
   if (!GetBooleanProperty(node, AXBooleanProperty::ENABLED))
     out_data->AddStateFlag(ui::AX_STATE_DISABLED);
 }
 
 }  // namespace
 
 namespace arc {
 
-AXTreeSourceArc::AXTreeSourceArc(int32_t id)
-    : tree_id_(id),
-      current_tree_serializer_(new AXTreeArcSerializer(this)),
+AXTreeSourceArc::AXTreeSourceArc(Delegate* delegate)
+    : current_tree_serializer_(new AXTreeArcSerializer(this)),
       root_id_(-1),
-      focused_node_id_(-1) {}
+      focused_node_id_(-1),
+      delegate_(delegate),
+      focus_stealer_(new FocusStealer(tree_id())) {}
 
 AXTreeSourceArc::~AXTreeSourceArc() {
   Reset();
 }
 
 void AXTreeSourceArc::NotifyAccessibilityEvent(
     mojom::AccessibilityEventData* event_data) {
   tree_map_.clear();
   parent_map_.clear();
   root_id_ = -1;
@@ skipping 16 matching lines @@
       root_id_ = id;
     }
   }
 
   ExtensionMsg_AccessibilityEventParams params;
   params.event_type = ToAXEvent(event_data->eventType);
 
   if (params.event_type == ui::AX_EVENT_FOCUS)
     focused_node_id_ = event_data->sourceId;
 
-  params.tree_id = tree_id_;
+  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);
 }
 
+void AXTreeSourceArc::Focus(aura::Window* window) {
+  views::Widget* widget = views::Widget::GetWidgetForNativeView(window);
+  if (!widget || !widget->GetContentsView())
+    return;
+
+  views::View* view = widget->GetContentsView();
+  if (!view->Contains(focus_stealer_.get()))
+    view->AddChildView(focus_stealer_.get());
+  focus_stealer_->Steal();
+}
+
 bool AXTreeSourceArc::GetTreeData(ui::AXTreeData* data) const {
-  data->tree_id = tree_id_;
+  data->tree_id = tree_id();
   if (focused_node_id_ >= 0)
     data->focus_id = focused_node_id_;
   return true;
 }
 
 mojom::AccessibilityNodeInfoData* AXTreeSourceArc::GetRoot() const {
   mojom::AccessibilityNodeInfoData* root = GetFromId(root_id_);
   return root;
 }
 
@@ skipping 85 matching lines @@
   // Integer properties.
   int32_t val;
   if (GetIntProperty(node, AXIntProperty::TEXT_SELECTION_START, &val) &&
       val >= 0)
     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::PerformAction(const ui::AXActionData& data) {
+  delegate_->OnAction(data);
+}
+
 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);
+  router->DispatchTreeDestroyedEvent(tree_id(), nullptr);
 }
 
 }  // namespace arc