Tracking push events for lucid sleep

extensions/browser/event_router.cc

 // Copyright (c) 2012 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 "extensions/browser/event_router.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 59 matching lines @@
   // 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());
 }
 
+// A global identifier used to distinguish extension events and is
+// incremented every time an event is dispatched.
+int g_extension_message_id = 0;
+
 }  // namespace
 
 const char EventRouter::kRegisteredEvents[] = "events";
 
+EventRouter::DispatchDetails::DispatchDetails(const std::string& extension_id,
+                                              const std::string& event_name,
+                                              int message_id)
+    : extension_id_(extension_id),
+      event_name_(event_name),
+      message_id_(message_id) {
+}
+
+EventRouter::DispatchDetails::~DispatchDetails() {
+}
+
 struct EventRouter::ListenerProcess {
   content::RenderProcessHost* process;
   std::string extension_id;
 
   ListenerProcess(content::RenderProcessHost* process,
                   const std::string& extension_id)
       : process(process), extension_id(extension_id) {}
 
   bool operator<(const ListenerProcess& that) const {
     if (process < that.process)
@@ skipping 10 matching lines @@
                                            const std::string& extension_id,
                                            const std::string& event_name,
                                            ListValue* event_args,
                                            UserGestureState user_gesture,
                                            const EventFilteringInfo& info) {
   NotifyApiEventDispatched(browser_context_id,
                            extension_id,
                            event_name,
                            make_scoped_ptr(event_args->DeepCopy()));
 
+  int message_id = g_extension_message_id++;
   ListValue args;
   args.Set(0, new base::StringValue(event_name));
   args.Set(1, event_args);
   args.Set(2, info.AsValue().release());
+  args.Set(3, new base::FundamentalValue(message_id));
   ipc_sender->Send(new ExtensionMsg_MessageInvoke(
       MSG_ROUTING_CONTROL,
       extension_id,
       kEventBindings,
       "dispatchEvent",
       args,
       user_gesture == USER_GESTURE_ENABLED));
 
+  DispatchDetails details(extension_id, event_name, message_id);
+  content::NotificationService::current()->Notify(

[Ken Rockot(use gerrit already), 2015/01/08 01:24:02]

This function runs on the IO thread, but NotificationService lives on the UI
thread.

[Ken Rockot(use gerrit already), 2015/01/08 01:25:58]

I realize my pronoun may be ambiguous here. What I mean is that
DispatchExtensionMessage runs on the IO thread. You'll have to hop to UI if you
want to touch NotificationService.

+      NOTIFICATION_EXTENSION_MESSAGE_DISPATCHED,
+      content::Source<content::BrowserContext>(
+          static_cast<content::BrowserContext*>(browser_context_id)),
+      content::Details<EventRouter::DispatchDetails>(&details));
+
   // DispatchExtensionMessage does _not_ take ownership of event_args, so we
   // must ensure that the destruction of args does not attempt to free it.
   scoped_ptr<base::Value> removed_event_args;
   args.Remove(1, &removed_event_args);
   ignore_result(removed_event_args.release());
 }
 
 // static
 EventRouter* EventRouter::Get(content::BrowserContext* browser_context) {
   return ExtensionSystem::Get(browser_context)->event_router();
@@ skipping 682 matching lines @@
                                      const std::string& extension_id,
                                      const GURL& listener_url,
                                      content::BrowserContext* browser_context)
     : event_name(event_name),
       extension_id(extension_id),
       listener_url(listener_url),
       browser_context(browser_context) {
 }
 
 }  // namespace extensions