Convert //third_party from scoped_ptr to std::unique_ptr

third_party/crashpad/crashpad/test/win/win_child_process.cc

 // Copyright 2015 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 147 matching lines @@
   char c = ' ';
   CheckedWriteFile(WritePipeHandle(), &c, sizeof(c));
 }
 
 // static
 bool WinChildProcess::IsChildProcess() {
   return GetSwitch(kIsMultiprocessChild, nullptr);
 }
 
 // static
-scoped_ptr<WinChildProcess::Handles> WinChildProcess::Launch() {
+std::unique_ptr<WinChildProcess::Handles> WinChildProcess::Launch() {
   // Make pipes for child-to-parent and parent-to-child communication.
-  scoped_ptr<Handles> handles_for_parent(new Handles);
+  std::unique_ptr<Handles> handles_for_parent(new Handles);
   ScopedFileHANDLE read_for_child;
   ScopedFileHANDLE write_for_child;
 
   if (!CreateInheritablePipe(
           &handles_for_parent->read, false, &write_for_child, true)) {
-    return scoped_ptr<Handles>();
+    return std::unique_ptr<Handles>();
   }
 
   if (!CreateInheritablePipe(
           &read_for_child, true, &handles_for_parent->write, false)) {
-    return scoped_ptr<Handles>();
+    return std::unique_ptr<Handles>();
   }
 
   // Build a command line for the child process that tells it only to run the
   // current test, and to pass down the values of the pipe handles.
   const ::testing::TestInfo* const test_info =
       ::testing::UnitTest::GetInstance()->current_test_info();
   std::wstring command_line =
       Paths::Executable().value() + L" " +
       base::UTF8ToUTF16(base::StringPrintf("--gtest_filter=%s.%s %s=0x%x|0x%x",
                                            test_info->test_case_name(),
                                            test_info->name(),
                                            kIsMultiprocessChild,
                                            HandleToInt(write_for_child.get()),
                                            HandleToInt(read_for_child.get())));
 
   // Command-line buffer cannot be constant, per CreateProcess signature.
   handles_for_parent->process = LaunchCommandLine(&command_line[0]);
   if (!handles_for_parent->process.is_valid())
-    return scoped_ptr<Handles>();
+    return std::unique_ptr<Handles>();
 
   // Block until the child process has launched. CreateProcess() returns
   // immediately, and test code expects process initialization to have
   // completed so it can, for example, read the process memory.
   char c;
   if (!LoggingReadFile(handles_for_parent->read.get(), &c, sizeof(c))) {
     ADD_FAILURE() << "LoggedReadFile";
-    return scoped_ptr<Handles>();
+    return std::unique_ptr<Handles>();
   }
 
   if (c != ' ') {
     ADD_FAILURE() << "invalid data read from child";
-    return scoped_ptr<Handles>();
+    return std::unique_ptr<Handles>();
   }
 
   return std::move(handles_for_parent);
 }
 
 FileHandle WinChildProcess::ReadPipeHandle() const {
   return pipe_read_.get();
 }
 
 FileHandle WinChildProcess::WritePipeHandle() const {
   return pipe_write_.get();
 }
 
 void WinChildProcess::CloseReadPipe() {
   pipe_read_.reset();
 }
 
 void WinChildProcess::CloseWritePipe() {
   pipe_write_.reset();
 }
 
 }  // namespace test
 }  // namespace crashpad