win: crashpad_handler should create its own pipe name in ephemeral mode

snapshot/win/exception_snapshot_win_test.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,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "snapshot/win/exception_snapshot_win.h"
 
 #include <string>
 
 #include "base/files/file_path.h"
-#include "base/strings/stringprintf.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "client/crashpad_client.h"
 #include "gtest/gtest.h"
 #include "snapshot/win/process_snapshot_win.h"
 #include "test/paths.h"
 #include "test/win/child_launcher.h"
 #include "util/file/file_io.h"
 #include "util/thread/thread.h"
 #include "util/win/exception_handler_server.h"
 #include "util/win/registration_protocol_win.h"
 #include "util/win/scoped_handle.h"
 #include "util/win/scoped_process_suspend.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
 // Runs the ExceptionHandlerServer on a background thread.
 class RunServerThread : public Thread {
  public:
-  // Instantiates a thread which will invoke server->Run(delegate, pipe_name);
+  // Instantiates a thread which will invoke server->Run(delegate);
   RunServerThread(ExceptionHandlerServer* server,
                   ExceptionHandlerServer::Delegate* delegate)
       : server_(server), delegate_(delegate) {}
   ~RunServerThread() override {}
 
  private:
   // Thread:
   void ThreadMain() override { server_->Run(delegate_); }
 
   ExceptionHandlerServer* server_;
@@ skipping 62 matching lines @@
  private:
   HANDLE server_ready_;  // weak
   HANDLE completed_test_event_;  // weak
   WinVMAddress break_near_;
 
   DISALLOW_COPY_AND_ASSIGN(CrashingDelegate);
 };
 
 void TestCrashingChild(const base::string16& directory_modification) {
   // Set up the registration server on a background thread.
-  std::string pipe_name = "\\\\.\\pipe\\handler_test_pipe_" +
-                          base::StringPrintf("%08x", GetCurrentProcessId());
   ScopedKernelHANDLE server_ready(CreateEvent(nullptr, false, false, nullptr));
   ScopedKernelHANDLE completed(CreateEvent(nullptr, false, false, nullptr));
   CrashingDelegate delegate(server_ready.get(), completed.get());
 
-  ExceptionHandlerServer exception_handler_server(pipe_name, true);
+  ExceptionHandlerServer exception_handler_server(true);
+  std::wstring pipe_name = exception_handler_server.CreatePipe();
   RunServerThread server_thread(&exception_handler_server, &delegate);
   server_thread.Start();
   ScopedStopServerAndJoinThread scoped_stop_server_and_join_thread(
       &exception_handler_server, &server_thread);
 
   WaitForSingleObject(server_ready.get(), INFINITE);
 
   // Spawn a child process, passing it the pipe name to connect to.
   base::FilePath test_executable = Paths::Executable();
   std::wstring child_test_executable =
       test_executable.DirName()
           .Append(directory_modification)
           .Append(test_executable.BaseName().RemoveFinalExtension().value() +
                   L"_crashing_child.exe")
           .value();
-  ChildLauncher child(child_test_executable, base::UTF8ToUTF16(pipe_name));
+  ChildLauncher child(child_test_executable, pipe_name);
   child.Start();
 
   // The child tells us (approximately) where it will crash.
   WinVMAddress break_near_address;
   LoggingReadFile(child.stdout_read_handle(),
                   &break_near_address,
                   sizeof(break_near_address));
   delegate.set_break_near(break_near_address);
 
   // Wait for the child to crash and the exception information to be validated.
@@ skipping 59 matching lines @@
   HANDLE server_ready_;  // weak
   HANDLE completed_test_event_;  // weak
   WinVMAddress dump_near_;
 
   DISALLOW_COPY_AND_ASSIGN(SimulateDelegate);
 };
 
 void TestDumpWithoutCrashingChild(
     const base::string16& directory_modification) {
   // Set up the registration server on a background thread.
-  std::string pipe_name = "\\\\.\\pipe\\handler_test_pipe_" +
-                          base::StringPrintf("%08x", GetCurrentProcessId());
   ScopedKernelHANDLE server_ready(CreateEvent(nullptr, false, false, nullptr));
   ScopedKernelHANDLE completed(CreateEvent(nullptr, false, false, nullptr));
   SimulateDelegate delegate(server_ready.get(), completed.get());
 
-  ExceptionHandlerServer exception_handler_server(pipe_name, true);
+  ExceptionHandlerServer exception_handler_server(true);
+  std::wstring pipe_name = exception_handler_server.CreatePipe();
   RunServerThread server_thread(&exception_handler_server, &delegate);
   server_thread.Start();
   ScopedStopServerAndJoinThread scoped_stop_server_and_join_thread(
       &exception_handler_server, &server_thread);
 
   WaitForSingleObject(server_ready.get(), INFINITE);
 
   // Spawn a child process, passing it the pipe name to connect to.
   base::FilePath test_executable = Paths::Executable();
   std::wstring child_test_executable =
       test_executable.DirName()
           .Append(directory_modification)
           .Append(test_executable.BaseName().RemoveFinalExtension().value() +
                   L"_dump_without_crashing.exe")
           .value();
-  ChildLauncher child(child_test_executable, base::UTF8ToUTF16(pipe_name));
+  ChildLauncher child(child_test_executable, pipe_name);
   child.Start();
 
   // The child tells us (approximately) where it will capture a dump.
   WinVMAddress dump_near_address;
   LoggingReadFile(child.stdout_read_handle(),
                   &dump_near_address,
                   sizeof(dump_near_address));
   delegate.set_dump_near(dump_near_address);
 
   // Wait for the child to crash and the exception information to be validated.
@@ skipping 10 matching lines @@
   TestDumpWithoutCrashingChild(FILE_PATH_LITERAL("..\\..\\out\\Debug"));
 #else
   TestDumpWithoutCrashingChild(FILE_PATH_LITERAL("..\\..\\out\\Release"));
 #endif
 }
 #endif  // ARCH_CPU_64_BITS
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad