#include "base/values.h"
#include "chrome/browser/chrome_notification_types.h"
#include "chrome/browser/extensions/extension_host.h"
-#include "chrome/browser/extensions/extension_system.h"
-#include "chrome/browser/extensions/extension_util.h"
#include "chrome/common/extensions/extension_messages.h"
#include "content/public/browser/notification_service.h"
#include "content/public/browser/render_process_host.h"
+#include "extensions/browser/api_activity_monitor.h"
#include "extensions/browser/extension_prefs.h"
#include "extensions/browser/extension_registry.h"
+#include "extensions/browser/extension_system.h"
#include "extensions/browser/extensions_browser_client.h"
#include "extensions/browser/lazy_background_task_queue.h"
#include "extensions/browser/process_manager.h"
// registered from its lazy background page.
const char kFilteredEvents[] = "filtered_events";
+// Sends a notification about an event to the API activity monitor on the
+// UI thread. Can be called from any thread.
+void NotifyApiEventDispatched(void* browser_context_id,
+ const std::string& extension_id,
+ const std::string& event_name,
+ scoped_ptr<ListValue> args) {
+ // The ApiActivityMonitor can only be accessed from the UI thread.
+ if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+ BrowserThread::PostTask(
+ BrowserThread::UI,
+ FROM_HERE,
+ base::Bind(&NotifyApiEventDispatched,
+ browser_context_id,
+ extension_id,
+ event_name,
+ base::Passed(&args)));
+ return;
+ }
+
+ // Notify the ApiActivityMonitor about the event dispatch.
+ BrowserContext* context = static_cast<BrowserContext*>(browser_context_id);
+ if (!ExtensionsBrowserClient::Get()->IsValidContext(context))
+ return;
+ ApiActivityMonitor* monitor =
+ ExtensionsBrowserClient::Get()->GetApiActivityMonitor(context);
+ if (monitor)
+ monitor->OnApiEventDispatched(extension_id, event_name, args.Pass());
+}
+
} // namespace
const char EventRouter::kRegisteredEvents[] = "events";
};
// static
-void EventRouter::NotifyExtensionDispatchObserverOnUIThread(
- void* browser_context_id,
- scoped_ptr<EventDispatchInfo> details) {
- if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
- BrowserThread::PostTask(
- BrowserThread::UI,
- FROM_HERE,
- base::Bind(&NotifyExtensionDispatchObserverOnUIThread,
- browser_context_id, base::Passed(&details)));
- } else {
- BrowserContext* context =
- reinterpret_cast<BrowserContext*>(browser_context_id);
- if (!ExtensionsBrowserClient::Get()->IsValidContext(context))
- return;
- ExtensionSystem* extension_system =
- ExtensionSystem::GetForBrowserContext(context);
- EventRouter* event_router = extension_system->event_router();
- if (!event_router)
- return;
- if (event_router->event_dispatch_observer_) {
- event_router->event_dispatch_observer_->OnWillDispatchEvent(
- details.Pass());
- }
- }
-}
-
-// static
void EventRouter::DispatchExtensionMessage(IPC::Sender* ipc_sender,
void* browser_context_id,
const std::string& extension_id,
ListValue* event_args,
UserGestureState user_gesture,
const EventFilteringInfo& info) {
- NotifyExtensionDispatchObserverOnUIThread(
- browser_context_id,
- make_scoped_ptr(new EventDispatchInfo(
- extension_id,
- event_name,
- make_scoped_ptr(event_args->DeepCopy()))));
+ NotifyApiEventDispatched(browser_context_id,
+ extension_id,
+ event_name,
+ make_scoped_ptr(event_args->DeepCopy()));
ListValue args;
args.Set(0, new base::StringValue(event_name));
ExtensionPrefs* extension_prefs)
: browser_context_(browser_context),
extension_prefs_(extension_prefs),
- listeners_(this),
- event_dispatch_observer_(NULL) {
+ listeners_(this) {
registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
content::NotificationService::AllSources());
registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
observers_.erase(iters_to_remove[i]);
}
-void EventRouter::SetEventDispatchObserver(EventDispatchObserver* observer) {
- CHECK(!event_dispatch_observer_);
- event_dispatch_observer_ = observer;
-}
-
void EventRouter::OnListenerAdded(const EventListener* listener) {
const EventListenerInfo details(
listener->event_name,
context != event->restrict_to_browser_context;
if (!cross_incognito)
return true;
- return util::CanCrossIncognito(extension, context);
+ return ExtensionsBrowserClient::Get()->CanExtensionCrossIncognito(
+ extension, context);
}
bool EventRouter::MaybeLoadLazyBackgroundPageToDispatchEvent(
if (extension->is_ephemeral() && !event->can_load_ephemeral_apps) {
// Most events can only be dispatched to ephemeral apps that are already
// running.
- ProcessManager* pm =
- ExtensionSystem::GetForBrowserContext(context)->process_manager();
+ ProcessManager* pm = ExtensionSystem::Get(context)->process_manager();
if (!pm->GetBackgroundHostForExtension(extension->id()))
return false;
}
if (!CanDispatchEventToBrowserContext(context, extension, event))
return false;
- LazyBackgroundTaskQueue* queue = ExtensionSystem::GetForBrowserContext(
+ LazyBackgroundTaskQueue* queue = ExtensionSystem::Get(
context)->lazy_background_task_queue();
if (queue->ShouldEnqueueTask(context, extension)) {
linked_ptr<Event> dispatched_event(event);
reinterpret_cast<BrowserContext*>(browser_context_id);
if (!ExtensionsBrowserClient::Get()->IsValidContext(browser_context))
return;
- ExtensionSystem* extension_system =
- ExtensionSystem::GetForBrowserContext(browser_context);
+ ExtensionSystem* extension_system = ExtensionSystem::Get(browser_context);
EventRouter* event_router = extension_system->event_router();
if (!event_router)
return;
// Only increment in-flight events if the lazy background page is active,
// because that's the only time we'll get an ACK.
if (BackgroundInfo::HasLazyBackgroundPage(extension)) {
- ProcessManager* pm =
- ExtensionSystem::GetForBrowserContext(context)->process_manager();
+ ProcessManager* pm = ExtensionSystem::Get(context)->process_manager();
ExtensionHost* host = pm->GetBackgroundHostForExtension(extension->id());
if (host)
pm->IncrementLazyKeepaliveCount(extension);
void EventRouter::OnEventAck(BrowserContext* context,
const std::string& extension_id) {
- ProcessManager* pm =
- ExtensionSystem::GetForBrowserContext(context)->process_manager();
+ ProcessManager* pm = ExtensionSystem::Get(context)->process_manager();
ExtensionHost* host = pm->GetBackgroundHostForExtension(extension_id);
// The event ACK is routed to the background host, so this should never be
// NULL.
const Extension* extension =
content::Details<const Extension>(details).ptr();
if (BackgroundInfo::HasLazyBackgroundPage(extension)) {
- LazyBackgroundTaskQueue* queue = ExtensionSystem::GetForBrowserContext(
+ LazyBackgroundTaskQueue* queue = ExtensionSystem::Get(
browser_context_)->lazy_background_task_queue();
queue->AddPendingTask(browser_context_, extension->id(),
base::Bind(&DoNothing));
extension_id(extension_id),
browser_context(browser_context) {}
-EventDispatchInfo::EventDispatchInfo(const std::string& extension_id,
- const std::string& event_name,
- scoped_ptr<ListValue> event_args)
- : extension_id(extension_id),
- event_name(event_name),
- event_args(event_args.Pass()) {}
-
-EventDispatchInfo::~EventDispatchInfo() {}
-
} // namespace extensions
projects / platform / framework / web / crosswalk.git / blobdiff