Do not pass URLs in onUpdated events to extensions unless they have the

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 321 matching lines @@
       to_index));
   args->Append(object_args);
 
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
   DispatchEvent(profile, events::kOnTabMoved, args.Pass(),
                 EventRouter::USER_GESTURE_UNKNOWN);
 }
 
 void BrowserEventRouter::TabUpdated(WebContents* contents, bool did_navigate) {
   TabEntry* entry = GetTabEntry(contents);
-  DictionaryValue* changed_properties = NULL;
+  scoped_ptr<DictionaryValue> changed_properties;
 
   DCHECK(entry);
 
   if (did_navigate)
-    changed_properties = entry->DidNavigate(contents);
+    changed_properties.reset(entry->DidNavigate(contents));
   else
-    changed_properties = entry->UpdateLoadState(contents);
+    changed_properties.reset(entry->UpdateLoadState(contents));
 
   if (changed_properties)
-    DispatchTabUpdatedEvent(contents, changed_properties);
+    DispatchTabUpdatedEvent(contents, changed_properties.Pass());
 }
 
 void BrowserEventRouter::DispatchEvent(
     Profile* profile,
     const char* event_name,
     scoped_ptr<ListValue> args,
     EventRouter::UserGestureState user_gesture) {
   if (!profile_->IsSameProfile(profile) ||
       !extensions::ExtensionSystem::Get(profile)->event_router())
     return;
@@ skipping 26 matching lines @@
   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);
 }
 
-static void WillDispatchTabUpdatedEvent(WebContents* contents,
-                                        Profile* profile,
-                                        const Extension* extension,
-                                        ListValue* event_args) {
+static void WillDispatchTabUpdatedEvent(
+    WebContents* contents,
+    const DictionaryValue* changed_properties,
+    Profile* profile,
+    const Extension* extension,
+    ListValue* event_args) {
+  // Overwrite the second argument with the appropriate properties dictionary,
+  // depending on extension permissions.
+  DictionaryValue* properties_value = changed_properties->DeepCopy();
+  ExtensionTabUtil::ScrubTabValueForExtension(contents, extension,
+                                              properties_value);
+  event_args->Set(1, properties_value);
+
+  // Overwrite the third arg with our tab value as seen by this extension.
   DictionaryValue* tab_value = ExtensionTabUtil::CreateTabValue(
       contents, extension);
-  // Overwrite the third arg with our tab value as seen by this extension.
   event_args->Set(2, tab_value);
 }
 
 void BrowserEventRouter::DispatchTabUpdatedEvent(
-    WebContents* contents, DictionaryValue* changed_properties) {
+    WebContents* contents, scoped_ptr<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_base(new ListValue());
 
   // First arg: The id of the tab that changed.
   args_base->AppendInteger(ExtensionTabUtil::GetTabId(contents));
 
-  // Second arg: An object containing the changes to the tab state.
-  args_base->Append(changed_properties);
+  // Second arg: An object containing the changes to the tab state.  Filled in
+  // by WillDispatchTabUpdatedEvent as a copy of changed_properties, if the
+  // extension has the tabs permission.
 
   // Third arg: An object containing the state of the tab. Filled in by
   // WillDispatchTabUpdatedEvent.
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
 
   scoped_ptr<Event> event(new Event(events::kOnTabUpdated, args_base.Pass()));
   event->restrict_to_profile = profile;
   event->user_gesture = EventRouter::USER_GESTURE_NOT_ENABLED;
   event->will_dispatch_callback =
-      base::Bind(&WillDispatchTabUpdatedEvent, contents);
+      base::Bind(&WillDispatchTabUpdatedEvent,
+                 contents, changed_properties.get());
   ExtensionSystem::Get(profile)->event_router()->BroadcastEvent(event.Pass());
 }
 
 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 51 matching lines @@
     RegisterForTabNotifications(new_contents);
   }
 }
 
 void BrowserEventRouter::TabPinnedStateChanged(WebContents* contents,
                                                int index) {
   TabStripModel* tab_strip = NULL;
   int tab_index;
 
   if (ExtensionTabUtil::GetTabStripModel(contents, &tab_strip, &tab_index)) {
-    DictionaryValue* changed_properties = new DictionaryValue();
+    scoped_ptr<DictionaryValue> changed_properties(new DictionaryValue());
     changed_properties->SetBoolean(tab_keys::kPinnedKey,
                                    tab_strip->IsTabPinned(tab_index));
-    DispatchTabUpdatedEvent(contents, changed_properties);
+    DispatchTabUpdatedEvent(contents, changed_properties.Pass());
   }
 }
 
 void BrowserEventRouter::TabStripEmpty() {}
 
 void BrowserEventRouter::DispatchOldPageActionEvent(
     Profile* profile,
     const std::string& extension_id,
     const std::string& page_action_id,
     int tab_id,
@@ skipping 66 matching lines @@
       event_name = "scriptBadge.onClicked";
       break;
     case Extension::ActionInfo::TYPE_SYSTEM_INDICATOR:
       // The System Indicator handles its own clicks.
       break;
   }
 
   if (event_name) {
     scoped_ptr<ListValue> args(new ListValue());
     DictionaryValue* tab_value = ExtensionTabUtil::CreateTabValue(
-        web_contents,
-        ExtensionTabUtil::INCLUDE_PRIVACY_SENSITIVE_FIELDS);
+        web_contents);
     args->Append(tab_value);
 
     DispatchEventToExtension(profile,
                              extension_action.extension_id(),
                              event_name,
                              args.Pass(),
                              EventRouter::USER_GESTURE_ENABLED);
   }
 }
 
 }  // namespace extensions