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

chrome/browser/extensions/api/processes/processes_api.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/api/processes/processes_api.h"
 
 #include "base/callback.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 107 matching lines @@
       continue;
     if (!widgets[i]->IsRenderView())
       continue;
 
     content::RenderViewHost* host = content::RenderViewHost::From(widgets[i]);
     content::WebContents* contents =
         content::WebContents::FromRenderViewHost(host);
     if (contents) {
       tab_id = ExtensionTabUtil::GetTabId(contents);
       if (tab_id != -1)
-        tabs_list->Append(Value::CreateIntegerValue(tab_id));
+        tabs_list->Append(new base::FundamentalValue(tab_id));
     }
   }
 
   return tabs_list;
 }
 
 // This function creates a Process object to be returned to the extensions
 // using these APIs. For memory details, which are not added by this function,
 // the callers need to use AddMemoryDetails.
 base::DictionaryValue* CreateProcessFromModel(int process_id,
@@ skipping 255 matching lines @@
   // termination status, therefore we will rely on notifications and not on
   // the Task Manager data. We do use the rest of this method for non-renderer
   // processes.
   if (model_->GetResourceType(start) == task_manager::Resource::RENDERER)
     return;
 
   // The callback function parameters.
   scoped_ptr<base::ListValue> args(new base::ListValue());
 
   // First arg: The id of the process that was closed.
-  args->Append(Value::CreateIntegerValue(
+  args->Append(new base::FundamentalValue(
       model_->GetUniqueChildProcessId(start)));
 
   // Second arg: The exit type for the process.
-  args->Append(Value::CreateIntegerValue(0));
+  args->Append(new base::FundamentalValue(0));
 
   // Third arg: The exit code for the process.
-  args->Append(Value::CreateIntegerValue(0));
+  args->Append(new base::FundamentalValue(0));
 
   DispatchEvent(keys::kOnExited, args.Pass());
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void ProcessesEventRouter::ProcessHangEvent(content::RenderWidgetHost* widget) {
 #if defined(ENABLE_TASK_MANAGER)
   std::string event(keys::kOnUnresponsive);
   if (!HasEventListeners(event))
     return;
@@ skipping 23 matching lines @@
 }
 
 void ProcessesEventRouter::ProcessClosedEvent(
     content::RenderProcessHost* rph,
     content::RenderProcessHost::RendererClosedDetails* details) {
 #if defined(ENABLE_TASK_MANAGER)
   // The callback function parameters.
   scoped_ptr<base::ListValue> args(new base::ListValue());
 
   // First arg: The id of the process that was closed.
-  args->Append(Value::CreateIntegerValue(rph->GetID()));
+  args->Append(new base::FundamentalValue(rph->GetID()));
 
   // Second arg: The exit type for the process.
-  args->Append(Value::CreateIntegerValue(details->status));
+  args->Append(new base::FundamentalValue(details->status));
 
   // Third arg: The exit code for the process.
-  args->Append(Value::CreateIntegerValue(details->exit_code));
+  args->Append(new base::FundamentalValue(details->exit_code));
 
   DispatchEvent(keys::kOnExited, args.Pass());
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 void ProcessesEventRouter::DispatchEvent(
     const char* event_name,
     scoped_ptr<base::ListValue> event_args) {
   if (extensions::ExtensionSystem::Get(profile_)->event_router()) {
     scoped_ptr<extensions::Event> event(new extensions::Event(
@@ skipping 106 matching lines @@
 }
 
 void GetProcessIdForTabFunction::GetProcessIdForTab() {
   content::WebContents* contents = NULL;
   int tab_index = -1;
   if (!ExtensionTabUtil::GetTabById(tab_id_, profile(), include_incognito(),
                                     NULL, NULL, &contents, &tab_index)) {
     error_ = ErrorUtils::FormatErrorMessage(
         extensions::tabs_constants::kTabNotFoundError,
         base::IntToString(tab_id_));
-    SetResult(Value::CreateIntegerValue(-1));
+    SetResult(new base::FundamentalValue(-1));
     SendResponse(false);
   } else {
     int process_id = contents->GetRenderProcessHost()->GetID();
-    SetResult(Value::CreateIntegerValue(process_id));
+    SetResult(new base::FundamentalValue(process_id));
     SendResponse(true);
   }
 
   // Balance the AddRef in the RunImpl.
   Release();
 }
 
 TerminateFunction::TerminateFunction() : process_id_(-1) {
 }
 
@@ skipping 54 matching lines @@
         break;
       }
     }
   }
 
   if (!found) {
     error_ = ErrorUtils::FormatErrorMessage(errors::kProcessNotFound,
         base::IntToString(process_id_));
     SendResponse(false);
   } else {
-    SetResult(Value::CreateBooleanValue(killed));
+    SetResult(new base::FundamentalValue(killed));
     SendResponse(true);
   }
 
   // Balance the AddRef in the RunImpl.
   Release();
 }
 
 GetProcessInfoFunction::GetProcessInfoFunction()
 #if defined(ENABLE_TASK_MANAGER)
   : memory_(false)
@@ skipping 93 matching lines @@
 
   SetResult(processes);
   SendResponse(true);
 
   // Balance the AddRef in the RunImpl.
   Release();
 #endif  // defined(ENABLE_TASK_MANAGER)
 }
 
 }  // namespace extensions