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);
-};
+constexpr int32_t kNoTaskId = -1;
 
 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 kNoTaskId;
+
+  int32_t task_id = kNoTaskId;
+  if (sscanf(arc_app_id.c_str(), "org.chromium.arc.%d", &task_id) != 1)
+    return kNoTaskId;
+
+  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 =

[hidehiko, 2017/05/01 05:15:27]

nit: please move this to just before L72 (please Get the instance just before
using it). (Sorry, I overlooked this in the last iteration).

+      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_(kNoTaskId) {
   arc_bridge_service()->accessibility_helper()->AddObserver(this);
 }
 
 ArcAccessibilityHelperBridge::~ArcAccessibilityHelperBridge() {
   arc_bridge_service()->accessibility_helper()->RemoveObserver(this);

[Luis Héctor Chávez, 2017/04/28 21:59:44]

nit: try to perform actions in the destructor in reverse order in which they are
preform; this should go last, and
exo::WMHelper::GetInstance()->RemoveActivationObserver(this); should go first.

[David Tseng, 2017/05/05 19:59:21]

Done.

+  ArcAppListPrefs::Get(chromeos::AccessibilityManager::Get()->profile())
+      ->RemoveObserver(this);
+  exo::WMHelper::GetInstance()->RemoveActivationObserver(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() == 0)
+      return;
+
+    arc::mojom::AccessibilityNodeInfoData* node = event_data->nodeData[0].get();
+    if (!node->stringProperties)
+      return;
+
+    auto package_it = node->stringProperties->find(
+        arc::mojom::AccessibilityStringProperty::PACKAGE_NAME);
+    if (package_it == node->stringProperties->end())
+      return;
+
+    auto task_ids_it = package_name_to_task_ids_.find(package_it->second);
+    if (task_ids_it == package_name_to_task_ids_.end())
+      return;
+
+    const auto& task_ids = task_ids_it->second;
+
+    // Reject updates to non-current task ids. We can do this currently
+    // because all events include the entire tree.
+    if (task_ids.count(current_task_id_) == 0)
+      return;
+
+    auto tree_it = package_name_to_tree_.find(package_it->second);
+    AXTreeSourceArc* tree_source;
+    if (tree_it == package_name_to_tree_.end()) {
+      package_name_to_tree_[package_it->second].reset(
+          new AXTreeSourceArc(this));
+      tree_source = package_name_to_tree_[package_it->second].get();
+    } else {
+      tree_source = tree_it->second.get();
+    }
+    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) const {
   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);
+  std::string package_name;
+  for (const auto& task_ids_entry : package_name_to_task_ids_) {
+    if (task_ids_entry.second.count(task_id) != 0) {
+      package_name = task_ids_entry.first;
+      break;
+    }
+  }
+
+  if (package_name.empty())
+    return;
+
+  auto it = package_name_to_tree_.find(package_name);
+  if (it != package_name_to_tree_.end())
+    it->second->Focus(gained_active);
+}
+
+void ArcAccessibilityHelperBridge::OnTaskCreated(
+    int32_t task_id,
+    const std::string& package_name,
+    const std::string& activity,
+    const std::string& intent) {
+  package_name_to_task_ids_[package_name].insert(task_id);
+}
+
+void ArcAccessibilityHelperBridge::OnTaskDestroyed(int task_id) {
+  std::string package_name;
+  bool should_delete_tree_source = false;
+  for (auto& task_ids_entry : package_name_to_task_ids_) {
+    if (task_ids_entry.second.count(task_id)) {
+      package_name = task_ids_entry.first;
+      task_ids_entry.second.erase(task_id);
+
+      if (task_ids_entry.second.size() == 0) {

[hidehiko, 2017/05/01 05:15:27]

IIUC;

for (auto& task_ids_entry : ...) {
  if (task_ids_entry.second.erase(task_id) > 0) {
    if (task_ids_entry.second.empty()) {
      package_name_to_tree_.erase(task_ids_entry.first);
      package_name_to_task_ids_.erase(task_ids_entry.first);
    }
    break;
  }
}

is probably simpler way.

Note:
map::erase() returns the number of deleted elements, so you can check it here.
package_name_to_tree_.erase() needs to be called before
package_name_to_task_ids_.erase(), otherwise task_ids_entry can be invalidated
first.
To check the emptiness of a collection, I recommend to use empty(), rather than
size() == 0, for consistency.

[David Tseng, 2017/05/05 19:59:21]

Yes, this is cleaner, but is it advisible to call erase on *all* of the value
sets simply to get the code to look cleaner?> 
Ok, I changed it to the above.
Thanks for pointing this out.
Acknowledged for the above (this wasn't an issue previously).

[hidehiko, 2017/05/08 06:13:11]

IMHO, here what is needed is removing "all" task_id from values (sets) in
|package_name_to_task_ids_|.
So, trying to erase() from all sets sounds reasonable (again IMHO).
If a set gets empty, then it is necessary to remove the corresponding
package_name's info from both package_name_to_tree_ and
package_name_to_task_ids_ maps. That's my understanding, and why I recommend to
do it.

it looks ok to leave it as is to me, or adding brief comment about map::erase()
works for me, too, if you'd like.

+        package_name_to_task_ids_.erase(task_ids_entry.first);
+        should_delete_tree_source = true;
+      }
+
+      break;
+    }
+  }
+
+  if (package_name.empty() || !should_delete_tree_source)
+    return;
+
+  auto it = package_name_to_tree_.find(package_name);
+  if (it != package_name_to_tree_.end())
+    package_name_to_tree_.erase(it);
+}
+
+void ArcAccessibilityHelperBridge::OnTaskSetActive(int32_t task_id) {
+  current_task_id_ = task_id;
+}
+
 }  // namespace arc