win: Rename CrashpadClient::SetHandler() to SetHandlerIPCPipe()

client/crashpad_client_win.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 97 matching lines @@
 std::wstring FormatArgumentString(const std::string& name,
                                   const std::wstring& value) {
   return std::wstring(L"--") + base::UTF8ToUTF16(name) + L"=" + value;
 }
 
 }  // namespace
 
 namespace crashpad {
 
 CrashpadClient::CrashpadClient()
-    : ipc_port_() {
+    : ipc_pipe_() {
 }
 
 CrashpadClient::~CrashpadClient() {
 }
 
 bool CrashpadClient::StartHandler(
     const base::FilePath& handler,
     const base::FilePath& database,
     const std::string& url,
     const std::map<std::string, std::string>& annotations,
     const std::vector<std::string>& arguments) {
-  DCHECK(ipc_port_.empty());
+  DCHECK(ipc_pipe_.empty());
 
-  ipc_port_ =
+  std::string ipc_pipe =
       base::StringPrintf("\\\\.\\pipe\\crashpad_%d_", GetCurrentProcessId());
   for (int index = 0; index < 16; ++index) {
-    ipc_port_.append(1, static_cast<char>(base::RandInt('A', 'Z')));
+    ipc_pipe.append(1, static_cast<char>(base::RandInt('A', 'Z')));
   }
+  ipc_pipe_ = base::UTF8ToUTF16(ipc_pipe);
 
   std::wstring command_line;
   AppendCommandLineArgument(handler.value(), &command_line);
   for (const std::string& argument : arguments) {
     AppendCommandLineArgument(base::UTF8ToUTF16(argument), &command_line);
   }
   if (!database.value().empty()) {
     AppendCommandLineArgument(FormatArgumentString("database",
                                                    database.value()),
                               &command_line);
   }
   if (!url.empty()) {
     AppendCommandLineArgument(FormatArgumentString("url",
                                                    base::UTF8ToUTF16(url)),
                               &command_line);
   }
   for (const auto& kv : annotations) {
     AppendCommandLineArgument(
         FormatArgumentString("annotation",
                              base::UTF8ToUTF16(kv.first + '=' + kv.second)),
         &command_line);
   }
-  AppendCommandLineArgument(FormatArgumentString("pipe-name",
-                                                 base::UTF8ToUTF16(ipc_port_)),
+  AppendCommandLineArgument(FormatArgumentString("pipe-name", ipc_pipe_),
                             &command_line);
 
   STARTUPINFO startup_info = {};
   startup_info.cb = sizeof(startup_info);
   startup_info.dwFlags = STARTF_USESTDHANDLES;
   startup_info.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
   startup_info.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
   startup_info.hStdError = GetStdHandle(STD_ERROR_HANDLE);
   PROCESS_INFORMATION process_info;
   BOOL rv = CreateProcess(handler.value().c_str(),
@@ skipping 13 matching lines @@
 
   rv = CloseHandle(process_info.hThread);
   PLOG_IF(WARNING, !rv) << "CloseHandle thread";
 
   rv = CloseHandle(process_info.hProcess);
   PLOG_IF(WARNING, !rv) << "CloseHandle process";
 
   return true;
 }
 
-bool CrashpadClient::SetHandler(const std::string& ipc_port) {
-  DCHECK(ipc_port_.empty());
-  DCHECK(!ipc_port.empty());
+bool CrashpadClient::SetHandlerIPCPipe(const std::wstring& ipc_pipe) {
+  DCHECK(ipc_pipe_.empty());
+  DCHECK(!ipc_pipe.empty());
 
-  ipc_port_ = ipc_port;
+  ipc_pipe_ = ipc_pipe;
 
   return true;
 }
 
 bool CrashpadClient::UseHandler() {
-  DCHECK(!ipc_port_.empty());
+  DCHECK(!ipc_pipe_.empty());
   DCHECK_EQ(g_signal_exception, INVALID_HANDLE_VALUE);
   DCHECK_EQ(g_signal_non_crash_dump, INVALID_HANDLE_VALUE);
   DCHECK_EQ(g_non_crash_dump_done, INVALID_HANDLE_VALUE);
   DCHECK(!g_critical_section_with_debug_info.DebugInfo);
 
   ClientToServerMessage message;
   memset(&message, 0, sizeof(message));
   message.type = ClientToServerMessage::kRegister;
   message.registration.version = RegistrationRequest::kMessageVersion;
   message.registration.client_process_id = GetCurrentProcessId();
@@ skipping 10 matching lines @@
   // of the list. But that is not an exported symbol, so on an arbitrary client
   // machine, we don't have a way of getting that pointer.
   if (InitializeCriticalSectionWithDebugInfoIfPossible(
           &g_critical_section_with_debug_info)) {
     message.registration.critical_section_address =
         reinterpret_cast<WinVMAddress>(&g_critical_section_with_debug_info);
   }
 
   ServerToClientMessage response = {0};
 
-  if (!SendToCrashHandlerServer(
-          base::UTF8ToUTF16(ipc_port_), message, &response)) {
+  if (!SendToCrashHandlerServer(ipc_pipe_, message, &response)) {
     return false;
   }
 
   // The server returns these already duplicated to be valid in this process.
   g_signal_exception = reinterpret_cast<HANDLE>(
       static_cast<uintptr_t>(response.registration.request_crash_dump_event));
   g_signal_non_crash_dump = reinterpret_cast<HANDLE>(static_cast<uintptr_t>(
       response.registration.request_non_crash_dump_event));
   g_non_crash_dump_done = reinterpret_cast<HANDLE>(static_cast<uintptr_t>(
       response.registration.non_crash_dump_completed_event));
@@ skipping 52 matching lines @@
       reinterpret_cast<crashpad::WinVMAddress>(&exception_pointers);
 
   bool set_event_result = !!SetEvent(g_signal_non_crash_dump);
   PLOG_IF(ERROR, !set_event_result) << "SetEvent";
 
   DWORD wfso_result = WaitForSingleObject(g_non_crash_dump_done, INFINITE);
   PLOG_IF(ERROR, wfso_result != WAIT_OBJECT_0) << "WaitForSingleObject";
 }
 
 }  // namespace crashpad