Dispatch automation events to the last used profile.

chrome/browser/extensions/api/automation_internal/automation_event_router.cc

 // Copyright 2015 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/extensions/api/automation_internal/automation_event_router.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "chrome/browser/accessibility/ax_tree_id_registry.h"
+#include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/extensions/api/automation_internal.h"
 #include "chrome/common/extensions/chrome_extension_messages.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "extensions/browser/event_router.h"
 #include "ui/accessibility/ax_enums.h"
 #include "ui/accessibility/ax_node_data.h"
 
 namespace extensions {
 
 // static
 AutomationEventRouter* AutomationEventRouter::GetInstance() {
   return Singleton<AutomationEventRouter,
                    LeakySingletonTraits<AutomationEventRouter>>::get();
 }
 
 AutomationEventRouter::AutomationEventRouter() {
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
                  content::NotificationService::AllBrowserContextsAndSources());
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
                  content::NotificationService::AllBrowserContextsAndSources());
+  active_profile_ = ProfileManager::GetLastUsedProfile();
+
+#if defined(OS_CHROMEOS)
+  session_state_observer_.reset(new ash::ScopedSessionStateObserver(this));
+#endif
 }
 
 AutomationEventRouter::~AutomationEventRouter() {
 }
 
 void AutomationEventRouter::RegisterListenerForOneTree(
+    const ExtensionId& extension_id,
     int listener_process_id,
     int listener_routing_id,
     int source_ax_tree_id) {
-  Register(listener_process_id, listener_routing_id, source_ax_tree_id, false);
+  Register(extension_id,
+           listener_process_id,
+           listener_routing_id,
+           source_ax_tree_id,
+           false);
 }
 
 void AutomationEventRouter::RegisterListenerWithDesktopPermission(
+    const ExtensionId& extension_id,
     int listener_process_id,
     int listener_routing_id) {
-  Register(listener_process_id, listener_routing_id, 0, true);
+  Register(extension_id,
+           listener_process_id,
+           listener_routing_id,
+           0,

[David Tseng, 2015/08/05 22:24:36]

nit: /* desktop tree id */

[dmazzoni, 2015/08/05 22:53:39]

Done.

+           true);
 }
 
 void AutomationEventRouter::DispatchAccessibilityEvent(
     const ExtensionMsg_AccessibilityEventParams& params) {
   for (const auto& listener : listeners_) {
+    // Reject listeners that don't want to listen to this tree.

[David Tseng, 2015/08/05 22:24:36]

nit: Skip?

[dmazzoni, 2015/08/05 22:53:39]

Done.

     if (!listener.desktop &&
         listener.tree_ids.find(params.tree_id) == listener.tree_ids.end()) {
       continue;
     }
 
     content::RenderProcessHost* rph =
         content::RenderProcessHost::FromID(listener.process_id);
     rph->Send(new ExtensionMsg_AccessibilityEvent(listener.routing_id,
-                                                  params));
+                                                  params,
+                                                  listener.is_active_profile));
   }
 }
 
 void AutomationEventRouter::DispatchTreeDestroyedEvent(
     int tree_id,
     content::BrowserContext* browser_context) {
   scoped_ptr<base::ListValue> args(
       api::automation_internal::OnAccessibilityTreeDestroyed::Create(tree_id));
   scoped_ptr<Event> event(new Event(
       events::AUTOMATION_INTERNAL_ON_ACCESSIBILITY_TREE_DESTROYED,
       api::automation_internal::OnAccessibilityTreeDestroyed::kEventName,
       args.Pass()));
   event->restrict_to_browser_context = browser_context;
   EventRouter::Get(browser_context)->BroadcastEvent(event.Pass());
 }
 
 AutomationEventRouter::AutomationListener::AutomationListener() {
 }
 
 AutomationEventRouter::AutomationListener::~AutomationListener() {
 }
 
 void AutomationEventRouter::Register(
+    const ExtensionId& extension_id,
     int listener_process_id,
     int listener_routing_id,
     int ax_tree_id,
     bool desktop) {
   auto iter = std::find_if(
       listeners_.begin(),
       listeners_.end(),
       [listener_process_id, listener_routing_id](
           const AutomationListener& item) {
         return (item.process_id == listener_process_id &&
                 item.routing_id == listener_routing_id);
       });
 
   // Add a new entry if we don't have one with that process and routing id.
   if (iter == listeners_.end()) {
     AutomationListener listener;
+    listener.extension_id = extension_id;
     listener.routing_id = listener_routing_id;
     listener.process_id = listener_process_id;
     listener.desktop = desktop;
     listener.tree_ids.insert(ax_tree_id);
+    listener.is_active_profile = true;

[David Tseng, 2015/08/05 22:24:36]

Does this default make sense?

[dmazzoni, 2015/08/05 22:53:39]

Deleted because we just call UpdateActiveProfile, below.

     listeners_.push_back(listener);
+    UpdateActiveProfile();
     return;
   }
 
   // We have an entry with that process and routing id, so update the set of
   // tree ids it wants to listen to, and update its desktop permission.
   iter->tree_ids.insert(ax_tree_id);
   if (desktop)
     iter->desktop = true;
 }
 
@@ skipping 11 matching lines @@
       content::Source<content::RenderProcessHost>(source).ptr();
   int process_id = rph->GetID();
   listeners_.erase(
       std::remove_if(
           listeners_.begin(),
           listeners_.end(),
           [process_id](const AutomationListener& item) {
             return item.process_id == process_id;
           }),
       listeners_.end());
+  UpdateActiveProfile();
+}
+
+void AutomationEventRouter::ActiveUserChanged(const std::string& user_id) {
+  active_profile_ = ProfileManager::GetLastUsedProfile();
+  UpdateActiveProfile();
+}
+
+void AutomationEventRouter::UpdateActiveProfile() {
+  for (auto& listener : listeners_) {
+#if defined(OS_CHROMEOS)

[David Tseng, 2015/08/05 22:24:36]

Can this be USE_ASH instead?

[dmazzoni, 2015/08/05 22:53:39]

No, because that'd be true on Windows, which uses ash for metro mode.

From an include-file perspective, we want Ash, from from a semantics/behavior
perspective, we want Chrome OS, which implies we have Ash available.

+    int extension_id_count = 0;
+    for (auto listener2 : listeners_) {
+      if (listener2.extension_id == listener.extension_id)
+        extension_id_count++;
+    }
+    content::RenderProcessHost* rph =
+        content::RenderProcessHost::FromID(listener.process_id);
+    listener.is_active_profile = (extension_id_count == 1 ||

[David Tseng, 2015/08/05 22:24:36]

Does this condition make sense? If I understand correctly, whenever an extension
is only loaded into one profile, it is considered active even if the profile
isn't currently active?

[dmazzoni, 2015/08/05 22:53:39]

Yes, that's intentional. The idea is only to prevent multiple copies of the
extension in different profiles from interfering with each other.

I added a comment to clarify.

+                                  rph->GetBrowserContext() == active_profile_);
+#else
+    listener.is_active_profile = true;
+#endif
+  }
 }
 
 }  // namespace extensions