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"
+#include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
+#include "base/synchronization/lock.h"
 #include "base/values.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_host.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"
@@ skipping 18 matching lines @@
 namespace extensions {
 
 namespace {
 
 void DoNothing(ExtensionHost* host) {}
 
 // A dictionary of event names to lists of filters that this extension has
 // 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) {
+// Sends a notification about an event to the API activity monitor and the
+// ExtensionHost for |extension_id| on the UI thread. Can be called from any
+// thread.
+void NotifyEventDispatched(void* browser_context_id,
+                           const std::string& extension_id,
+                           const std::string& event_name,
+                           int message_id,
+                           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)));
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&NotifyEventDispatched, browser_context_id, extension_id,
+                   event_name, message_id, 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());
+
+  ExtensionHost* host =
+      ProcessManager::Get(context)->GetBackgroundHostForExtension(extension_id);
+  if (host)
+    host->OnMessageDispatched(event_name, message_id);
 }
 
+// A global identifier used to distinguish extension messages that is
+// incremented every time a message is dispatched.
+int g_extension_message_id = 0;
+
+// Protects access to |g_extension_message_id|.
+base::LazyInstance<base::Lock>::Leaky g_message_id_lock =
+    LAZY_INSTANCE_INITIALIZER;
+
 }  // namespace
 
 const char EventRouter::kRegisteredEvents[] = "events";
 
 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)
       return true;
     if (process == that.process && extension_id < that.extension_id)
       return true;
     return false;
   }
 };
 
 // static
 void EventRouter::DispatchExtensionMessage(IPC::Sender* ipc_sender,
                                            void* browser_context_id,
                                            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()));
+  // Since this function can be called from any thread we need to protect access
+  // to |g_extension_message_id|.
+  g_message_id_lock.Get().Acquire();
+  int message_id = g_extension_message_id++;
+  g_message_id_lock.Get().Release();
+
+  NotifyEventDispatched(browser_context_id, extension_id, event_name,
+                        message_id, make_scoped_ptr(event_args->DeepCopy()));
 
   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));
 
   // DispatchExtensionMessage does _not_ take ownership of event_args, so we
   // must ensure that the destruction of args does not attempt to free it.
@@ skipping 690 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