Remove ExtensionFunction::SetResult(T*) overload.

extensions/browser/api/socket/socket_api.cc

 // Copyright 2014 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 "extensions/browser/api/socket/socket_api.h"
 
+#include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
+#include "base/memory/ptr_util.h"
 #include "build/build_config.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/storage_partition.h"
 #include "extensions/browser/api/dns/host_resolver_wrapper.h"
 #include "extensions/browser/api/socket/socket.h"
 #include "extensions/browser/api/socket/tcp_socket.h"
 #include "extensions/browser/api/socket/tls_socket.h"
 #include "extensions/browser/api/socket/udp_socket.h"
 #include "extensions/browser/extension_system.h"
@@ skipping 82 matching lines @@
 
 void SocketAsyncApiFunction::OpenFirewallHole(const std::string& address,
                                               int socket_id,
                                               Socket* socket) {
 #if defined(OS_CHROMEOS)
   if (!net::IsLocalhost(address)) {
     net::IPEndPoint local_address;
     if (!socket->GetLocalAddress(&local_address)) {
       NOTREACHED() << "Cannot get address of recently bound socket.";
       error_ = kFirewallFailure;
-      SetResult(new base::FundamentalValue(-1));
+      SetResult(base::MakeUnique<base::FundamentalValue>(-1));
       AsyncWorkCompleted();
       return;
     }
 
     AppFirewallHole::PortType type = socket->GetSocketType() == Socket::TYPE_TCP
                                          ? AppFirewallHole::PortType::TCP
                                          : AppFirewallHole::PortType::UDP;
 
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
@@ skipping 21 matching lines @@
       base::Bind(&SocketAsyncApiFunction::OnFirewallHoleOpened, this, socket_id,
                  base::Passed(&hole)));
 }
 
 void SocketAsyncApiFunction::OnFirewallHoleOpened(
     int socket_id,
     std::unique_ptr<AppFirewallHole, BrowserThread::DeleteOnUIThread> hole) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!hole) {
     error_ = kFirewallFailure;
-    SetResult(new base::FundamentalValue(-1));
+    SetResult(base::MakeUnique<base::FundamentalValue>(-1));
     AsyncWorkCompleted();
     return;
   }
 
   Socket* socket = GetSocket(socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
-    SetResult(new base::FundamentalValue(-1));
+    SetResult(base::MakeUnique<base::FundamentalValue>(-1));
     AsyncWorkCompleted();
     return;
   }
 
   socket->set_firewall_hole(std::move(hole));
   AsyncWorkCompleted();
 }
 
 #endif  // OS_CHROMEOS
 
