Convert //ppapi to use std::unique_ptr

ppapi/proxy/nacl_message_scanner_unittest.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 <stdint.h>
 
 #include "ipc/ipc_message.h"
 #include "ppapi/proxy/nacl_message_scanner.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/ppapi_proxy_test.h"
@@ skipping 28 matching lines @@
     NaClMessageScanner::FileIOMap::const_iterator it =
         scanner.files_.find(file_io);
     return (it != scanner.files_.end()) ? it->second : NULL;
   }
 
   void OpenQuotaFile(NaClMessageScanner* scanner,
                      PP_Resource file_io,
                      PP_Resource file_system) {
     std::vector<SerializedHandle> unused_handles;
     ResourceMessageReplyParams fio_reply_params(file_io, 0);
-    scoped_ptr<IPC::Message> new_msg_ptr;
+    std::unique_ptr<IPC::Message> new_msg_ptr;
     scanner->ScanMessage(
         PpapiPluginMsg_ResourceReply(
             fio_reply_params,
             PpapiPluginMsg_FileIO_OpenReply(file_system, 0)),
         PpapiPluginMsg_ResourceReply::ID,
         &unused_handles,
         &new_msg_ptr);
     EXPECT_FALSE(new_msg_ptr);
   }
 };
 
 TEST_F(NaClMessageScannerTest, FileOpenClose) {
   NaClMessageScanner test;
   std::vector<SerializedHandle> unused_handles;
   ResourceMessageCallParams fio_call_params(kFileIO, 0);
   ResourceMessageCallParams fs_call_params(kFileSystem, 0);
   ResourceMessageReplyParams fio_reply_params(kFileIO, 0);
   ResourceMessageReplyParams fs_reply_params(kFileSystem, 0);
-  scoped_ptr<IPC::Message> new_msg_ptr;
+  std::unique_ptr<IPC::Message> new_msg_ptr;
 
   EXPECT_EQ(NULL, FindFileSystem(test, kFileSystem));
   EXPECT_EQ(NULL, FindFileIO(test, kFileIO));
 
   // Open a file, not in a quota file system.
   test.ScanMessage(
       PpapiPluginMsg_ResourceReply(
           fio_reply_params,
           PpapiPluginMsg_FileIO_OpenReply(kInvalidResource, 0)),
       PpapiPluginMsg_ResourceReply::ID,
@@ skipping 57 matching lines @@
   EXPECT_FALSE(FindFileSystem(test, kFileSystem));
 }
 
 TEST_F(NaClMessageScannerTest, QuotaAuditing) {
   NaClMessageScanner test;
   std::vector<SerializedHandle> unused_handles;
   ResourceMessageCallParams fio_call_params(kFileIO, 0);
   ResourceMessageCallParams fs_call_params(kFileSystem, 0);
   ResourceMessageReplyParams fio_reply_params(kFileIO, 0);
   ResourceMessageReplyParams fs_reply_params(kFileSystem, 0);
-  scoped_ptr<IPC::Message> new_msg_ptr;
+  std::unique_ptr<IPC::Message> new_msg_ptr;
 
   OpenQuotaFile(&test, kFileIO, kFileSystem);
   NaClMessageScanner::FileSystem* fs = FindFileSystem(test, kFileSystem);
   NaClMessageScanner::FileIO* fio = FindFileIO(test, kFileIO);
   EXPECT_TRUE(fs);
   EXPECT_EQ(0, fs->reserved_quota());
   EXPECT_TRUE(fio);
   EXPECT_EQ(0, fio->max_written_offset());
 
   // Without reserving quota, we should not be able to grow the file.
@@ skipping 51 matching lines @@
   EXPECT_EQ(kNewFileSize + 1, new_file_growths[kFileIO].max_written_offset);
 }
 
 TEST_F(NaClMessageScannerTest, SetLength) {
   NaClMessageScanner test;
   std::vector<SerializedHandle> unused_handles;
   ResourceMessageCallParams fio_call_params(kFileIO, 0);
   ResourceMessageCallParams fs_call_params(kFileSystem, 0);
   ResourceMessageReplyParams fio_reply_params(kFileIO, 0);
   ResourceMessageReplyParams fs_reply_params(kFileSystem, 0);
-  scoped_ptr<IPC::Message> new_msg_ptr;
+  std::unique_ptr<IPC::Message> new_msg_ptr;
 
   OpenQuotaFile(&test, kFileIO, kFileSystem);
   NaClMessageScanner::FileSystem* fs = FindFileSystem(test, kFileSystem);
   NaClMessageScanner::FileIO* fio = FindFileIO(test, kFileIO);
 
   // Receive reserved quota, and updated file sizes.
   const int64_t kNewFileSize = 10;
   FileSizeMap file_sizes;
   file_sizes[kFileIO] = 0;
   test.ScanMessage(
@@ skipping 32 matching lines @@
               UnpackMessage<PpapiHostMsg_FileIO_SetLength>(
                   nested_msg, &length));
   new_msg_ptr.reset();
   EXPECT_EQ(-1, length);
   EXPECT_EQ(kQuotaReservationAmount - kNewFileSize, fs->reserved_quota());
   EXPECT_EQ(kNewFileSize, fio->max_written_offset());
 }
 
 }  // namespace proxy
 }  // namespace ppapi