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

chrome/browser/extensions/api/socket/socket_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/socket/socket_api.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
@@ skipping 168 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &hostname_));
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(2, &port_));
   return true;
 }
 
 void SocketConnectFunction::AsyncWorkStart() {
   socket_ = GetSocket(socket_id_);
   if (!socket_) {
     error_ = kSocketNotFoundError;
-    SetResult(Value::CreateIntegerValue(-1));
+    SetResult(new base::FundamentalValue(-1));
     AsyncWorkCompleted();
     return;
   }
 
   SocketPermissionRequest::OperationType operation_type;
   switch (socket_->GetSocketType()) {
     case Socket::TYPE_TCP:
       operation_type = SocketPermissionRequest::TCP_CONNECT;
       break;
     case Socket::TYPE_UDP:
       operation_type = SocketPermissionRequest::UDP_SEND_TO;
       break;
     default:
       NOTREACHED() << "Unknown socket type.";
       operation_type = SocketPermissionRequest::NONE;
       break;
   }
 
   SocketPermission::CheckParam param(operation_type, hostname_, port_);
   if (!PermissionsData::CheckAPIPermissionWithParam(
           GetExtension(), APIPermission::kSocket, &param)) {
     error_ = kPermissionError;
-    SetResult(Value::CreateIntegerValue(-1));
+    SetResult(new base::FundamentalValue(-1));
     AsyncWorkCompleted();
     return;
   }
 
   StartDnsLookup(hostname_);
 }
 
 void SocketConnectFunction::AfterDnsLookup(int lookup_result) {
   if (lookup_result == net::OK) {
     StartConnect();
   } else {
-    SetResult(Value::CreateIntegerValue(lookup_result));
+    SetResult(new base::FundamentalValue(lookup_result));
     AsyncWorkCompleted();
   }
 }
 
 void SocketConnectFunction::StartConnect() {
   socket_->Connect(resolved_address_, port_,
                    base::Bind(&SocketConnectFunction::OnConnect, this));
 }
 
 void SocketConnectFunction::OnConnect(int result) {
-  SetResult(Value::CreateIntegerValue(result));
+  SetResult(new base::FundamentalValue(result));
   AsyncWorkCompleted();
 }
 
 bool SocketDisconnectFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
   return true;
 }
 
 void SocketDisconnectFunction::Work() {
   Socket* socket = GetSocket(socket_id_);
@@ skipping 10 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(2, &port_));
   return true;
 }
 
 void SocketBindFunction::Work() {
   int result = -1;
   Socket* socket = GetSocket(socket_id_);
 
   if (!socket) {
     error_ = kSocketNotFoundError;
-    SetResult(Value::CreateIntegerValue(result));
+    SetResult(new base::FundamentalValue(result));
     return;
   }
 
   if (socket->GetSocketType() == Socket::TYPE_UDP) {
     SocketPermission::CheckParam param(
         SocketPermissionRequest::UDP_BIND, address_, port_);
     if (!PermissionsData::CheckAPIPermissionWithParam(
             GetExtension(),
             APIPermission::kSocket,
             &param)) {
       error_ = kPermissionError;
-      SetResult(Value::CreateIntegerValue(result));
+      SetResult(new base::FundamentalValue(result));
       return;
     }
   } else if (socket->GetSocketType() == Socket::TYPE_TCP) {
     error_ = kTCPSocketBindError;
-    SetResult(Value::CreateIntegerValue(result));
+    SetResult(new base::FundamentalValue(result));
     return;
   }
 
   result = socket->Bind(address_, port_);
-  SetResult(Value::CreateIntegerValue(result));
+  SetResult(new base::FundamentalValue(result));
 }
 
 SocketListenFunction::SocketListenFunction() {}
 
 SocketListenFunction::~SocketListenFunction() {}
 
 bool SocketListenFunction::Prepare() {
   params_ = api::socket::Listen::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketListenFunction::Work() {
   int result = -1;
 
   Socket* socket = GetSocket(params_->socket_id);
   if (socket) {
     SocketPermission::CheckParam param(
         SocketPermissionRequest::TCP_LISTEN, params_->address, params_->port);
     if (!PermissionsData::CheckAPIPermissionWithParam(
             GetExtension(),
             APIPermission::kSocket,
             &param)) {
       error_ = kPermissionError;
-      SetResult(Value::CreateIntegerValue(result));
+      SetResult(new base::FundamentalValue(result));
       return;
     }
 
     result = socket->Listen(
         params_->address,
         params_->port,
         params_->backlog.get() ? *params_->backlog.get() : 5,
         &error_);
   } else {
     error_ = kSocketNotFoundError;
   }
 
-  SetResult(Value::CreateIntegerValue(result));
+  SetResult(new base::FundamentalValue(result));
 }
 
 SocketAcceptFunction::SocketAcceptFunction() {}
 
 SocketAcceptFunction::~SocketAcceptFunction() {}
 
 bool SocketAcceptFunction::Prepare() {
   params_ = api::socket::Accept::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
@@ skipping 160 matching lines @@
 
   io_buffer_size_ = data->GetSize();
   io_buffer_ = new net::WrappedIOBuffer(data->GetBuffer());
   return true;
 }
 
 void SocketSendToFunction::AsyncWorkStart() {
   socket_ = GetSocket(socket_id_);
   if (!socket_) {
     error_ = kSocketNotFoundError;
-    SetResult(Value::CreateIntegerValue(-1));
+    SetResult(new base::FundamentalValue(-1));
     AsyncWorkCompleted();
     return;
   }
 
   if (socket_->GetSocketType() == Socket::TYPE_UDP) {
     SocketPermission::CheckParam param(SocketPermissionRequest::UDP_SEND_TO,
         hostname_, port_);
     if (!PermissionsData::CheckAPIPermissionWithParam(
             GetExtension(),
             APIPermission::kSocket,
             &param)) {
       error_ = kPermissionError;
-      SetResult(Value::CreateIntegerValue(-1));
+      SetResult(new base::FundamentalValue(-1));
       AsyncWorkCompleted();
       return;
     }
   }
 
   StartDnsLookup(hostname_);
 }
 
 void SocketSendToFunction::AfterDnsLookup(int lookup_result) {
   if (lookup_result == net::OK) {
     StartSendTo();
   } else {
-    SetResult(Value::CreateIntegerValue(lookup_result));
+    SetResult(new base::FundamentalValue(lookup_result));
     AsyncWorkCompleted();
   }
 }
 
 void SocketSendToFunction::StartSendTo() {
   socket_->SendTo(io_buffer_, io_buffer_size_, resolved_address_, port_,
                   base::Bind(&SocketSendToFunction::OnCompleted, this));
 }
 
 void SocketSendToFunction::OnCompleted(int bytes_written) {
@@ skipping 18 matching lines @@
   bool result = false;
   Socket* socket = GetSocket(params_->socket_id);
   if (socket) {
     int delay = 0;
     if (params_->delay.get())
       delay = *params_->delay;
     result = socket->SetKeepAlive(params_->enable, delay);
   } else {
     error_ = kSocketNotFoundError;
   }
-  SetResult(Value::CreateBooleanValue(result));
+  SetResult(new base::FundamentalValue(result));
 }
 
 SocketSetNoDelayFunction::SocketSetNoDelayFunction() {}
 
 SocketSetNoDelayFunction::~SocketSetNoDelayFunction() {}
 
 bool SocketSetNoDelayFunction::Prepare() {
   params_ = api::socket::SetNoDelay::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketSetNoDelayFunction::Work() {
   bool result = false;
   Socket* socket = GetSocket(params_->socket_id);
   if (socket)
     result = socket->SetNoDelay(params_->no_delay);
   else
     error_ = kSocketNotFoundError;
-  SetResult(Value::CreateBooleanValue(result));
+  SetResult(new base::FundamentalValue(result));
 }
 
 SocketGetInfoFunction::SocketGetInfoFunction() {}
 
 SocketGetInfoFunction::~SocketGetInfoFunction() {}
 
 bool SocketGetInfoFunction::Prepare() {
   params_ = api::socket::GetInfo::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
@@ skipping 91 matching lines @@
   params_ = api::socket::JoinGroup::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketJoinGroupFunction::Work() {
   int result = -1;
   Socket* socket = GetSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
-    SetResult(Value::CreateIntegerValue(result));
+    SetResult(new base::FundamentalValue(result));
     return;
   }
 
   if (socket->GetSocketType() != Socket::TYPE_UDP) {
     error_ = kMulticastSocketTypeError;
-    SetResult(Value::CreateIntegerValue(result));
+    SetResult(new base::FundamentalValue(result));
     return;
   }
 
   SocketPermission::CheckParam param(
       SocketPermissionRequest::UDP_MULTICAST_MEMBERSHIP,
       kWildcardAddress,
       kWildcardPort);
 
   if (!PermissionsData::CheckAPIPermissionWithParam(
           GetExtension(), APIPermission::kSocket, &param)) {
     error_ = kPermissionError;
-    SetResult(Value::CreateIntegerValue(result));
+    SetResult(new base::FundamentalValue(result));
     return;
   }
 
   result = static_cast<UDPSocket*>(socket)->JoinGroup(params_->address);
   if (result != 0) {
     error_ = net::ErrorToString(result);
   }
-  SetResult(Value::CreateIntegerValue(result));
+  SetResult(new base::FundamentalValue(result));
 }
 
 SocketLeaveGroupFunction::SocketLeaveGroupFunction() {}
 
 SocketLeaveGroupFunction::~SocketLeaveGroupFunction() {}
 
 bool SocketLeaveGroupFunction::Prepare() {
   params_ = api::socket::LeaveGroup::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketLeaveGroupFunction::Work() {
   int result = -1;
   Socket* socket = GetSocket(params_->socket_id);
 
   if (!socket) {
     error_ = kSocketNotFoundError;
-    SetResult(Value::CreateIntegerValue(result));
+    SetResult(new base::FundamentalValue(result));
     return;
   }
 
   if (socket->GetSocketType() != Socket::TYPE_UDP) {
     error_ = kMulticastSocketTypeError;
-    SetResult(Value::CreateIntegerValue(result));
+    SetResult(new base::FundamentalValue(result));
     return;
   }
 
   SocketPermission::CheckParam param(
       SocketPermissionRequest::UDP_MULTICAST_MEMBERSHIP,
       kWildcardAddress,
       kWildcardPort);
   if (!PermissionsData::CheckAPIPermissionWithParam(GetExtension(),
                                                     APIPermission::kSocket,
                                                     &param)) {
     error_ = kPermissionError;
-    SetResult(Value::CreateIntegerValue(result));
+    SetResult(new base::FundamentalValue(result));
     return;
   }
 
   result = static_cast<UDPSocket*>(socket)->LeaveGroup(params_->address);
   if (result != 0)
     error_ = net::ErrorToString(result);
-  SetResult(Value::CreateIntegerValue(result));
+  SetResult(new base::FundamentalValue(result));
 }
 
 SocketSetMulticastTimeToLiveFunction::SocketSetMulticastTimeToLiveFunction() {}
 
 SocketSetMulticastTimeToLiveFunction::~SocketSetMulticastTimeToLiveFunction() {}
 
 bool SocketSetMulticastTimeToLiveFunction::Prepare() {
   params_ = api::socket::SetMulticastTimeToLive::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 void SocketSetMulticastTimeToLiveFunction::Work() {
   int result = -1;
   Socket* socket = GetSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
-    SetResult(Value::CreateIntegerValue(result));
+    SetResult(new base::FundamentalValue(result));
     return;
   }
 
   if (socket->GetSocketType() != Socket::TYPE_UDP) {
     error_ = kMulticastSocketTypeError;
-    SetResult(Value::CreateIntegerValue(result));
+    SetResult(new base::FundamentalValue(result));
     return;
   }
 
   result = static_cast<UDPSocket*>(socket)->SetMulticastTimeToLive(
       params_->ttl);
   if (result != 0)
     error_ = net::ErrorToString(result);
-  SetResult(Value::CreateIntegerValue(result));
+  SetResult(new base::FundamentalValue(result));
 }
 
 SocketSetMulticastLoopbackModeFunction::
     SocketSetMulticastLoopbackModeFunction() {}
 
 SocketSetMulticastLoopbackModeFunction::
   ~SocketSetMulticastLoopbackModeFunction() {}
 
 bool SocketSetMulticastLoopbackModeFunction::Prepare() {
   params_ = api::socket::SetMulticastLoopbackMode::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketSetMulticastLoopbackModeFunction::Work() {
   int result = -1;
   Socket* socket = GetSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
-    SetResult(Value::CreateIntegerValue(result));
+    SetResult(new base::FundamentalValue(result));
     return;
   }
 
   if (socket->GetSocketType() != Socket::TYPE_UDP) {
     error_ = kMulticastSocketTypeError;
-    SetResult(Value::CreateIntegerValue(result));
+    SetResult(new base::FundamentalValue(result));
     return;
   }
 
   result = static_cast<UDPSocket*>(socket)->
       SetMulticastLoopbackMode(params_->enabled);
   if (result != 0)
     error_ = net::ErrorToString(result);
-  SetResult(Value::CreateIntegerValue(result));
+  SetResult(new base::FundamentalValue(result));
 }
 
 SocketGetJoinedGroupsFunction::SocketGetJoinedGroupsFunction() {}
 
 SocketGetJoinedGroupsFunction::~SocketGetJoinedGroupsFunction() {}
 
 bool SocketGetJoinedGroupsFunction::Prepare() {
   params_ = api::socket::GetJoinedGroups::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketGetJoinedGroupsFunction::Work() {
   int result = -1;
   Socket* socket = GetSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
-    SetResult(Value::CreateIntegerValue(result));
+    SetResult(new base::FundamentalValue(result));
     return;
   }
 
   if (socket->GetSocketType() != Socket::TYPE_UDP) {
     error_ = kMulticastSocketTypeError;
-    SetResult(Value::CreateIntegerValue(result));
+    SetResult(new base::FundamentalValue(result));
     return;
   }
 
   SocketPermission::CheckParam param(
       SocketPermissionRequest::UDP_MULTICAST_MEMBERSHIP,
       kWildcardAddress,
       kWildcardPort);
   if (!PermissionsData::CheckAPIPermissionWithParam(
           GetExtension(),
           APIPermission::kSocket,
           &param)) {
     error_ = kPermissionError;
-    SetResult(Value::CreateIntegerValue(result));
+    SetResult(new base::FundamentalValue(result));
     return;
   }
 
   base::ListValue* values = new base::ListValue();
   values->AppendStrings((std::vector<std::string>&)
       static_cast<UDPSocket*>(socket)->GetJoinedGroups());
   SetResult(values);
 }
 
 }  // namespace extensions