Always send the full tab object in ExtensionAction click event.

chrome/browser/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 "chrome/browser/extensions/browser_event_router.h"
 
 #include "base/json/json_writer.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/extension_action/extension_page_actions_api_constants.h"
 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
@@ skipping 148 matching lines @@
   if (service) {
     service->window_event_router()->OnActiveWindowChanged(
         browser ? browser->extension_window_controller() : NULL);
   }
 }
 
 void BrowserEventRouter::TabCreatedAt(WebContents* contents,
                                       int index,
                                       bool active) {
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
-  DispatchEventWithTab(profile, "", events::kOnTabCreated, contents, active,
-                       EventRouter::USER_GESTURE_NOT_ENABLED);
+  const EventListenerMap::ListenerList& listeners(
+      ExtensionSystem::Get(profile)->event_router()->
+      listeners().GetEventListenersByName(events::kOnTabCreated));
+  for (EventListenerMap::ListenerList::const_iterator it = listeners.begin();
+       it != listeners.end();
+       ++it) {
+    scoped_ptr<ListValue> args(new ListValue());
+    DictionaryValue* tab_value = ExtensionTabUtil::CreateTabValue(
+        contents,
+        profile->GetExtensionService()->extensions()->GetByID(
+            (*it)->extension_id));
+    args->Append(tab_value);
+    tab_value->SetBoolean(tab_keys::kSelectedKey, active);
+    DispatchEventToExtension(profile, (*it)->extension_id,
+                             events::kOnTabCreated, args.Pass(),
+                             EventRouter::USER_GESTURE_NOT_ENABLED);
+  }
 
   RegisterForTabNotifications(contents);
 }
 
 void BrowserEventRouter::TabInsertedAt(TabContents* contents,
                                        int index,
                                        bool active) {
   // If tab is new, send created event.
   int tab_id = ExtensionTabUtil::GetTabId(contents->web_contents());
   if (!GetTabEntry(contents->web_contents())) {
@@ skipping 190 matching lines @@
     scoped_ptr<ListValue> event_args,
     scoped_ptr<ListValue> cross_incognito_args) {
   if (!profile_->IsSameProfile(profile) || !profile->GetExtensionEventRouter())
     return;
 
   profile->GetExtensionEventRouter()->DispatchEventsToRenderersAcrossIncognito(
       event_name, event_args.Pass(), profile, cross_incognito_args.Pass(),
       GURL());
 }
 
-void BrowserEventRouter::DispatchEventWithTab(
-    Profile* profile,
-    const std::string& extension_id,
-    const char* event_name,
-    const WebContents* web_contents,
-    bool active,
-    EventRouter::UserGestureState user_gesture,
-    scoped_ptr<ListValue> event_args) {
-  if (!profile_->IsSameProfile(profile))
-    return;
-
-  if (!extension_id.empty()) {
-    event_args->Append(ExtensionTabUtil::CreateTabValueActive(
-        web_contents,
-        active,
-        profile->GetExtensionService()->extensions()->GetByID(extension_id)));
-    DispatchEventToExtension(profile, extension_id, event_name,
-                             event_args.Pass(), user_gesture);
-  } else {
-    const EventListenerMap::ListenerList& listeners(
-        ExtensionSystem::Get(profile)->event_router()->
-        listeners().GetEventListenersByName(event_name));
-
-    for (EventListenerMap::ListenerList::const_iterator it = listeners.begin();
-         it != listeners.end();
-         ++it) {
-      scoped_ptr<ListValue> args(event_args->DeepCopy());
-      args->Append(ExtensionTabUtil::CreateTabValueActive(
-          web_contents,
-          active,
-          profile->GetExtensionService()->extensions()->GetByID(
-              (*it)->extension_id)));
-      DispatchEventToExtension(profile, (*it)->extension_id, event_name,
-                               args.Pass(), user_gesture);
-    }
-  }
-}
-
 void BrowserEventRouter::DispatchSimpleBrowserEvent(
     Profile* profile, const int window_id, const char* event_name) {
   if (!profile_->IsSameProfile(profile))
     return;
 
   scoped_ptr<ListValue> args(new ListValue());
   args->Append(Value::CreateIntegerValue(window_id));
 
   DispatchEvent(profile, event_name, args.Pass(),
                 EventRouter::USER_GESTURE_UNKNOWN);
 }
 
 void BrowserEventRouter::DispatchTabUpdatedEvent(
     WebContents* contents, DictionaryValue* changed_properties) {
   DCHECK(changed_properties);
   DCHECK(contents);
 
   // The state of the tab (as seen from the extension point of view) has
   // changed.  Send a notification to the extension.
-  scoped_ptr<ListValue> args(new ListValue());
+  scoped_ptr<ListValue> args_base(new ListValue());
 
   // First arg: The id of the tab that changed.
-  args->Append(Value::CreateIntegerValue(ExtensionTabUtil::GetTabId(contents)));
+  args_base->AppendInteger(ExtensionTabUtil::GetTabId(contents));
 
   // Second arg: An object containing the changes to the tab state.
-  args->Append(changed_properties);
+  args_base->Append(changed_properties);
 
   // Third arg: An object containing the state of the tab.
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
 
-  DispatchEventWithTab(profile, "", events::kOnTabUpdated, contents, true,
-                       EventRouter::USER_GESTURE_UNKNOWN, args.Pass());
+  const EventListenerMap::ListenerList& listeners(
+      ExtensionSystem::Get(profile)->event_router()->
+      listeners().GetEventListenersByName(events::kOnTabUpdated));
+  for (EventListenerMap::ListenerList::const_iterator it = listeners.begin();
+       it != listeners.end();
+       ++it) {
+    scoped_ptr<ListValue> args(args_base->DeepCopy());
+    DictionaryValue* tab_value = ExtensionTabUtil::CreateTabValue(
+        contents,
+        profile->GetExtensionService()->extensions()->GetByID(
+            (*it)->extension_id));
+    args->Append(tab_value);
+    DispatchEventToExtension(profile, (*it)->extension_id,
+                             events::kOnTabUpdated, args.Pass(),
+                             EventRouter::USER_GESTURE_UNKNOWN);
+  }
 }
 
 BrowserEventRouter::TabEntry* BrowserEventRouter::GetTabEntry(
     const WebContents* contents) {
   int tab_id = ExtensionTabUtil::GetTabId(contents);
   std::map<int, TabEntry>::iterator i = tab_entries_.find(tab_id);
   if (tab_entries_.end() == i)
     return NULL;
   return &i->second;
 }
@@ skipping 129 matching lines @@
       break;
     case ExtensionAction::TYPE_PAGE:
       event_name = "pageAction.onClicked";
       break;
     case ExtensionAction::TYPE_SCRIPT_BADGE:
       event_name = "scriptBadge.onClicked";
       break;
   }
 
   if (event_name) {
-    DispatchEventWithTab(profile,
-                         extension_action.extension_id(),
-                         event_name,
-                         tab_contents->web_contents(),
-                         true,
-                         EventRouter::USER_GESTURE_ENABLED);
+    scoped_ptr<ListValue> args(new ListValue());
+    DictionaryValue* tab_value = ExtensionTabUtil::CreateTabValue(
+        tab_contents->web_contents(),
+        ExtensionTabUtil::INCLUDE_PRIVACY_SENSITIVE_FIELDS);
+    args->Append(tab_value);
+
+    DispatchEventToExtension(profile,
+                             extension_action.extension_id(),
+                             event_name,
+                             args.Pass(),
+                             EventRouter::USER_GESTURE_ENABLED);
   }
 }
 
 }  // namespace extensions