@@ skipping 65 matching lines @@
 
 void SocketCreateFunction::Work() {
   Socket* socket = NULL;
   if (socket_type_ == kSocketTypeTCP) {
     socket = new TCPSocket(extension_->id());
   } else if (socket_type_ == kSocketTypeUDP) {
     socket = new UDPSocket(extension_->id());
   }
   DCHECK(socket);
 
-  base::DictionaryValue* result = new base::DictionaryValue();
+  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
   result->SetInteger(kSocketIdKey, AddSocket(socket));
-  SetResult(result);
+  SetResult(std::move(result));
 }
 
 bool SocketDestroyFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
   return true;
 }
 
 void SocketDestroyFunction::Work() { RemoveSocket(socket_id_); }
 
 SocketConnectFunction::SocketConnectFunction()
     : socket_id_(0), hostname_(), port_(0) {
 }
 
 SocketConnectFunction::~SocketConnectFunction() {}
 
 bool SocketConnectFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &hostname_));
   int port;
   EXTENSION_FUNCTION_VALIDATE(
       args_->GetInteger(2, &port) && port >= 0 && port <= 65535);
   port_ = static_cast<uint16_t>(port);
   return true;
 }
 
 void SocketConnectFunction::AsyncWorkStart() {
   Socket* socket = GetSocket(socket_id_);
   if (!socket) {
     error_ = kSocketNotFoundError;
-    SetResult(new base::FundamentalValue(-1));
+    SetResult(base::MakeUnique<base::FundamentalValue>(-1));
     AsyncWorkCompleted();
     return;
   }
 
   socket->set_hostname(hostname_);
 
   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 (!extension()->permissions_data()->CheckAPIPermissionWithParam(
           APIPermission::kSocket, &param)) {
     error_ = kPermissionError;
-    SetResult(new base::FundamentalValue(-1));
+    SetResult(base::MakeUnique<base::FundamentalValue>(-1));
     AsyncWorkCompleted();
     return;
   }
 
   StartDnsLookup(net::HostPortPair(hostname_, port_));
 }
 
 void SocketConnectFunction::AfterDnsLookup(int lookup_result) {
   if (lookup_result == net::OK) {
     StartConnect();
   } else {
-    SetResult(new base::FundamentalValue(lookup_result));
+    SetResult(base::MakeUnique<base::FundamentalValue>(lookup_result));
     AsyncWorkCompleted();
   }
 }
 
 void SocketConnectFunction::StartConnect() {
   Socket* socket = GetSocket(socket_id_);
   if (!socket) {
     error_ = kSocketNotFoundError;
-    SetResult(new base::FundamentalValue(-1));
+    SetResult(base::MakeUnique<base::FundamentalValue>(-1));
     AsyncWorkCompleted();
     return;
   }
 
   socket->Connect(addresses_,
                   base::Bind(&SocketConnectFunction::OnConnect, this));
 }
 
 void SocketConnectFunction::OnConnect(int result) {
-  SetResult(new base::FundamentalValue(result));
+  SetResult(base::MakeUnique<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 11 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(
       args_->GetInteger(2, &port) && port >= 0 && port <= 65535);
   port_ = static_cast<uint16_t>(port);
   return true;
 }
 
 void SocketBindFunction::AsyncWorkStart() {
   Socket* socket = GetSocket(socket_id_);
   if (!socket) {
     error_ = kSocketNotFoundError;
-    SetResult(new base::FundamentalValue(-1));
+    SetResult(base::MakeUnique<base::FundamentalValue>(-1));
     AsyncWorkCompleted();
     return;
   }
 
   if (socket->GetSocketType() == Socket::TYPE_TCP) {
     error_ = kTCPSocketBindError;
-    SetResult(new base::FundamentalValue(-1));
+    SetResult(base::MakeUnique<base::FundamentalValue>(-1));
     AsyncWorkCompleted();
     return;
   }
 
   CHECK(socket->GetSocketType() == Socket::TYPE_UDP);
   SocketPermission::CheckParam param(SocketPermissionRequest::UDP_BIND,
                                      address_, port_);
   if (!extension()->permissions_data()->CheckAPIPermissionWithParam(
           APIPermission::kSocket, &param)) {
     error_ = kPermissionError;
-    SetResult(new base::FundamentalValue(-1));
+    SetResult(base::MakeUnique<base::FundamentalValue>(-1));
     AsyncWorkCompleted();
     return;
   }
 
   int result = socket->Bind(address_, port_);
-  SetResult(new base::FundamentalValue(result));
+  SetResult(base::MakeUnique<base::FundamentalValue>(result));
   if (result != net::OK) {
     AsyncWorkCompleted();
     return;
   }
 
   OpenFirewallHole(address_, socket_id_, socket);
 }
 
 SocketListenFunction::SocketListenFunction() {}
 
 SocketListenFunction::~SocketListenFunction() {}
 
 bool SocketListenFunction::Prepare() {
   params_ = api::socket::Listen::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketListenFunction::AsyncWorkStart() {
   Socket* socket = GetSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
-    SetResult(new base::FundamentalValue(-1));
+    SetResult(base::MakeUnique<base::FundamentalValue>(-1));
     AsyncWorkCompleted();
     return;
   }
 
   SocketPermission::CheckParam param(SocketPermissionRequest::TCP_LISTEN,
                                      params_->address, params_->port);
   if (!extension()->permissions_data()->CheckAPIPermissionWithParam(
           APIPermission::kSocket, &param)) {
     error_ = kPermissionError;
-    SetResult(new base::FundamentalValue(-1));
+    SetResult(base::MakeUnique<base::FundamentalValue>(-1));
     AsyncWorkCompleted();
     return;
   }
 
   int result = socket->Listen(
       params_->address, params_->port,
       params_->backlog.get() ? *params_->backlog.get() : 5, &error_);
-  SetResult(new base::FundamentalValue(result));
+  SetResult(base::MakeUnique<base::FundamentalValue>(result));
   if (result != net::OK) {
     AsyncWorkCompleted();
     return;
   }
 
   OpenFirewallHole(params_->address, params_->socket_id, socket);
 }
 
 SocketAcceptFunction::SocketAcceptFunction() {}
 
@@ skipping 11 matching lines @@
     socket->Accept(base::Bind(&SocketAcceptFunction::OnAccept, this));
   } else {
     error_ = kSocketNotFoundError;
     OnAccept(-1, NULL);
   }
 }
 
 void SocketAcceptFunction::OnAccept(
     int result_code,
     std::unique_ptr<net::TCPClientSocket> socket) {
-  base::DictionaryValue* result = new base::DictionaryValue();
+  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
   result->SetInteger(kResultCodeKey, result_code);
   if (socket) {
     Socket* client_socket =
         new TCPSocket(std::move(socket), extension_id(), true);
     result->SetInteger(kSocketIdKey, AddSocket(client_socket));
   }
-  SetResult(result);
+  SetResult(std::move(result));
 
   AsyncWorkCompleted();
 }
 
 SocketReadFunction::SocketReadFunction() {}
 
 SocketReadFunction::~SocketReadFunction() {}
 
 bool SocketReadFunction::Prepare() {
   params_ = api::socket::Read::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketReadFunction::AsyncWorkStart() {
   Socket* socket = GetSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
     OnCompleted(-1, NULL);
     return;
   }
 
   socket->Read(params_->buffer_size.get() ? *params_->buffer_size.get() : 4096,
                base::Bind(&SocketReadFunction::OnCompleted, this));
 }
 
 void SocketReadFunction::OnCompleted(int bytes_read,
                                      scoped_refptr<net::IOBuffer> io_buffer) {
-  base::DictionaryValue* result = new base::DictionaryValue();
+  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
   result->SetInteger(kResultCodeKey, bytes_read);
   if (bytes_read > 0) {
     result->Set(kDataKey,
                 base::BinaryValue::CreateWithCopiedBuffer(io_buffer->data(),
                                                           bytes_read));
   } else {
     result->Set(kDataKey, new base::BinaryValue());
   }
-  SetResult(result);
+  SetResult(std::move(result));
 
   AsyncWorkCompleted();
 }
 
 SocketWriteFunction::SocketWriteFunction()
     : socket_id_(0), io_buffer_(NULL), io_buffer_size_(0) {}
 
 SocketWriteFunction::~SocketWriteFunction() {}
 
 bool SocketWriteFunction::Prepare() {
@@ skipping 14 matching lines @@
     OnCompleted(-1);
     return;
   }
 
   socket->Write(io_buffer_,
                 io_buffer_size_,
                 base::Bind(&SocketWriteFunction::OnCompleted, this));
 }
 
 void SocketWriteFunction::OnCompleted(int bytes_written) {
-  base::DictionaryValue* result = new base::DictionaryValue();
+  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
   result->SetInteger(kBytesWrittenKey, bytes_written);
-  SetResult(result);
+  SetResult(std::move(result));
 
   AsyncWorkCompleted();
 }
 
 SocketRecvFromFunction::SocketRecvFromFunction() {}
 
 SocketRecvFromFunction::~SocketRecvFromFunction() {}
 
 bool SocketRecvFromFunction::Prepare() {
   params_ = api::socket::RecvFrom::Params::Create(*args_);
@@ skipping 10 matching lines @@
   }
 
   socket->RecvFrom(params_->buffer_size.get() ? *params_->buffer_size : 4096,
                    base::Bind(&SocketRecvFromFunction::OnCompleted, this));
 }
 
 void SocketRecvFromFunction::OnCompleted(int bytes_read,
                                          scoped_refptr<net::IOBuffer> io_buffer,
                                          const std::string& address,
                                          uint16_t port) {
-  base::DictionaryValue* result = new base::DictionaryValue();
+  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
   result->SetInteger(kResultCodeKey, bytes_read);
   if (bytes_read > 0) {
     result->Set(kDataKey,
                 base::BinaryValue::CreateWithCopiedBuffer(io_buffer->data(),
                                                           bytes_read));
   } else {
     result->Set(kDataKey, new base::BinaryValue());
   }
   result->SetString(kAddressKey, address);
   result->SetInteger(kPortKey, port);
-  SetResult(result);
+  SetResult(std::move(result));
 
   AsyncWorkCompleted();
 }
 
 SocketSendToFunction::SocketSendToFunction()
     : socket_id_(0), io_buffer_(NULL), io_buffer_size_(0), port_(0) {
 }
 
 SocketSendToFunction::~SocketSendToFunction() {}
 
 bool SocketSendToFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
   base::BinaryValue* data = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetBinary(1, &data));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(2, &hostname_));
   int port;
   EXTENSION_FUNCTION_VALIDATE(
       args_->GetInteger(3, &port) && port >= 0 && port <= 65535);
   port_ = static_cast<uint16_t>(port);
 
   io_buffer_size_ = data->GetSize();
   io_buffer_ = new net::WrappedIOBuffer(data->GetBuffer());
   return true;
 }
 
 void SocketSendToFunction::AsyncWorkStart() {
   Socket* socket = GetSocket(socket_id_);
   if (!socket) {
     error_ = kSocketNotFoundError;
-    SetResult(new base::FundamentalValue(-1));
+    SetResult(base::MakeUnique<base::FundamentalValue>(-1));
     AsyncWorkCompleted();
     return;
   }
 
   if (socket->GetSocketType() == Socket::TYPE_UDP) {
     SocketPermission::CheckParam param(
         SocketPermissionRequest::UDP_SEND_TO, hostname_, port_);
     if (!extension()->permissions_data()->CheckAPIPermissionWithParam(
             APIPermission::kSocket, &param)) {
       error_ = kPermissionError;
-      SetResult(new base::FundamentalValue(-1));
+      SetResult(base::MakeUnique<base::FundamentalValue>(-1));
       AsyncWorkCompleted();
       return;
     }
   }
 
   StartDnsLookup(net::HostPortPair(hostname_, port_));
 }
 
 void SocketSendToFunction::AfterDnsLookup(int lookup_result) {
   if (lookup_result == net::OK) {
     StartSendTo();
   } else {
-    SetResult(new base::FundamentalValue(lookup_result));
+    SetResult(base::MakeUnique<base::FundamentalValue>(lookup_result));
     AsyncWorkCompleted();
   }
 }
 
 void SocketSendToFunction::StartSendTo() {
   Socket* socket = GetSocket(socket_id_);
   if (!socket) {
     error_ = kSocketNotFoundError;
-    SetResult(new base::FundamentalValue(-1));
+    SetResult(base::MakeUnique<base::FundamentalValue>(-1));
     AsyncWorkCompleted();
     return;
   }
 
   socket->SendTo(io_buffer_, io_buffer_size_, addresses_.front(),
                  base::Bind(&SocketSendToFunction::OnCompleted, this));
 }
 
 void SocketSendToFunction::OnCompleted(int bytes_written) {
-  base::DictionaryValue* result = new base::DictionaryValue();
+  std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
   result->SetInteger(kBytesWrittenKey, bytes_written);
-  SetResult(result);
+  SetResult(std::move(result));
 
   AsyncWorkCompleted();
 }
 
 SocketSetKeepAliveFunction::SocketSetKeepAliveFunction() {}
 
 SocketSetKeepAliveFunction::~SocketSetKeepAliveFunction() {}
 
 bool SocketSetKeepAliveFunction::Prepare() {
   params_ = api::socket::SetKeepAlive::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketSetKeepAliveFunction::Work() {
   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(new base::FundamentalValue(result));
+  SetResult(base::MakeUnique<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(new base::FundamentalValue(result));
+  SetResult(base::MakeUnique<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 26 matching lines @@
   }
 
   // Grab the local address as known by the OS.
   net::IPEndPoint localAddress;
   if (socket->GetLocalAddress(&localAddress)) {
     info.local_address.reset(
         new std::string(localAddress.ToStringWithoutPort()));
     info.local_port.reset(new int(localAddress.port()));
   }
 
-  SetResult(info.ToValue().release());
+  SetResult(info.ToValue());
 }
 
 bool SocketGetNetworkListFunction::RunAsync() {
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&SocketGetNetworkListFunction::GetNetworkListOnFileThread,
                  this));
   return true;
 }
 
