c/b/extensions, json_schema_compiler: Do not use Value::Create*.

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/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/extension_action/extension_page_actions_api_constants.h"
@@ skipping 183 matching lines @@
   // 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<base::ListValue> args(new base::ListValue());
-  args->Append(Value::CreateIntegerValue(tab_id));
+  args->Append(new base::FundamentalValue(tab_id));
 
   DictionaryValue* object_args = new DictionaryValue();
-  object_args->Set(tab_keys::kNewWindowIdKey, Value::CreateIntegerValue(
+  object_args->Set(tab_keys::kNewWindowIdKey, new base::FundamentalValue(
       ExtensionTabUtil::GetWindowIdOfTab(contents)));
-  object_args->Set(tab_keys::kNewPositionKey, Value::CreateIntegerValue(
+  object_args->Set(tab_keys::kNewPositionKey, new base::FundamentalValue(
       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<base::ListValue> args(new base::ListValue());
-  args->Append(Value::CreateIntegerValue(ExtensionTabUtil::GetTabId(contents)));
+  args->Append(
+      new base::FundamentalValue(ExtensionTabUtil::GetTabId(contents)));
 
   DictionaryValue* object_args = new DictionaryValue();
-  object_args->Set(tab_keys::kOldWindowIdKey, Value::CreateIntegerValue(
+  object_args->Set(tab_keys::kOldWindowIdKey, new base::FundamentalValue(
       ExtensionTabUtil::GetWindowIdOfTab(contents)));
-  object_args->Set(tab_keys::kOldPositionKey, Value::CreateIntegerValue(
+  object_args->Set(tab_keys::kOldPositionKey, new base::FundamentalValue(
       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<base::ListValue> args(new base::ListValue());
-  args->Append(Value::CreateIntegerValue(tab_id));
+  args->Append(new base::FundamentalValue(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<base::ListValue> args(new base::ListValue());
   int tab_id = ExtensionTabUtil::GetTabId(new_contents);
-  args->Append(Value::CreateIntegerValue(tab_id));
+  args->Append(new base::FundamentalValue(tab_id));
 
   DictionaryValue* object_args = new DictionaryValue();
-  object_args->Set(tab_keys::kWindowIdKey, Value::CreateIntegerValue(
+  object_args->Set(tab_keys::kWindowIdKey, new base::FundamentalValue(
       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<base::ListValue>(args->DeepCopy()), gesture);
   DispatchEvent(profile, events::kOnTabActiveChanged,
                 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));
+  object_args->Set(tab_keys::kTabIdKey, new base::FundamentalValue(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();
   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));
+    all->Append(new base::FundamentalValue(tab_id));
   }
 
   scoped_ptr<base::ListValue> args(new base::ListValue());
   DictionaryValue* select_info = new DictionaryValue();
 
-  select_info->Set(tab_keys::kWindowIdKey, Value::CreateIntegerValue(
+  select_info->Set(tab_keys::kWindowIdKey, new base::FundamentalValue(
       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<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<base::ListValue> args(new base::ListValue());
-  args->Append(Value::CreateIntegerValue(ExtensionTabUtil::GetTabId(contents)));
+  args->Append(
+      new base::FundamentalValue(ExtensionTabUtil::GetTabId(contents)));
 
   DictionaryValue* object_args = new DictionaryValue();
-  object_args->Set(tab_keys::kWindowIdKey, Value::CreateIntegerValue(
+  object_args->Set(tab_keys::kWindowIdKey, new base::FundamentalValue(
       ExtensionTabUtil::GetWindowIdOfTab(contents)));
-  object_args->Set(tab_keys::kFromIndexKey, Value::CreateIntegerValue(
+  object_args->Set(tab_keys::kFromIndexKey, new base::FundamentalValue(
       from_index));
-  object_args->Set(tab_keys::kToIndexKey, Value::CreateIntegerValue(
+  object_args->Set(tab_keys::kToIndexKey, new base::FundamentalValue(
       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);
@@ skipping 56 matching lines @@
   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<base::ListValue> args(new base::ListValue());
-  args->Append(Value::CreateIntegerValue(window_id));
+  args->Append(new base::FundamentalValue(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,
@@ skipping 82 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<base::ListValue> args(new base::ListValue());
-  args->Append(Value::CreateIntegerValue(new_tab_id));
-  args->Append(Value::CreateIntegerValue(old_tab_id));
+  args->Append(new base::FundamentalValue(new_tab_id));
+  args->Append(new base::FundamentalValue(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);
   DCHECK_GT(removed_count, 0);
   UnregisterForTabNotifications(old_contents);
@@ skipping 20 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<base::ListValue> args(new base::ListValue());
-  args->Append(Value::CreateStringValue(page_action_id));
+  args->Append(new base::StringValue(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(tab_keys::kTabIdKey, new base::FundamentalValue(tab_id));
+  data->Set(tab_keys::kTabUrlKey, new base::StringValue(url));
   data->Set(page_actions_keys::kButtonKey,
-            Value::CreateIntegerValue(button));
+            new base::FundamentalValue(button));
   args->Append(data);
 
   DispatchEventToExtension(profile, extension_id, "pageActions", args.Pass(),
                            EventRouter::USER_GESTURE_ENABLED);
 }
 
 void BrowserEventRouter::BrowserActionExecuted(
     const ExtensionAction& browser_action,
     Browser* browser) {
   Profile* profile = browser->profile();
@@ skipping 59 matching lines @@
 
     DispatchEventToExtension(profile,
                              extension_action.extension_id(),
                              event_name,
                              args.Pass(),
                              EventRouter::USER_GESTURE_ENABLED);
   }
 }
 
 }  // namespace extensions