Convert most of extensions and some other random stuff to using the base namespace for Values.

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 147 matching lines @@
   if (tabs_window_api) {
     tabs_window_api->windows_event_router()->OnActiveWindowChanged(
         browser ? browser->extension_window_controller() : NULL);
   }
 }
 
 static void WillDispatchTabCreatedEvent(WebContents* contents,
                                         bool active,
                                         Profile* profile,
                                         const Extension* extension,
-                                        ListValue* event_args) {
+                                        base::ListValue* event_args) {
   DictionaryValue* tab_value = ExtensionTabUtil::CreateTabValue(
       contents, extension);
   event_args->Clear();
   event_args->Append(tab_value);
   tab_value->SetBoolean(tab_keys::kSelectedKey, active);
 }
 
 void BrowserEventRouter::TabCreatedAt(WebContents* contents,
                                       int index,
                                       bool active) {
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
-  scoped_ptr<ListValue> args(new ListValue());
+  scoped_ptr<base::ListValue> args(new base::ListValue());
   scoped_ptr<Event> event(new Event(events::kOnTabCreated, args.Pass()));
   event->restrict_to_profile = profile;
   event->user_gesture = EventRouter::USER_GESTURE_NOT_ENABLED;
   event->will_dispatch_callback =
       base::Bind(&WillDispatchTabCreatedEvent, contents, active);
   ExtensionSystem::Get(profile)->event_router()->BroadcastEvent(event.Pass());
 
   RegisterForTabNotifications(contents);
 }
 
 void BrowserEventRouter::TabInsertedAt(WebContents* contents,
                                        int index,
                                        bool active) {
   // If tab is new, send created event.
   int tab_id = ExtensionTabUtil::GetTabId(contents);
   if (!GetTabEntry(contents)) {
     tab_entries_[tab_id] = TabEntry();
 
     TabCreatedAt(contents, index, active);
     return;
   }
 
-  scoped_ptr<ListValue> args(new ListValue());
+  scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Append(Value::CreateIntegerValue(tab_id));
 
   DictionaryValue* object_args = new DictionaryValue();
   object_args->Set(tab_keys::kNewWindowIdKey, Value::CreateIntegerValue(
       ExtensionTabUtil::GetWindowIdOfTab(contents)));
   object_args->Set(tab_keys::kNewPositionKey, Value::CreateIntegerValue(
       index));
   args->Append(object_args);
 
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
   DispatchEvent(profile, events::kOnTabAttached, args.Pass(),
                 EventRouter::USER_GESTURE_UNKNOWN);
 }
 
 void BrowserEventRouter::TabDetachedAt(WebContents* contents, int index) {
   if (!GetTabEntry(contents)) {
     // The tab was removed. Don't send detach event.
     return;
   }
 
-  scoped_ptr<ListValue> args(new ListValue());
+  scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Append(Value::CreateIntegerValue(ExtensionTabUtil::GetTabId(contents)));
 
   DictionaryValue* object_args = new DictionaryValue();
   object_args->Set(tab_keys::kOldWindowIdKey, Value::CreateIntegerValue(
       ExtensionTabUtil::GetWindowIdOfTab(contents)));
   object_args->Set(tab_keys::kOldPositionKey, Value::CreateIntegerValue(
       index));
   args->Append(object_args);
 
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
   DispatchEvent(profile, events::kOnTabDetached, args.Pass(),
                 EventRouter::USER_GESTURE_UNKNOWN);
 }
 
 void BrowserEventRouter::TabClosingAt(TabStripModel* tab_strip_model,
                                       WebContents* contents,
                                       int index) {
   int tab_id = ExtensionTabUtil::GetTabId(contents);
 
-  scoped_ptr<ListValue> args(new ListValue());
+  scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Append(Value::CreateIntegerValue(tab_id));
 
   DictionaryValue* object_args = new DictionaryValue();
   object_args->SetInteger(tab_keys::kWindowIdKey,
                           ExtensionTabUtil::GetWindowIdOfTab(contents));
   object_args->SetBoolean(tab_keys::kWindowClosing,
                           tab_strip_model->closing_all());
   args->Append(object_args);
 
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
   DispatchEvent(profile, events::kOnTabRemoved, args.Pass(),
                 EventRouter::USER_GESTURE_UNKNOWN);
 
   int removed_count = tab_entries_.erase(tab_id);
   DCHECK_GT(removed_count, 0);
 
   UnregisterForTabNotifications(contents);
 }
 
 void BrowserEventRouter::ActiveTabChanged(WebContents* old_contents,
                                           WebContents* new_contents,
                                           int index,
                                           int reason) {
-  scoped_ptr<ListValue> args(new ListValue());
+  scoped_ptr<base::ListValue> args(new base::ListValue());
   int tab_id = ExtensionTabUtil::GetTabId(new_contents);
   args->Append(Value::CreateIntegerValue(tab_id));
 
   DictionaryValue* object_args = new DictionaryValue();
   object_args->Set(tab_keys::kWindowIdKey, Value::CreateIntegerValue(
       ExtensionTabUtil::GetWindowIdOfTab(new_contents)));
   args->Append(object_args);
 
   // The onActivated event replaced onActiveChanged and onSelectionChanged. The
   // deprecated events take two arguments: tabId, {windowId}.
   Profile* profile =
       Profile::FromBrowserContext(new_contents->GetBrowserContext());
   EventRouter::UserGestureState gesture =
       reason & CHANGE_REASON_USER_GESTURE
       ? EventRouter::USER_GESTURE_ENABLED
       : EventRouter::USER_GESTURE_NOT_ENABLED;
   DispatchEvent(profile, events::kOnTabSelectionChanged,
-                scoped_ptr<ListValue>(args->DeepCopy()), gesture);
+                scoped_ptr<base::ListValue>(args->DeepCopy()), gesture);
   DispatchEvent(profile, events::kOnTabActiveChanged,
-                scoped_ptr<ListValue>(args->DeepCopy()), gesture);
+                scoped_ptr<base::ListValue>(args->DeepCopy()), gesture);
 
   // The onActivated event takes one argument: {windowId, tabId}.
   args->Remove(0, NULL);
   object_args->Set(tab_keys::kTabIdKey, Value::CreateIntegerValue(tab_id));
   DispatchEvent(profile, events::kOnTabActivated, args.Pass(), gesture);
 }
 
 void BrowserEventRouter::TabSelectionChanged(
     TabStripModel* tab_strip_model,
     const ui::ListSelectionModel& old_model) {
   ui::ListSelectionModel::SelectedIndices new_selection =
       tab_strip_model->selection_model().selected_indices();
-  ListValue* all = new ListValue();
+  base::ListValue* all = new base::ListValue();
 
   for (size_t i = 0; i < new_selection.size(); ++i) {
     int index = new_selection[i];
     WebContents* contents = tab_strip_model->GetWebContentsAt(index);
     if (!contents)
       break;
     int tab_id = ExtensionTabUtil::GetTabId(contents);
     all->Append(Value::CreateIntegerValue(tab_id));
   }
 
-  scoped_ptr<ListValue> args(new ListValue());
+  scoped_ptr<base::ListValue> args(new base::ListValue());
   DictionaryValue* select_info = new DictionaryValue();
 
   select_info->Set(tab_keys::kWindowIdKey, Value::CreateIntegerValue(
       ExtensionTabUtil::GetWindowIdOfTabStripModel(tab_strip_model)));
 
   select_info->Set(tab_keys::kTabIdsKey, all);
   args->Append(select_info);
 
   // The onHighlighted event replaced onHighlightChanged.
   Profile* profile = tab_strip_model->profile();
   DispatchEvent(profile, events::kOnTabHighlightChanged,
-                scoped_ptr<ListValue>(args->DeepCopy()),
+                scoped_ptr<base::ListValue>(args->DeepCopy()),
                 EventRouter::USER_GESTURE_UNKNOWN);
   DispatchEvent(profile, events::kOnTabHighlighted, args.Pass(),
                 EventRouter::USER_GESTURE_UNKNOWN);
 }
 
 void BrowserEventRouter::TabMoved(WebContents* contents,
                                   int from_index,
                                   int to_index) {
-  scoped_ptr<ListValue> args(new ListValue());
+  scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Append(Value::CreateIntegerValue(ExtensionTabUtil::GetTabId(contents)));
 
   DictionaryValue* object_args = new DictionaryValue();
   object_args->Set(tab_keys::kWindowIdKey, Value::CreateIntegerValue(
       ExtensionTabUtil::GetWindowIdOfTab(contents)));
   object_args->Set(tab_keys::kFromIndexKey, Value::CreateIntegerValue(
       from_index));
   object_args->Set(tab_keys::kToIndexKey, Value::CreateIntegerValue(
       to_index));
   args->Append(object_args);
@@ skipping 29 matching lines @@
     scoped_ptr<DictionaryValue> changed_properties(new DictionaryValue());
     changed_properties->SetString(
         tab_keys::kFaviconUrlKey,
         entry->GetFavicon().url.possibly_invalid_spec());
     DispatchTabUpdatedEvent(contents, changed_properties.Pass());
 }
 
 void BrowserEventRouter::DispatchEvent(
     Profile* profile,
     const char* event_name,
-    scoped_ptr<ListValue> args,
+    scoped_ptr<base::ListValue> args,
     EventRouter::UserGestureState user_gesture) {
   if (!profile_->IsSameProfile(profile) ||
       !extensions::ExtensionSystem::Get(profile)->event_router())
     return;
 
   scoped_ptr<Event> event(new Event(event_name, args.Pass()));
   event->restrict_to_profile = profile;
   event->user_gesture = user_gesture;
   ExtensionSystem::Get(profile)->event_router()->BroadcastEvent(event.Pass());
 }
 
 void BrowserEventRouter::DispatchEventToExtension(
     Profile* profile,
     const std::string& extension_id,
     const char* event_name,
-    scoped_ptr<ListValue> event_args,
+    scoped_ptr<base::ListValue> event_args,
     EventRouter::UserGestureState user_gesture) {
   if (!profile_->IsSameProfile(profile) ||
       !extensions::ExtensionSystem::Get(profile)->event_router())
     return;
 
   scoped_ptr<Event> event(new Event(event_name, event_args.Pass()));
   event->restrict_to_profile = profile;
   event->user_gesture = user_gesture;
   ExtensionSystem::Get(profile)->event_router()->
       DispatchEventToExtension(extension_id, event.Pass());
 }
 
 void BrowserEventRouter::DispatchSimpleBrowserEvent(
     Profile* profile, const int window_id, const char* event_name) {
   if (!profile_->IsSameProfile(profile))
     return;
 
-  scoped_ptr<ListValue> args(new ListValue());
+  scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Append(Value::CreateIntegerValue(window_id));
 
   DispatchEvent(profile, event_name, args.Pass(),
                 EventRouter::USER_GESTURE_UNKNOWN);
 }
 
 static void WillDispatchTabUpdatedEvent(
     WebContents* contents,
     const DictionaryValue* changed_properties,
     Profile* profile,
     const Extension* extension,
-    ListValue* event_args) {
+    base::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);
   event_args->Set(2, tab_value);
 }
 
 void BrowserEventRouter::DispatchTabUpdatedEvent(
     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());