@@ skipping 46 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(new base::FundamentalValue(result));
+    SetResult(base::MakeUnique<base::FundamentalValue>(result));
     return;
   }
 
   if (socket->GetSocketType() != Socket::TYPE_UDP) {
     error_ = kMulticastSocketTypeError;
-    SetResult(new base::FundamentalValue(result));
+    SetResult(base::MakeUnique<base::FundamentalValue>(result));
     return;
   }
 
   SocketPermission::CheckParam param(
       SocketPermissionRequest::UDP_MULTICAST_MEMBERSHIP,
       kWildcardAddress,
       kWildcardPort);
 
   if (!extension()->permissions_data()->CheckAPIPermissionWithParam(
           APIPermission::kSocket, &param)) {
     error_ = kPermissionError;
-    SetResult(new base::FundamentalValue(result));
+    SetResult(base::MakeUnique<base::FundamentalValue>(result));
     return;
   }
 
   result = static_cast<UDPSocket*>(socket)->JoinGroup(params_->address);
   if (result != 0) {
     error_ = net::ErrorToString(result);
   }
-  SetResult(new base::FundamentalValue(result));
+  SetResult(base::MakeUnique<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(new base::FundamentalValue(result));
+    SetResult(base::MakeUnique<base::FundamentalValue>(result));
     return;
   }
 
   if (socket->GetSocketType() != Socket::TYPE_UDP) {
     error_ = kMulticastSocketTypeError;
-    SetResult(new base::FundamentalValue(result));
+    SetResult(base::MakeUnique<base::FundamentalValue>(result));
     return;
   }
 
   SocketPermission::CheckParam param(
       SocketPermissionRequest::UDP_MULTICAST_MEMBERSHIP,
       kWildcardAddress,
       kWildcardPort);
   if (!extension()->permissions_data()->CheckAPIPermissionWithParam(
           APIPermission::kSocket, &param)) {
     error_ = kPermissionError;
-    SetResult(new base::FundamentalValue(result));
+    SetResult(base::MakeUnique<base::FundamentalValue>(result));
     return;
   }
 
   result = static_cast<UDPSocket*>(socket)->LeaveGroup(params_->address);
   if (result != 0)
     error_ = net::ErrorToString(result);
