Complete live region support in ChromeVox Next.

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 "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
@@ skipping 375 matching lines @@
 
   AutomationInternalCustomBindings* owner_;
   bool removed_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(AutomationMessageFilter);
 };
 
 AutomationInternalCustomBindings::AutomationInternalCustomBindings(
     ScriptContext* context)
-    : ObjectBackedNativeHandler(context), is_active_profile_(true) {
+    : ObjectBackedNativeHandler(context),
+      is_active_profile_(true),
+      tree_change_observer_mask_(
+          api::automation::TREE_CHANGE_OBSERVER_MASK_NOTREECHANGES) {
   // 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, \
                 base::Bind(&AutomationInternalCustomBindings::FN, \
                 base::Unretained(this)))
   ROUTE_FUNCTION(IsInteractPermitted);
   ROUTE_FUNCTION(GetSchemaAdditions);
   ROUTE_FUNCTION(GetRoutingID);
   ROUTE_FUNCTION(StartCachingAccessibilityTrees);
   ROUTE_FUNCTION(DestroyAccessibilityTree);
+  ROUTE_FUNCTION(SetTreeChangeObserverMask);
   ROUTE_FUNCTION(GetChildIDAtIndex);
   #undef ROUTE_FUNCTION
 
   // Bindings that take a Tree ID and return a property of the tree.
 
   RouteTreeIDFunction(
       "GetRootID", [](v8::Isolate* isolate, v8::ReturnValue<v8::Value> result,
                       TreeCache* cache) {
         result.Set(v8::Integer::New(isolate, cache->tree.root()->id()));
       });
@@ skipping 306 matching lines @@
   auto iter = tree_id_to_tree_cache_map_.find(tree_id);
   if (iter == tree_id_to_tree_cache_map_.end())
     return;
 
   TreeCache* cache = iter->second;
   tree_id_to_tree_cache_map_.erase(tree_id);
   axtree_to_tree_cache_map_.erase(&cache->tree);
   delete cache;
 }
 
+void AutomationInternalCustomBindings::SetTreeChangeObserverMask(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  if (args.Length() != 1 || !args[0]->IsString()) {
+    ThrowInvalidArgumentsException(this);
+    return;
+  }
+
+  std::string mask_str = *v8::String::Utf8Value(args[0]);
+  tree_change_observer_mask_ =
+      api::automation::ParseTreeChangeObserverMask(mask_str);
+}
+
 void AutomationInternalCustomBindings::RouteTreeIDFunction(
     const std::string& name,
     TreeIDFunction callback) {
   scoped_refptr<TreeIDWrapper> wrapper = new TreeIDWrapper(this, callback);
   RouteFunction(name, base::Bind(&TreeIDWrapper::Run, wrapper));
 }
 
 void AutomationInternalCustomBindings::RouteNodeIDFunction(
     const std::string& name,
     NodeIDFunction callback) {
@@ skipping 157 matching lines @@
 }
 
 void AutomationInternalCustomBindings::SendTreeChangeEvent(
     api::automation::TreeChangeType change_type,
     ui::AXTree* tree,
     ui::AXNode* node) {
   // Don't send tree change events when it's not the active profile.
   if (!is_active_profile_)
     return;
 
+  if (node->data().role != ui::AX_ROLE_EMBEDDED_OBJECT &&
+      node->data().role != ui::AX_ROLE_WEB_VIEW) {
+    switch (tree_change_observer_mask_) {
+      case api::automation::TREE_CHANGE_OBSERVER_MASK_NOTREECHANGES:
+      default:
+        return;
+      case api::automation::TREE_CHANGE_OBSERVER_MASK_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_MASK_ALLTREECHANGES:
+        break;
+    }
+  }
+
   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());
   v8::Local<v8::Array> args(v8::Array::New(GetIsolate(), 3U));
   args->Set(0U, v8::Integer::New(GetIsolate(), tree_id));
   args->Set(1U, v8::Integer::New(GetIsolate(), node->id()));
   args->Set(2U, CreateV8String(isolate, ToString(change_type)));
   context()->DispatchEvent("automationInternal.onTreeChange", args);
 }
 
 }  // namespace extensions