+  scoped_ptr<base::ListValue> args_base(new base::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.  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.
@@ skipping 49 matching lines @@
 }
 
 void BrowserEventRouter::TabReplacedAt(TabStripModel* tab_strip_model,
                                        WebContents* old_contents,
                                        WebContents* new_contents,
                                        int index) {
   // Notify listeners that the next tabs closing or being added are due to
   // WebContents being swapped.
   const int new_tab_id = ExtensionTabUtil::GetTabId(new_contents);
   const int old_tab_id = ExtensionTabUtil::GetTabId(old_contents);
-  scoped_ptr<ListValue> args(new ListValue());
+  scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Append(Value::CreateIntegerValue(new_tab_id));
   args->Append(Value::CreateIntegerValue(old_tab_id));
 
   DispatchEvent(Profile::FromBrowserContext(new_contents->GetBrowserContext()),
                 events::kOnTabReplaced,
                 args.Pass(),
                 EventRouter::USER_GESTURE_UNKNOWN);
 
   // Update tab_entries_.
   const int removed_count = tab_entries_.erase(old_tab_id);
@@ skipping 21 matching lines @@
 
 void BrowserEventRouter::TabStripEmpty() {}
 
 void BrowserEventRouter::DispatchOldPageActionEvent(
     Profile* profile,
     const std::string& extension_id,
     const std::string& page_action_id,
     int tab_id,
     const std::string& url,
     int button) {
-  scoped_ptr<ListValue> args(new ListValue());
+  scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Append(Value::CreateStringValue(page_action_id));
 
   DictionaryValue* data = new DictionaryValue();
   data->Set(tab_keys::kTabIdKey, Value::CreateIntegerValue(tab_id));
   data->Set(tab_keys::kTabUrlKey, Value::CreateStringValue(url));
   data->Set(page_actions_keys::kButtonKey,
             Value::CreateIntegerValue(button));
   args->Append(data);
 
   DispatchEventToExtension(profile, extension_id, "pageActions", args.Pass(),
@@ skipping 52 matching lines @@
       break;
     case ActionInfo::TYPE_SCRIPT_BADGE:
       event_name = "scriptBadge.onClicked";
       break;
     case ActionInfo::TYPE_SYSTEM_INDICATOR:
       // The System Indicator handles its own clicks.
       break;
   }
 
   if (event_name) {
-    scoped_ptr<ListValue> args(new ListValue());
+    scoped_ptr<base::ListValue> args(new base::ListValue());
     DictionaryValue* tab_value = ExtensionTabUtil::CreateTabValue(
         web_contents);
     args->Append(tab_value);
 
     DispatchEventToExtension(profile,
                              extension_action.extension_id(),
                              event_name,
                              args.Pass(),
                              EventRouter::USER_GESTURE_ENABLED);
   }
 }
 
 }  // namespace extensions