-  SetResult(new base::FundamentalValue(result));
+  SetResult(base::MakeUnique<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(new base::FundamentalValue(result));
+    SetResult(base::MakeUnique<base::FundamentalValue>(result));
     return;
   }
 
   if (socket->GetSocketType() != Socket::TYPE_UDP) {
     error_ = kMulticastSocketTypeError;
-    SetResult(new base::FundamentalValue(result));
+    SetResult(base::MakeUnique<base::FundamentalValue>(result));
     return;
   }
 
   result =
       static_cast<UDPSocket*>(socket)->SetMulticastTimeToLive(params_->ttl);
   if (result != 0)
     error_ = net::ErrorToString(result);
-  SetResult(new base::FundamentalValue(result));
+  SetResult(base::MakeUnique<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(new base::FundamentalValue(result));
+    SetResult(base::MakeUnique<base::FundamentalValue>(result));
     return;
   }
 
   if (socket->GetSocketType() != Socket::TYPE_UDP) {
     error_ = kMulticastSocketTypeError;
-    SetResult(new base::FundamentalValue(result));
+    SetResult(base::MakeUnique<base::FundamentalValue>(result));
     return;
   }
 
   result = static_cast<UDPSocket*>(socket)
                ->SetMulticastLoopbackMode(params_->enabled);
   if (result != 0)
     error_ = net::ErrorToString(result);
