Refactor extension event distribution to use Values instead of JSON strings.

chrome/browser/extensions/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 "chrome/browser/extensions/event_router.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/values.h"
@@ skipping 16 matching lines @@
 #include "chrome/common/extensions/api/extension_api.h"
 #include "chrome/common/view_type.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 
 using base::Value;
 using content::BrowserThread;
 
 namespace {
 
-const char kDispatchEvent[] = "Event.dispatchJSON";
+const char kDispatchEvent[] = "Event.dispatchEvent";
 
 void NotifyEventListenerRemovedOnIOThread(
     void* profile,
     const std::string& extension_id,
     const std::string& sub_event_name) {
   ExtensionWebRequestEventRouter::GetInstance()->RemoveEventListener(
       profile, extension_id, sub_event_name);
 }
 
 }  // namespace
@@ skipping 11 matching lines @@
   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::DispatchEvent(IPC::Sender* ipc_sender,
-                                const std::string& extension_id,
-                                const std::string& event_name,
-                                const Value& event_args,
-                                const GURL& event_url,
-                                UserGestureState user_gesture,
-                                const EventFilteringInfo& info) {
-  // TODO(gdk): Reduce number of DeepCopy() calls throughout the event dispatch
-  // chain, starting by replacing the event_args with a Value*.
+void EventRouter::DispatchExtensionMessage(IPC::Sender* ipc_sender,
+                                           const std::string& extension_id,
+                                           const std::string& event_name,
+                                           ListValue* event_args,
+                                           const GURL& event_url,
+                                           UserGestureState user_gesture,
+                                           const EventFilteringInfo& info) {
   ListValue args;
   args.Set(0, Value::CreateStringValue(event_name));
-  args.Set(1, event_args.DeepCopy());
+  args.Set(1, event_args);
   args.Set(2, info.AsValue().release());
-
   ipc_sender->Send(new ExtensionMsg_MessageInvoke(MSG_ROUTING_CONTROL,
       extension_id, kDispatchEvent, args, event_url,
       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.
+  Value* removed_event_args = NULL;
+  args.Remove(1, &removed_event_args);
 }
 
 // static
 void EventRouter::DispatchEvent(IPC::Sender* ipc_sender,
                                 const std::string& extension_id,
                                 const std::string& event_name,
-                                const std::string& event_args,
+                                scoped_ptr<ListValue> event_args,
                                 const GURL& event_url,
                                 UserGestureState user_gesture,
                                 const EventFilteringInfo& info) {
-  scoped_ptr<Value> event_args_value(Value::CreateStringValue(event_args));
-  DispatchEvent(ipc_sender, extension_id, event_name, *event_args_value.get(),
-                event_url, user_gesture, info);
+  DispatchExtensionMessage(ipc_sender, extension_id, event_name,
+                           event_args.get(), event_url, user_gesture, info);
 }
 
 EventRouter::EventRouter(Profile* profile)
     : profile_(profile),
       extension_devtools_manager_(
           ExtensionSystem::Get(profile)->devtools_manager()),
       listeners_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
                  content::NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
@@ skipping 164 matching lines @@
 
   for (std::set<ListenerProcess>::const_iterator listener = listeners.begin();
        listener != listeners.end(); ++listener) {
     if (listener->extension_id == extension_id)
       return true;
   }
   return false;
 }
 
 void EventRouter::DispatchEventToRenderers(const std::string& event_name,
-                                           const std::string& event_args,
+                                           scoped_ptr<ListValue> event_args,
                                            Profile* restrict_to_profile,
                                            const GURL& event_url,
                                            EventFilteringInfo info) {
-  DCHECK(!event_args.empty());
-  StringValue event_args_value(event_args);
-  linked_ptr<Event> event(new Event(event_name, event_args_value,
+  linked_ptr<Event> event(new Event(event_name, event_args.Pass(),
                                     event_url, restrict_to_profile,
                                     USER_GESTURE_UNKNOWN, info));
   DispatchEventImpl("", event);
 }
 
 void EventRouter::DispatchEventToRenderers(const std::string& event_name,
-                                           const std::string& event_args,
+                                           scoped_ptr<ListValue> event_args,
                                            Profile* restrict_to_profile,
                                            const GURL& event_url) {
-  DispatchEventToRenderers(event_name, event_args, restrict_to_profile,
+  DispatchEventToRenderers(event_name, event_args.Pass(), restrict_to_profile,
                            event_url, EventFilteringInfo());
 }
 
 void EventRouter::DispatchEventToRenderers(const std::string& event_name,
-                                           const std::string& event_args,
+                                           scoped_ptr<ListValue> event_args,
                                            Profile* restrict_to_profile,
                                            const GURL& event_url,
                                            UserGestureState user_gesture) {
-  DCHECK(!event_args.empty());
-  StringValue event_args_value(event_args);
   EventFilteringInfo info;
-  linked_ptr<Event> event(new Event(event_name, event_args_value,
+  linked_ptr<Event> event(new Event(event_name, event_args.Pass(),
                                     event_url, restrict_to_profile,
                                     user_gesture, info));
   DispatchEventImpl("", event);
 }
 
 void EventRouter::DispatchEventToExtension(const std::string& extension_id,
                                            const std::string& event_name,
-                                           const Value& event_args,
+                                           scoped_ptr<ListValue> event_args,
                                            Profile* restrict_to_profile,
                                            const GURL& event_url) {
   DCHECK(!extension_id.empty());
-  linked_ptr<Event> event(new Event(event_name, event_args, event_url,
+  linked_ptr<Event> event(new Event(event_name, event_args.Pass(), event_url,
                                     restrict_to_profile, USER_GESTURE_UNKNOWN,
                                     EventFilteringInfo()));
   DispatchEventImpl(extension_id, event);
 }
 
 void EventRouter::DispatchEventToExtension(const std::string& extension_id,
                                            const std::string& event_name,
-                                           const std::string& event_args,
-                                           Profile* restrict_to_profile,
-                                           const GURL& event_url) {
-  StringValue event_args_value(event_args);
-  DispatchEventToExtension(extension_id, event_name, event_args_value,
-                           restrict_to_profile, event_url);
-}
-
-void EventRouter::DispatchEventToExtension(const std::string& extension_id,
-                                           const std::string& event_name,
-                                           const std::string& event_args,
+                                           scoped_ptr<ListValue> event_args,
                                            Profile* restrict_to_profile,
                                            const GURL& event_url,
                                            UserGestureState user_gesture) {
   DCHECK(!extension_id.empty());
-  StringValue event_args_value(event_args);
-  linked_ptr<Event> event(new Event(event_name, event_args_value, event_url,
+  linked_ptr<Event> event(new Event(event_name, event_args.Pass(), event_url,
                                     restrict_to_profile, user_gesture,
                                     EventFilteringInfo()));
   DispatchEventImpl(extension_id, event);
 }
 
 void EventRouter::DispatchEventsToRenderersAcrossIncognito(
     const std::string& event_name,
-    const std::string& event_args,
+    scoped_ptr<ListValue> event_args,
     Profile* restrict_to_profile,
-    const std::string& cross_incognito_args,
+    scoped_ptr<ListValue> cross_incognito_args,
     const GURL& event_url) {
-  linked_ptr<Event> event(new Event(event_name, event_args,
-                                    event_url, restrict_to_profile,
-                                    cross_incognito_args, USER_GESTURE_UNKNOWN,
+  linked_ptr<Event> event(new Event(event_name, event_args.Pass(), event_url,
+                                    restrict_to_profile,
+                                    cross_incognito_args.Pass(),
+                                    USER_GESTURE_UNKNOWN,
                                     EventFilteringInfo()));
   DispatchEventImpl("", event);
 }
 
 void EventRouter::DispatchEventImpl(const std::string& restrict_to_extension_id,
                                     const linked_ptr<Event>& event) {
   // We don't expect to get events from a completely different profile.
   DCHECK(!event->restrict_to_profile ||
          profile_->IsSameProfile(event->restrict_to_profile));
 
@@ skipping 61 matching lines @@
       process->GetBrowserContext());
   ProcessMap* process_map =
       listener_profile->GetExtensionService()->process_map();
   // If the event is privileged, only send to extension processes. Otherwise,
   // it's OK to send to normal renderers (e.g., for content scripts).
   if (ExtensionAPI::GetSharedInstance()->IsPrivileged(event->event_name) &&
       !process_map->Contains(extension->id(), process->GetID())) {
     return;
   }
 
-  const Value* event_args = NULL;
+  ListValue* event_args = NULL;
   if (!CanDispatchEventToProfile(listener_profile, extension,
                                  event, &event_args)) {
     return;
   }
 
-  DispatchEvent(process, extension_id,
-                event->event_name, *event_args,
-                event->event_url, event->user_gesture,
-                event->info);
+  DispatchExtensionMessage(process, extension_id,
+                           event->event_name, event_args,
+                           event->event_url, event->user_gesture,
+                           event->info);
   IncrementInFlightEvents(listener_profile, extension);
 }
 
 bool EventRouter::CanDispatchEventToProfile(Profile* profile,
                                             const Extension* extension,
                                             const linked_ptr<Event>& event,
-                                            const Value** event_args) {
-  *event_args = event->event_args.get();
+                                            ListValue** event_args) {
+  if (event_args)
+    *event_args = event->event_args.get();
 
   // Is this event from a different profile than the renderer (ie, an
   // incognito tab event sent to a normal process, or vice versa).
   bool cross_incognito =
       event->restrict_to_profile && profile != event->restrict_to_profile;
   if (cross_incognito &&
       !profile->GetExtensionService()->CanCrossIncognito(extension)) {
     if (!event->cross_incognito_args.get())
       return false;
     // Send the event with different arguments to extensions that can't
     // cross incognito.
-    *event_args = event->cross_incognito_args.get();
+    if (event_args)
+      *event_args = event->cross_incognito_args.get();
   }
 
   return true;
 }
 
 void EventRouter::MaybeLoadLazyBackgroundPageToDispatchEvent(
     Profile* profile,
     const Extension* extension,
     const linked_ptr<Event>& event) {
-  const Value* event_args = NULL;
-  if (!CanDispatchEventToProfile(profile, extension, event, &event_args))
+  if (!CanDispatchEventToProfile(profile, extension, event, NULL))
     return;
 
   LazyBackgroundTaskQueue* queue =
       ExtensionSystem::Get(profile)->lazy_background_task_queue();
   if (queue->ShouldEnqueueTask(profile, extension)) {
     queue->AddPendingTask(profile, extension->id(),
                           base::Bind(&EventRouter::DispatchPendingEvent,
                                      base::Unretained(this), event));
   }
 }
@@ skipping 80 matching lines @@
                      profile_, extension->id()));
       break;
     }
     default:
       NOTREACHED();
       return;
   }
 }
 
 Event::Event(const std::string& event_name,
-             const Value& event_args,
+             scoped_ptr<ListValue> event_args,
              const GURL& event_url,
              Profile* restrict_to_profile,
-             const Value& cross_incognito_args,
+             scoped_ptr<ListValue> cross_incognito_args,
              EventRouter::UserGestureState user_gesture,
              const EventFilteringInfo& info)
     : event_name(event_name),
-      event_args(event_args.DeepCopy()),
+      event_args(event_args.Pass()),
       event_url(event_url),
       restrict_to_profile(restrict_to_profile),
-      cross_incognito_args(cross_incognito_args.DeepCopy()),
+      cross_incognito_args(cross_incognito_args.Pass()),
       user_gesture(user_gesture),
-      info(info) {
-}
+      info(info) {}
 
 Event::Event(const std::string& event_name,
-             const std::string& event_args,
-             const GURL& event_url,
-             Profile* restrict_to_profile,
-             const std::string& cross_incognito_args,
-             EventRouter::UserGestureState user_gesture,
-             const EventFilteringInfo& info)
-    : event_name(event_name),
-      event_args(Value::CreateStringValue(event_args)),
-      event_url(event_url),
-      restrict_to_profile(restrict_to_profile),
-      cross_incognito_args(Value::CreateStringValue(cross_incognito_args)),
-      user_gesture(user_gesture),
-      info(info) {
-}
-
-Event::Event(const std::string& event_name,
-             const Value& event_args,
+             scoped_ptr<ListValue> event_args,
              const GURL& event_url,
              Profile* restrict_to_profile,
              EventRouter::UserGestureState user_gesture,
              const EventFilteringInfo& info)
     : event_name(event_name),
-      event_args(event_args.DeepCopy()),
+      event_args(event_args.Pass()),
       event_url(event_url),
       restrict_to_profile(restrict_to_profile),
       cross_incognito_args(NULL),
       user_gesture(user_gesture),
-      info(info) {
-}
+      info(info) {}
 
-Event::~Event() {
-}
+Event::~Event() {}
 
 }  // namespace extensions