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

chrome/browser/chromeos/arc/accessibility/arc_accessibility_helper_bridge.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/arc_accessibility_helper_bridge.h"
 
 #include "base/command_line.h"
 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h"
-#include "chrome/browser/chromeos/arc/accessibility/ax_tree_source_arc.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chromeos/chromeos_switches.h"
 #include "components/arc/arc_bridge_service.h"
 #include "components/exo/shell_surface.h"
 #include "components/exo/surface.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
 #include "ui/gfx/geometry/rect.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) {
-    SetFocusBehavior(views::View::FocusBehavior::ALWAYS);
-    set_owned_by_client();
-  }
-
-  // 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_;
-  DISALLOW_COPY_AND_ASSIGN(FocusStealer);
-};
-
 exo::Surface* GetArcSurface(const aura::Window* window) {
   if (!window)
     return nullptr;
 
   exo::Surface* arc_surface = exo::Surface::AsSurface(window);
   if (!arc_surface)
     arc_surface = exo::ShellSurface::GetMainSurface(window);
   return arc_surface;
 }
 
+int32_t GetTaskId(aura::Window* window) {
+  const std::string arc_app_id = exo::ShellSurface::GetApplicationId(window);
+  if (arc_app_id.empty())
+    return -1;
+
+  int task_id = -1;
+  if (sscanf(arc_app_id.c_str(), "org.chromium.arc.%d", &task_id) != 1)
+    return -1;
+
+  return task_id;
+}
+
 void DispatchFocusChange(arc::mojom::AccessibilityNodeInfoData* node_data) {
   chromeos::AccessibilityManager* accessibility_manager =
       chromeos::AccessibilityManager::Get();
   if (!accessibility_manager)
     return;
 
   exo::WMHelper* wmHelper = exo::WMHelper::GetInstance();
   aura::Window* focused_window = wmHelper->GetFocusedWindow();
   if (!focused_window)
     return;
 
   aura::Window* toplevel_window = focused_window->GetToplevelWindow();
 
   gfx::Rect bounds_in_screen = gfx::ScaleToEnclosingRect(
       node_data->boundsInScreen,
       1.0f / toplevel_window->layer()->device_scale_factor());
 
   accessibility_manager->OnViewFocusedInArc(bounds_in_screen);
 }
 
