Convert //ppapi to use std::unique_ptr

ppapi/proxy/udp_socket_filter.cc

 // Copyright 2015 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 "ppapi/proxy/udp_socket_filter.h"
 
 #include <algorithm>
 #include <cstring>
 #include <utility>
 
 #include "base/logging.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/proxy/error_conversion.h"
 #include "ppapi/proxy/plugin_globals.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/resource_creation_api.h"
 
 namespace ppapi {
 namespace proxy {
 
 const int32_t UDPSocketFilter::kMaxReadSize = 128 * 1024;
 const int32_t UDPSocketFilter::kMaxReceiveBufferSize =
     1024 * UDPSocketFilter::kMaxReadSize;
 const size_t UDPSocketFilter::kPluginReceiveBufferSlots = 32u;
 
 namespace {
 
 int32_t SetRecvFromOutput(PP_Instance pp_instance,
-                          const scoped_ptr<std::string>& data,
+                          const std::unique_ptr<std::string>& data,
                           const PP_NetAddress_Private& addr,
                           char* output_buffer,
                           int32_t num_bytes,
                           PP_Resource* output_addr,
                           int32_t browser_result) {
   ProxyLock::AssertAcquired();
   DCHECK_GE(num_bytes, static_cast<int32_t>(data->size()));
 
   int32_t result = browser_result;
   if (result == PP_OK && output_addr) {
@@ skipping 21 matching lines @@
 }
 
 void UDPSocketFilter::AddUDPResource(
     PP_Instance instance,
     PP_Resource resource,
     bool private_api,
     const base::Closure& slot_available_callback) {
   ProxyLock::AssertAcquired();
   base::AutoLock acquire(lock_);
   DCHECK(!queues_.contains(resource));
-  queues_.add(resource, scoped_ptr<RecvQueue>(new RecvQueue(
+  queues_.add(resource, std::unique_ptr<RecvQueue>(new RecvQueue(
                             instance, private_api, slot_available_callback)));
 }
 
 void UDPSocketFilter::RemoveUDPResource(PP_Resource resource) {
   ProxyLock::AssertAcquired();
   base::AutoLock acquire(lock_);
   DCHECK(queues_.contains(resource));
   queues_.erase(resource);
 }
 
@@ skipping 92 matching lines @@
 
     result = PP_ERROR_MESSAGE_TOO_BIG;
   } else {
     // Instead of calling SetRecvFromOutput directly, post it as a completion
     // task, so that:
     // 1) It can run with the ProxyLock (we can't lock it on the IO thread.)
     // 2) So that we only write to the output params in the case of success.
     //    (Since the callback will complete on another thread, it's possible
     //     that the resource will be deleted and abort the callback before it
     //     is actually run.)
-    scoped_ptr<std::string> data_to_pass(new std::string(data));
+    std::unique_ptr<std::string> data_to_pass(new std::string(data));
     recvfrom_callback_->set_completion_task(base::Bind(
         &SetRecvFromOutput, pp_instance_, base::Passed(std::move(data_to_pass)),
         addr, base::Unretained(read_buffer_), bytes_to_read_,
         base::Unretained(recvfrom_addr_resource_)));
     last_recvfrom_addr_ = addr;
     PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
         FROM_HERE,
         RunWhileLocked(slot_available_callback_));
   }
 
@@ skipping 22 matching lines @@
     recvfrom_addr_resource_ = addr_out;
     recvfrom_callback_ = callback;
     return PP_OK_COMPLETIONPENDING;
   } else {
     RecvBuffer& front = recv_buffers_.front();
 
     if (static_cast<size_t>(num_bytes) < front.data.size())
       return PP_ERROR_MESSAGE_TOO_BIG;
 
     int32_t result = static_cast<int32_t>(front.data.size());
-    scoped_ptr<std::string> data_to_pass(new std::string);
+    std::unique_ptr<std::string> data_to_pass(new std::string);
     data_to_pass->swap(front.data);
     SetRecvFromOutput(pp_instance_, std::move(data_to_pass), front.addr,
                       buffer_out, num_bytes, addr_out, PP_OK);
     last_recvfrom_addr_ = front.addr;
     recv_buffers_.pop();
     slot_available_callback_.Run();
 
     return result;
   }
 }
 
 PP_NetAddress_Private UDPSocketFilter::RecvQueue::GetLastAddrPrivate() const {
   CHECK(private_api_);
   return last_recvfrom_addr_;
 }
 
 }  // namespace proxy
 }  // namespace ppapi