Convert //chrome from scoped_ptr to std::unique_ptr

chrome/service/service_ipc_server_unittest.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 "chrome/service/service_ipc_server.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "build/build_config.h"
 #include "chrome/common/service_messages.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_channel_handle.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 81 matching lines @@
   IPC::SyncChannel* GetServerChannel() {
     return server_->channel_.get();
   }
 
  protected:
   FakeServiceIPCServerClient service_process_client_;
   IPC::ChannelHandle channel_handle_;
   base::MessageLoopForUI main_message_loop_;
   base::Thread io_thread_;
   base::WaitableEvent shutdown_event_;
-  scoped_ptr<ServiceIPCServer> server_;
+  std::unique_ptr<ServiceIPCServer> server_;
   FakeChannelListener client_process_channel_listener_;
-  scoped_ptr<IPC::SyncChannel> client_process_channel_;
+  std::unique_ptr<IPC::SyncChannel> client_process_channel_;
 };
 
 ServiceIPCServerTest::ServiceIPCServerTest()
     : channel_handle_(IPC::Channel::GenerateUniqueRandomChannelID()),
       io_thread_("ServiceIPCServerTest IO"),
       shutdown_event_(true /* manual_reset */, false /* initially_signaled */) {
 }
 
 void ServiceIPCServerTest::SetUp() {
   base::Thread::Options options;
@@ skipping 107 matching lines @@
 }
 
 TEST_F(ServiceIPCServerTest, SingleMessageHandler) {
   ConnectClientChannel();
   ASSERT_TRUE(server_->is_ipc_client_connected());
 
   // Verify that a message handler is offered messages not handled by the server
   // itself.
   FakeMessageHandler* handler =
       new FakeMessageHandler(true /* should_handle */);
-  server_->AddMessageHandler(make_scoped_ptr(handler));
+  server_->AddMessageHandler(base::WrapUnique(handler));
   SendToServiceProcess(new ServiceMsg_DisableCloudPrintProxy());
   ASSERT_EQ(1, handler->handle_message_calls_);
 }
 
 TEST_F(ServiceIPCServerTest, MultipleMessageHandlers) {
   ConnectClientChannel();
   ASSERT_TRUE(server_->is_ipc_client_connected());
 
   // If there are multiple handlers they are offered the message in order of
   // being added until it is handled.
   FakeMessageHandler* handler1 =
       new FakeMessageHandler(false /* should_handle */);
-  server_->AddMessageHandler(make_scoped_ptr(handler1));
+  server_->AddMessageHandler(base::WrapUnique(handler1));
   FakeMessageHandler* handler2 =
       new FakeMessageHandler(true /* should_handle */);
-  server_->AddMessageHandler(make_scoped_ptr(handler2));
+  server_->AddMessageHandler(base::WrapUnique(handler2));
   FakeMessageHandler* handler3 =
       new FakeMessageHandler(true /* should_handle */);
-  server_->AddMessageHandler(make_scoped_ptr(handler3));
+  server_->AddMessageHandler(base::WrapUnique(handler3));
   SendToServiceProcess(new ServiceMsg_DisableCloudPrintProxy());
   ASSERT_EQ(1, handler1->handle_message_calls_);
   ASSERT_EQ(1, handler2->handle_message_calls_);
   ASSERT_EQ(0, handler3->handle_message_calls_);
 }