+arc::mojom::AccessibilityFilterType GetFilterType() {
+  chromeos::AccessibilityManager* accessibility_manager =
+      chromeos::AccessibilityManager::Get();
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          chromeos::switches::kEnableChromeVoxArcSupport))
+    return arc::mojom::AccessibilityFilterType::ALL;
+
+  if (!accessibility_manager)
+    return arc::mojom::AccessibilityFilterType::OFF;
+
+  if (accessibility_manager->IsSpokenFeedbackEnabled())
+    return arc::mojom::AccessibilityFilterType::WHITELISTED_PACKAGE_NAME;
+
+  if (accessibility_manager->IsFocusHighlightEnabled())
+    return arc::mojom::AccessibilityFilterType::FOCUS;
+
+  return arc::mojom::AccessibilityFilterType::OFF;
+}
+
 }  // namespace
 
 namespace arc {
 
 ArcAccessibilityHelperBridge::ArcAccessibilityHelperBridge(
     ArcBridgeService* bridge_service)
-    : ArcService(bridge_service), binding_(this) {
+    : ArcService(bridge_service), binding_(this), current_task_id_(0) {
   arc_bridge_service()->accessibility_helper()->AddObserver(this);
 }
 
 ArcAccessibilityHelperBridge::~ArcAccessibilityHelperBridge() {
   arc_bridge_service()->accessibility_helper()->RemoveObserver(this);
+  ArcAppListPrefs::Get(chromeos::AccessibilityManager::Get()->profile())
+      ->RemoveObserver(this);
 }
 
 void ArcAccessibilityHelperBridge::OnInstanceReady() {
+  ArcAppListPrefs::Get(chromeos::AccessibilityManager::Get()->profile())
+      ->AddObserver(this);
   auto* instance = ARC_GET_INSTANCE_FOR_METHOD(
       arc_bridge_service()->accessibility_helper(), Init);
   DCHECK(instance);
   instance->Init(binding_.CreateInterfacePtrAndBind());
 
-  chromeos::AccessibilityManager* accessibility_manager =
-      chromeos::AccessibilityManager::Get();
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          chromeos::switches::kEnableChromeVoxArcSupport)) {
-    instance->SetFilter(arc::mojom::AccessibilityFilterType::ALL);
-    if (!tree_source_) {
-      tree_source_.reset(new AXTreeSourceArc(tree_id()));
-      focus_stealer_.reset(new FocusStealer(tree_source_->tree_id()));
-      exo::WMHelper::GetInstance()->AddActivationObserver(this);
-    }
-  } else if (accessibility_manager &&
-             accessibility_manager->IsFocusHighlightEnabled()) {
-    instance->SetFilter(arc::mojom::AccessibilityFilterType::FOCUS);
-  }
+  arc::mojom::AccessibilityFilterType filter_type = GetFilterType();
+  instance->SetFilter(filter_type);
+
+  if (filter_type == arc::mojom::AccessibilityFilterType::ALL ||
+      filter_type ==
+          arc::mojom::AccessibilityFilterType::WHITELISTED_PACKAGE_NAME)
+    exo::WMHelper::GetInstance()->AddActivationObserver(this);
 }
 
 void ArcAccessibilityHelperBridge::OnAccessibilityEventDeprecated(
     mojom::AccessibilityEventType event_type,
     mojom::AccessibilityNodeInfoDataPtr event_source) {
   if (event_type == arc::mojom::AccessibilityEventType::VIEW_FOCUSED)
     DispatchFocusChange(event_source.get());
 }
 
 void ArcAccessibilityHelperBridge::OnAccessibilityEvent(
     mojom::AccessibilityEventDataPtr event_data) {
-  if (tree_source_) {
-    tree_source_->NotifyAccessibilityEvent(event_data.get());
+  arc::mojom::AccessibilityFilterType filter_type = GetFilterType();
+
+  if (filter_type == arc::mojom::AccessibilityFilterType::ALL ||
+      filter_type ==
+          arc::mojom::AccessibilityFilterType::WHITELISTED_PACKAGE_NAME) {
+    // Get the task id for this package.
+    if (event_data->nodeData.size()) {
+      arc::mojom::AccessibilityNodeInfoData* node =
+          event_data->nodeData[0].get();
+      if (!node->stringProperties)
+        return;
+
+      auto it = node->stringProperties->find(
+          arc::mojom::AccessibilityStringProperty::PACKAGE_NAME);
+      if (it == node->stringProperties->end())
+        return;
+
+      auto task_id_it = package_name_to_task_id_.find(it->second);
+      if (task_id_it == package_name_to_task_id_.end())
+        return;
+
+      int32_t task_id = task_id_it->second;
+
+      // Reject updates to non-current task ids. We can do this currently
+      // because all events include the entire tree.
+      if (task_id != current_task_id_)
+        return;
+
+      auto tree_it = task_id_to_tree_.find(task_id);
+      AXTreeSourceArc* tree_source;
+      if (tree_it == task_id_to_tree_.end()) {
+        tree_source = new AXTreeSourceArc(this);
+        task_id_to_tree_[task_id] = tree_source;
+      } else {
+        tree_source = tree_it->second;
+      }
+      tree_source->NotifyAccessibilityEvent(event_data.get());
+    }
     return;
   }
 
   if (event_data->eventType != arc::mojom::AccessibilityEventType::VIEW_FOCUSED)
     return;
 
   CHECK_EQ(1U, event_data.get()->nodeData.size());
   DispatchFocusChange(event_data.get()->nodeData[0].get());
 }
 
-void ArcAccessibilityHelperBridge::OnWindowActivated(
-    aura::Window* gained_active,
-    aura::Window* lost_active) {
-  if (gained_active == lost_active || !tree_source_)
-    return;
-
-  exo::Surface* active_surface = GetArcSurface(gained_active);
-  exo::Surface* inactive_surface = GetArcSurface(lost_active);
-
-  // Detach the accessibility tree from an inactive ShellSurface so that any
-  // client walking the desktop tree gets non-duplicated linearization.
-  if (inactive_surface) {
-    views::Widget* widget = views::Widget::GetWidgetForNativeView(lost_active);
-    if (widget && widget->GetContentsView()) {
-      views::View* view = widget->GetContentsView();
-      view->RemoveChildView(focus_stealer_.get());
-      view->NotifyAccessibilityEvent(ui::AX_EVENT_CHILDREN_CHANGED, false);
-    }
-  }
-
-  if (!active_surface)
-    return;
-
-  views::Widget* widget = views::Widget::GetWidgetForNativeView(gained_active);
-  if (widget && widget->GetContentsView()) {
-    views::View* view = widget->GetContentsView();
-    if (!view->Contains(focus_stealer_.get()))
-      view->AddChildView(focus_stealer_.get());
-    focus_stealer_->RequestFocus();
-    view->NotifyAccessibilityEvent(ui::AX_EVENT_CHILDREN_CHANGED, false);
-  }
-}
-
-void ArcAccessibilityHelperBridge::PerformAction(const ui::AXActionData& data) {
+void ArcAccessibilityHelperBridge::OnAction(const ui::AXActionData& data) {
   arc::mojom::AccessibilityActionType mojo_action;
   switch (data.action) {
     case ui::AX_ACTION_DO_DEFAULT:
       mojo_action = arc::mojom::AccessibilityActionType::CLICK;
       break;
     default:
       return;
   }
 
   auto* instance = ARC_GET_INSTANCE_FOR_METHOD(
       arc_bridge_service()->accessibility_helper(), PerformAction);
   instance->PerformAction(data.target_node_id, mojo_action);
 }
 
+void ArcAccessibilityHelperBridge::OnWindowActivated(
+    aura::Window* gained_active,
+    aura::Window* lost_active) {
+  if (gained_active == lost_active)
+    return;
+
+  if (!GetArcSurface(gained_active))
+    return;
+
+  // Grab the tree source associated with this app.
+  int32_t task_id = GetTaskId(gained_active);
+  auto it = task_id_to_tree_.find(task_id);
+  if (it != task_id_to_tree_.end())
+    it->second->Focus(gained_active);
+}
+
+void ArcAccessibilityHelperBridge::OnTaskCreated(
+    int task_id,
+    const std::string& package_name,
+    const std::string& activity,
+    const std::string& intent) {
+  package_name_to_task_id_[package_name] = task_id;

[yawano, 2017/04/25 09:29:23]

An app can open multiple activities. One example is Android Gmail app. If you
tap compose, it opens another activity with the same package name. Are we
assigning same task id for that case? Or are we assigning different task ids in
that case?

[David Tseng, 2017/04/25 16:16:54]

Yes, this was a concern of mine as well so I pushed this patchset out for review
earlier than later.

If I log OnTaskCreated, I only ever see the startup activity in Inbox. This is
after tapping on compose. I tried this for several other apps, navigating
through several screens (with a navigate up button). However, if you would like
to verify this, would appreciate it.

If we do indeed need Activity name, it is somewhat knknown how we can support
this.

The root problem we would need to solve is
an AccessibilityEvent is only associated with a package name and not an
activity. Trying to get the activity name is unfortunately just as racey as
anything else.

[yawano, 2017/04/26 08:03:24]

I've tested this today, and different task ids are assigned to different windows
from same package name.

Inbox doesn't start new activity for compose. But Gmail Android client does.

Also activity name won't help as a single package can start multiple same
activities. On Android side, we have AccessibilityWindowInfo and it has its own
id for each window. We may be able to use it for distinguishing them. But it's
not always available for all events, and it will make the logic much more
complicated.

IIUC, we want to do this as we have problem with whitelisting. We won't switch
between ChromeVox and TalkBack in the single package name.

How about to make this mapping 1:n? 1 package name can have multiple task ids.

e.g.
If we get an accessibility event for packageA.
Resolve package name packageA to set of task ids [1, 2, 3].
If current_task_id_ is contained in the set, we will consider the event for the
task id.
If not, we will discard it.

[David Tseng, 2017/04/26 15:29:52]

Thanks for verifying.

The window id won't help because it gets created by accessibility for
accessibility.

What we need is to associate the task id with an accessibility event within an
app's context. The origin of the accessibility event (when it gets initially
populated) should perhaps have the task id.
There are several other reasons we need this. Performance is bad in the current
case where we destroy the tree when you switch between apps. There is
significant user delay when you alt-tab to an app and begin interacting. There
is also the issue of retaining user position. If we destroy the tree, ChromeVox
looses position so when you alt-tab back to an app, you end up at the top.
I was hoping to avoid this, but I can live with the above lag when switching
between the same package but different activities.

+}
+
+void ArcAccessibilityHelperBridge::OnTaskDestroyed(int task_id) {
+  auto it = task_id_to_tree_.find(task_id);
+  if (it != task_id_to_tree_.end()) {
+    delete it->second;
+    task_id_to_tree_.erase(it);
+  }
+}
+
+void ArcAccessibilityHelperBridge::OnTaskSetActive(int32_t task_id) {
+  current_task_id_ = task_id;
+}
+
 }  // namespace arc