Dispatch automation events to the last used profile.

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 82 matching lines @@
   }
 
   AutomationInternalCustomBindings* owner_;
   bool removed_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(AutomationMessageFilter);
 };
 
 AutomationInternalCustomBindings::AutomationInternalCustomBindings(
-    ScriptContext* context) : ObjectBackedNativeHandler(context) {
+    ScriptContext* context)
+    : ObjectBackedNativeHandler(context),
+      is_active_profile_(true) {
   // 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);
@@ skipping 397 matching lines @@
     const std::string& str) {
   return v8::String::NewFromUtf8(
       GetIsolate(), str.c_str(), v8::String::kNormalString, str.length());
 }
 
 //
 // Handle accessibility events from the browser process.
 //
 
 void AutomationInternalCustomBindings::OnAccessibilityEvent(
-    const ExtensionMsg_AccessibilityEventParams& params) {
+    const ExtensionMsg_AccessibilityEventParams& params,
+    bool is_active_profile) {
+  is_active_profile_ = is_active_profile;
   int tree_id = params.tree_id;
   TreeCache* cache;
   auto iter = tree_id_to_tree_cache_map_.find(tree_id);
   if (iter == tree_id_to_tree_cache_map_.end()) {
     cache = new TreeCache();
     cache->tab_id = -1;
     cache->tree_id = params.tree_id;
     cache->tree.SetDelegate(this);
     tree_id_to_tree_cache_map_.insert(std::make_pair(tree_id, cache));
     axtree_to_tree_cache_map_.insert(std::make_pair(&cache->tree, cache));
   } else {
     cache = iter->second;
   }
 
+  // Update the internal state whether it's the active profile or not.
   cache->location_offset = params.location_offset;
   if (!cache->tree.Unserialize(params.update)) {
     LOG(ERROR) << cache->tree.error();
     return;
   }
 
+  // Don't send the event if it's not the active profile.
+  if (!is_active_profile)
+    return;
+
   v8::HandleScope handle_scope(GetIsolate());
   v8::Context::Scope context_scope(context()->v8_context());
   v8::Local<v8::Array> args(v8::Array::New(GetIsolate(), 1U));
   v8::Local<v8::Object> event_params(v8::Object::New(GetIsolate()));
   event_params->Set(CreateV8String("treeID"),
                     v8::Integer::New(GetIsolate(), params.tree_id));
   event_params->Set(CreateV8String("targetID"),
                     v8::Integer::New(GetIsolate(), params.id));
   event_params->Set(CreateV8String("eventType"),
                     CreateV8String(ToString(params.event_type)));
@@ skipping 57 matching lines @@
             tree, node);
         break;
     }
   }
 }
 
 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;
+
   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::HandleScope handle_scope(GetIsolate());
   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(ToString(change_type)));
   context()->DispatchEvent("automationInternal.onTreeChange", args);
 }
 
 }  // namespace extensions