Some easy conversions of scoped_ptr -> std::unique_ptr in the EDK.

mojo/edk/system/remote_message_pipe_unittest.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 <stdint.h>
 #include <stdio.h>
 #include <string.h>
 
+#include <memory>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
@@ skipping 311 matching lines @@
   // receiving this message, |PassIncomingMessagePipe()| is used to obtain the
   // message pipe on the other side.
   scoped_refptr<MessagePipe> mp2(MessagePipe::CreateLocalLocal());
   ASSERT_TRUE(channels(0));
   size_t max_endpoint_info_size;
   size_t max_platform_handle_count;
   mp2->StartSerialize(1, channels(0), &max_endpoint_info_size,
                       &max_platform_handle_count);
   EXPECT_GT(max_endpoint_info_size, 0u);
   ASSERT_EQ(0u, max_platform_handle_count);
-  scoped_ptr<char[]> endpoint_info(new char[max_endpoint_info_size]);
+  std::unique_ptr<char[]> endpoint_info(new char[max_endpoint_info_size]);
   size_t endpoint_info_size;
   mp2->EndSerialize(1, channels(0), endpoint_info.get(), &endpoint_info_size,
                     nullptr);
   EXPECT_EQ(max_endpoint_info_size, endpoint_info_size);
 
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
       mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   EXPECT_EQ(MOJO_RESULT_OK,
             mp0->WriteMessage(0, UserPointer<const void>(endpoint_info.get()),
                               static_cast<uint32_t>(endpoint_info_size),
                               nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
   mp1->RemoveAwakable(1, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
 
   EXPECT_EQ(endpoint_info_size, channels(1)->GetSerializedEndpointSize());
-  scoped_ptr<char[]> received_endpoint_info(new char[endpoint_info_size]);
+  std::unique_ptr<char[]> received_endpoint_info(new char[endpoint_info_size]);
   buffer_size = static_cast<uint32_t>(endpoint_info_size);
   EXPECT_EQ(MOJO_RESULT_OK,
             mp1->ReadMessage(1, UserPointer<void>(received_endpoint_info.get()),
                              MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(endpoint_info_size, static_cast<size_t>(buffer_size));
   EXPECT_EQ(0, memcmp(received_endpoint_info.get(), endpoint_info.get(),
                       endpoint_info_size));
 
   // Warning: The local side of mp3 is port 0, not port 1.
@@ skipping 980 matching lines @@
   mp0->Close(0);
   mp1->Close(1);
   EXPECT_EQ(MOJO_RESULT_OK, dispatcher->Close());
   // Note that |local_mp|'s port 0 belong to |dispatcher|, which was closed.
   local_mp->Close(1);
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo