Support output for Chrome's native find in ChromeVox.

chrome/renderer/extensions/automation_internal_custom_bindings.cc

 // Copyright 2014 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/renderer/extensions/automation_internal_custom_bindings.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 399 matching lines @@
   bool removed_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(AutomationMessageFilter);
 };
 
 AutomationInternalCustomBindings::AutomationInternalCustomBindings(
     ScriptContext* context)
     : ObjectBackedNativeHandler(context),
       is_active_profile_(true),
-      tree_change_observer_overall_filter_(
-          api::automation::TREE_CHANGE_OBSERVER_FILTER_NOTREECHANGES) {
+      tree_change_observer_overall_filter_(0) {
   // It's safe to use base::Unretained(this) here because these bindings
   // will only be called on a valid AutomationInternalCustomBindings instance
   // and none of the functions have any side effects.
 #define ROUTE_FUNCTION(FN)                                        \
   RouteFunction(#FN, "automation",                                \
                 base::Bind(&AutomationInternalCustomBindings::FN, \
                            base::Unretained(this)))
   ROUTE_FUNCTION(IsInteractPermitted);
   ROUTE_FUNCTION(GetSchemaAdditions);
   ROUTE_FUNCTION(GetRoutingID);
@@ skipping 348 matching lines @@
   observer.id = args[0]->Int32Value();
   std::string filter_str = *v8::String::Utf8Value(args[1]);
   observer.filter = api::automation::ParseTreeChangeObserverFilter(filter_str);
 
   tree_change_observers_.push_back(observer);
   UpdateOverallTreeChangeObserverFilter();
 }
 
 void AutomationInternalCustomBindings::RemoveTreeChangeObserver(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
-  if (args.Length() != 1 || !args[0]->IsNumber()) {
+  // The argument is an integer key for an object which is automatically
+  // converted to a string.
+  if (args.Length() != 1 || !args[0]->IsString()) {
     ThrowInvalidArgumentsException(this);
     return;
   }
 
   int observer_id = args[0]->Int32Value();
 
   for (auto iter = tree_change_observers_.begin();
        iter != tree_change_observers_.end(); ++iter) {
     if (iter->id == observer_id) {
       tree_change_observers_.erase(iter);
@@ skipping 142 matching lines @@
   }
   if (cache->tree.data().focus_id == node->id()) {
     state->Set(CreateV8String(isolate, "focused"),
                v8::Boolean::New(isolate, true));
   }
 
   args.GetReturnValue().Set(state);
 }
 
 void AutomationInternalCustomBindings::UpdateOverallTreeChangeObserverFilter() {
-  tree_change_observer_overall_filter_ =
-      api::automation::TREE_CHANGE_OBSERVER_FILTER_NOTREECHANGES;
-  for (const auto& observer : tree_change_observers_) {
-    tree_change_observer_overall_filter_ =
-        std::max(observer.filter, tree_change_observer_overall_filter_);
-  }
+  tree_change_observer_overall_filter_ = 0;
+  for (const auto& observer : tree_change_observers_)
+    tree_change_observer_overall_filter_ |= 1 << observer.filter;
 }
 
 ui::AXNode* AutomationInternalCustomBindings::GetParent(
     ui::AXNode* node,
     TreeCache** in_out_cache) {
   if (node->parent())
     return node->parent();
 
   int parent_tree_id = (*in_out_cache)->tree.data().parent_tree_id;
   if (parent_tree_id < 0)
@@ skipping 231 matching lines @@
     ui::AXNode* node) {
   // Don't send tree change events when it's not the active profile.
   if (!is_active_profile_)
     return;
 
   // Always notify the custom bindings when there's a node with a child tree
   // ID that might need to be loaded.
   if (node->data().HasIntAttribute(ui::AX_ATTR_CHILD_TREE_ID))
     SendChildTreeIDEvent(tree, node);
 
-  switch (tree_change_observer_overall_filter_) {
-    case api::automation::TREE_CHANGE_OBSERVER_FILTER_NOTREECHANGES:
-    default:
-      return;
-    case api::automation::TREE_CHANGE_OBSERVER_FILTER_LIVEREGIONTREECHANGES:
-      if (!node->data().HasStringAttribute(ui::AX_ATTR_CONTAINER_LIVE_STATUS) &&
-          node->data().role != ui::AX_ROLE_ALERT) {
-        return;
-      }
-      break;
-    case api::automation::TREE_CHANGE_OBSERVER_FILTER_ALLTREECHANGES:
-      break;
+  bool has_filter = false;
+  if (tree_change_observer_overall_filter_ &
+      (1 <<
+       api::automation::TREE_CHANGE_OBSERVER_FILTER_LIVEREGIONTREECHANGES)) {
+    if (node->data().HasStringAttribute(ui::AX_ATTR_CONTAINER_LIVE_STATUS) ||
+        node->data().role == ui::AX_ROLE_ALERT) {
+      has_filter = true;
+    }
   }
 
+  if (tree_change_observer_overall_filter_ &
+      (1 << api::automation::TREE_CHANGE_OBSERVER_FILTER_TEXTMARKERCHANGES)) {
+    if (node->data().HasIntListAttribute(ui::AX_ATTR_MARKER_TYPES))
+      has_filter = true;
+  }
+
+  if (tree_change_observer_overall_filter_ &
+      (1 << api::automation::TREE_CHANGE_OBSERVER_FILTER_ALLTREECHANGES))
+    has_filter = true;
+
+  if (!has_filter)
+    return;
+
   auto iter = axtree_to_tree_cache_map_.find(tree);
   if (iter == axtree_to_tree_cache_map_.end())
     return;
 
   int tree_id = iter->second->tree_id;
 
   v8::Isolate* isolate = GetIsolate();
   v8::HandleScope handle_scope(isolate);
   v8::Context::Scope context_scope(context()->v8_context());
 
   for (const auto& observer : tree_change_observers_) {
     switch (observer.filter) {
       case api::automation::TREE_CHANGE_OBSERVER_FILTER_NOTREECHANGES:
       default:
         continue;
       case api::automation::TREE_CHANGE_OBSERVER_FILTER_LIVEREGIONTREECHANGES:
         if (!node->data().HasStringAttribute(
                 ui::AX_ATTR_CONTAINER_LIVE_STATUS) &&
             node->data().role != ui::AX_ROLE_ALERT) {
           continue;
         }
         break;
+      case api::automation::TREE_CHANGE_OBSERVER_FILTER_TEXTMARKERCHANGES:
+        if (!node->data().HasIntListAttribute(ui::AX_ATTR_MARKER_TYPES))
+          continue;
+        break;
       case api::automation::TREE_CHANGE_OBSERVER_FILTER_ALLTREECHANGES:
         break;
     }
 
     v8::Local<v8::Array> args(v8::Array::New(GetIsolate(), 4U));
     args->Set(0U, v8::Integer::New(GetIsolate(), observer.id));
     args->Set(1U, v8::Integer::New(GetIsolate(), tree_id));
     args->Set(2U, v8::Integer::New(GetIsolate(), node->id()));
     args->Set(3U, CreateV8String(isolate, ToString(change_type)));
     context()->DispatchEvent("automationInternal.onTreeChange", args);
@@ skipping 32 matching lines @@
   v8::Local<v8::Array> args(v8::Array::New(GetIsolate(), 2U));
   args->Set(0U, v8::Integer::New(GetIsolate(), tree_id));
   v8::Local<v8::Array> nodes(v8::Array::New(GetIsolate(), ids.size()));
   args->Set(1U, nodes);
   for (size_t i = 0; i < ids.size(); ++i)
     nodes->Set(i, v8::Integer::New(GetIsolate(), ids[i]));
   context()->DispatchEvent("automationInternal.onNodesRemoved", args);
 }
 
 }  // namespace extensions