chrome/browser/extensions/event_router_forwarder.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/extensions/event_router_forwarder.h"
   6
   7 #include "base/bind.h"
   8 #include "base/values.h"
   9 #include "chrome/browser/browser_process.h"
  10 #include "chrome/browser/profiles/profile_manager.h"
  11 #include "content/public/browser/browser_thread.h"
  12 #include "extensions/browser/event_router.h"
  13 #include "url/gurl.h"
  14
  15 using content::BrowserThread;
  16
  17 namespace extensions {
  18
  19 EventRouterForwarder::EventRouterForwarder() {
  20 }
  21
  22 EventRouterForwarder::~EventRouterForwarder() {
  23 }
  24
  25 void EventRouterForwarder::BroadcastEventToRenderers(
  26     const std::string& event_name,
  27     scoped_ptr<base::ListValue> event_args,
  28     const GURL& event_url) {
  29   HandleEvent(std::string(), event_name, event_args.Pass(), 0, true, event_url);
  30 }
  31
  32 void EventRouterForwarder::DispatchEventToRenderers(
  33     const std::string& event_name,
  34     scoped_ptr<base::ListValue> event_args,
  35     void* profile,
  36     bool use_profile_to_restrict_events,
  37     const GURL& event_url) {
  38   if (!profile)
  39     return;
  40   HandleEvent(std::string(),
  41               event_name,
  42               event_args.Pass(),
  43               profile,
  44               use_profile_to_restrict_events,
  45               event_url);
  46 }
  47
  48 void EventRouterForwarder::BroadcastEventToExtension(
  49     const std::string& extension_id,
  50     const std::string& event_name,
  51     scoped_ptr<base::ListValue> event_args,
  52     const GURL& event_url) {
  53   HandleEvent(extension_id, event_name, event_args.Pass(), 0, true, event_url);
  54 }
  55
  56 void EventRouterForwarder::DispatchEventToExtension(
  57     const std::string& extension_id,
  58     const std::string& event_name,
  59     scoped_ptr<base::ListValue> event_args,
  60     void* profile,
  61     bool use_profile_to_restrict_events,
  62     const GURL& event_url) {
  63   if (!profile)
  64     return;
  65   HandleEvent(extension_id, event_name, event_args.Pass(), profile,
  66               use_profile_to_restrict_events, event_url);
  67 }
  68
  69 void EventRouterForwarder::HandleEvent(const std::string& extension_id,
  70                                        const std::string& event_name,
  71                                        scoped_ptr<base::ListValue> event_args,
  72                                        void* profile_ptr,
  73                                        bool use_profile_to_restrict_events,
  74                                        const GURL& event_url) {
  75   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
  76     BrowserThread::PostTask(
  77         BrowserThread::UI, FROM_HERE,
  78         base::Bind(&EventRouterForwarder::HandleEvent, this,
  79                    extension_id, event_name, base::Passed(&event_args),
  80                    profile_ptr, use_profile_to_restrict_events, event_url));
  81     return;
  82   }
  83
  84   if (!g_browser_process || !g_browser_process->profile_manager())
  85     return;
  86
  87   ProfileManager* profile_manager = g_browser_process->profile_manager();
  88   Profile* profile = NULL;
  89   if (profile_ptr) {
  90     profile = reinterpret_cast<Profile*>(profile_ptr);
  91     if (!profile_manager->IsValidProfile(profile))
  92       return;
  93   }
  94   if (profile) {
  95     CallEventRouter(profile, extension_id, event_name, event_args.Pass(),
  96                     use_profile_to_restrict_events ? profile : NULL, event_url);
  97   } else {
  98     std::vector<Profile*> profiles(profile_manager->GetLoadedProfiles());
  99     for (size_t i = 0; i < profiles.size(); ++i) {
 100       scoped_ptr<base::ListValue> per_profile_event_args(
 101           event_args->DeepCopy());
 102       CallEventRouter(
 103           profiles[i], extension_id, event_name, per_profile_event_args.Pass(),
 104           use_profile_to_restrict_events ? profiles[i] : NULL, event_url);
 105     }
 106   }
 107 }
 108
 109 void EventRouterForwarder::CallEventRouter(
 110     Profile* profile,
 111     const std::string& extension_id,
 112     const std::string& event_name,
 113     scoped_ptr<base::ListValue> event_args,
 114     Profile* restrict_to_profile,
 115     const GURL& event_url) {
 116 #if defined(OS_CHROMEOS)
 117   // Extension does not exist for chromeos login.  This needs to be
 118   // removed once we have an extension service for login screen.
 119   // crosbug.com/12856.
 120   if (!extensions::EventRouter::Get(profile))
 121     return;
 122 #endif
 123
 124   scoped_ptr<Event> event(new Event(event_name, event_args.Pass()));
 125   event->restrict_to_browser_context = restrict_to_profile;
 126   event->event_url = event_url;
 127   if (extension_id.empty()) {
 128     extensions::EventRouter::Get(profile)->BroadcastEvent(event.Pass());
 129   } else {
 130     extensions::EventRouter::Get(profile)
 131         ->DispatchEventToExtension(extension_id, event.Pass());
 132   }
 133 }
 134
 135 }  // namespace extensions