Convert //ppapi to use std::unique_ptr

ppapi/proxy/nacl_message_scanner.cc

 // Copyright 2013 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/nacl_message_scanner.h"
 
 #include <stddef.h>
 
 #include <tuple>
 #include <utility>
@@ skipping 27 matching lines @@
 
   // Vector to hold handles found in the message.
   Handles handles;
   // Current handle index in the rewritten message. During the scan, it will be
   // be less than or equal to handles.size(). After the scan it should be equal.
   int handle_index;
   // The rewritten message. This may be NULL, so all ScanParam overloads should
   // check for NULL before writing to it. In some cases, a ScanParam overload
   // may set this to NULL when it can determine that there are no parameters
   // that need conversion. (See the ResourceMessageReplyParams overload.)
-  scoped_ptr<IPC::Message> new_msg;
+  std::unique_ptr<IPC::Message> new_msg;
   // Resource id for resource messages. Save this when scanning resource replies
   // so when we audit the nested message, we know which resource it is for.
   PP_Resource pp_resource;
   // Callback to receive the nested message in a resource message or reply.
   base::Callback<void(PP_Resource, const IPC::Message&, SerializedHandle*)>
       nested_msg_callback;
 };
 
 void WriteHandle(int handle_index,
                  const SerializedHandle& handle,
@@ skipping 272 matching lines @@
 // message body, rather than passed in a separate FileDescriptorSet. Therefore,
 // on Windows, any message containing handles must be rewritten in the POSIX
 // format before we can send it to the NaCl plugin.
 // On Mac, base::SharedMemoryHandle has a different serialization than
 // base::FileDescriptor (which base::SharedMemoryHandle is typedef-ed to in
 // OS_NACL).
 bool NaClMessageScanner::ScanMessage(
     const IPC::Message& msg,
     uint32_t type,
     std::vector<SerializedHandle>* handles,
-    scoped_ptr<IPC::Message>* new_msg_ptr) {
+    std::unique_ptr<IPC::Message>* new_msg_ptr) {
   DCHECK(handles);
   DCHECK(handles->empty());
   DCHECK(new_msg_ptr);
   DCHECK(!new_msg_ptr->get());
 
   bool rewrite_msg =
 #if defined(OS_WIN) || defined(OS_MACOSX)
       true;
 #else
       false;
@@ skipping 30 matching lines @@
   // we ever add new param types that also require rewriting.
   if (!results.handles.empty()) {
     handles->swap(results.handles);
     *new_msg_ptr = std::move(results.new_msg);
   }
   return true;
 }
 
 void NaClMessageScanner::ScanUntrustedMessage(
     const IPC::Message& untrusted_msg,
-    scoped_ptr<IPC::Message>* new_msg_ptr) {
+    std::unique_ptr<IPC::Message>* new_msg_ptr) {
   // Audit FileIO and FileSystem messages to ensure that the plugin doesn't
   // exceed its file quota. If we find the message is malformed, just pass it
   // through - we only care about well formed messages to the host.
   if (untrusted_msg.type() == PpapiHostMsg_ResourceCall::ID) {
     ResourceMessageCallParams params;
     IPC::Message nested_msg;
     if (!UnpackMessage<PpapiHostMsg_ResourceCall>(
             untrusted_msg, &params, &nested_msg))
       return;
 
@@ skipping 156 matching lines @@
             fio_it->second->SetMaxWrittenOffset(offset_it->second);
         }
       }
       break;
     }
   }
 }
 
 }  // namespace proxy
 }  // namespace ppapi