-  SetResult(new base::FundamentalValue(result));
+  SetResult(base::MakeUnique<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(new base::FundamentalValue(result));
+    SetResult(base::MakeUnique<base::FundamentalValue>(result));
     return;
   }
 
   if (socket->GetSocketType() != Socket::TYPE_UDP) {
     error_ = kMulticastSocketTypeError;
-    SetResult(new base::FundamentalValue(result));
+    SetResult(base::MakeUnique<base::FundamentalValue>(result));
     return;
   }
 
   SocketPermission::CheckParam param(
       SocketPermissionRequest::UDP_MULTICAST_MEMBERSHIP,
       kWildcardAddress,
       kWildcardPort);
   if (!extension()->permissions_data()->CheckAPIPermissionWithParam(
           APIPermission::kSocket, &param)) {
     error_ = kPermissionError;
-    SetResult(new base::FundamentalValue(result));
+    SetResult(base::MakeUnique<base::FundamentalValue>(result));
     return;
   }
 
-  base::ListValue* values = new base::ListValue();
+  std::unique_ptr<base::ListValue> values(new base::ListValue());
   values->AppendStrings((std::vector<std::string>&)static_cast<UDPSocket*>(
                             socket)->GetJoinedGroups());
-  SetResult(values);
+  SetResult(std::move(values));
 }
 
 SocketSecureFunction::SocketSecureFunction() {
 }
 
 SocketSecureFunction::~SocketSecureFunction() {
 }
 
 bool SocketSecureFunction::Prepare() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   params_ = api::socket::Secure::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   url_request_getter_ = content::BrowserContext::GetDefaultStoragePartition(
       browser_context())->GetURLRequestContext();
   return true;
 }
 
 // Override the regular implementation, which would call AsyncWorkCompleted
 // immediately after Work().
 void SocketSecureFunction::AsyncWorkStart() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   Socket* socket = GetSocket(params_->socket_id);
   if (!socket) {
-    SetResult(new base::FundamentalValue(net::ERR_INVALID_ARGUMENT));
+    SetResult(
+        base::MakeUnique<base::FundamentalValue>(net::ERR_INVALID_ARGUMENT));
     error_ = kSocketNotFoundError;
     AsyncWorkCompleted();
     return;
   }
 
   // Make sure that the socket is a TCP client socket.
   if (socket->GetSocketType() != Socket::TYPE_TCP ||
       static_cast<TCPSocket*>(socket)->ClientStream() == NULL) {
-    SetResult(new base::FundamentalValue(net::ERR_INVALID_ARGUMENT));
+    SetResult(
+        base::MakeUnique<base::FundamentalValue>(net::ERR_INVALID_ARGUMENT));
     error_ = kSecureSocketTypeError;
     AsyncWorkCompleted();
     return;
   }
 
   if (!socket->IsConnected()) {
-    SetResult(new base::FundamentalValue(net::ERR_INVALID_ARGUMENT));
+    SetResult(
+        base::MakeUnique<base::FundamentalValue>(net::ERR_INVALID_ARGUMENT));
     error_ = kSocketNotConnectedError;
     AsyncWorkCompleted();
     return;
   }
 
   net::URLRequestContext* url_request_context =
       url_request_getter_->GetURLRequestContext();
 
   TLSSocket::UpgradeSocketToTLS(
       socket,
@@ skipping 15 matching lines @@
   } else {
     RemoveSocket(params_->socket_id);
     error_ = net::ErrorToString(result);
   }
 
   results_ = api::socket::Secure::Results::Create(result);
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions