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

client/crashpad_client.h

 // Copyright 2014 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 33 matching lines @@
   //! This method does not actually direct any crashes to the Crashpad handler,
   //! because there may be alternative ways to use an existing Crashpad handler
   //! without having to start one. To begin directing crashes to the handler,
   //! started by this method, call UseHandler() after this method returns
   //! successfully.
   //!
   //! On Mac OS X, this method starts a Crashpad handler and obtains a Mach
   //! send right corresponding to a receive right held by the handler process.
   //! The handler process runs an exception server on this port.
   //!
-  //! On Windows, SetHandler() is normally used instead since the handler is
-  //! started by other means.
-  //!
   //! \param[in] handler The path to a Crashpad handler executable.
   //! \param[in] database The path to a Crashpad database. The handler will be
   //!     started with this path as its `--database` argument.
   //! \param[in] url The URL of an upload server. The handler will be started
   //!     with this URL as its `--url` argument.
   //! \param[in] annotations Process annotations to set in each crash report.
   //!     The handler will be started with an `--annotation` argument for each
   //!     element in this map.
   //! \param[in] arguments Additional arguments to pass to the Crashpad handler.
   //!     Arguments passed in other parameters and arguments required to perform
@@ skipping 11 matching lines @@
   //! \brief Sets the IPC port of a presumably-running Crashpad handler process
   //!     which was started with StartHandler() or by other compatible means
   //!     and does an IPC message exchange to register this process with the
   //!     handler. However, just like StartHandler(), crashes are not serviced
   //!     until UseHandler() is called.
   //!
   //! The IPC port name (somehow) encodes enough information so that
   //! registration is done with a crash handler using the appropriate database
   //! and upload server.
   //!
-  //! \param[in] ipc_port The full name of the crash handler IPC port.
+  //! \param[in] ipc_pipe The full name of the crash handler IPC pipe. This is
+  //!     a string of the form `"\\.\pipe\NAME"`.
   //!
   //! \return `true` on success and `false` on failure.
-  bool SetHandler(const std::string& ipc_port);
+  bool SetHandlerIPCPipe(const std::wstring& ipc_pipe);
 
   //! \brief Requests that the handler capture a dump even though there hasn't
   //!     been a crash.
   //!
   //! \param[in] context A `CONTEXT`, generally captured by CaptureContext() or
   //!     similar.
   static void DumpWithoutCrash(const CONTEXT& context);
 #endif
 
   //! \brief Configures the process to direct its crashes to a Crashpad handler.
   //!
   //! The Crashpad handler must previously have been started by StartHandler()
-  //! or configured by SetHandler().
+  //! or configured by SetHandlerIPCPipe().
   //!
   //! On Mac OS X, this method sets the task’s exception port for `EXC_CRASH`,
   //! `EXC_RESOURCE`, and `EXC_GUARD` exceptions to the Mach send right obtained
   //! by StartHandler(). The handler will be installed with behavior
   //! `EXCEPTION_STATE_IDENTITY | MACH_EXCEPTION_CODES` and thread state flavor
   //! `MACHINE_THREAD_STATE`. Exception ports are inherited, so a Crashpad
   //! handler chosen by UseHandler() will remain the handler for any child
   //! processes created after UseHandler() is called. Child processes do not
   //! need to call StartHandler() or UseHandler() or be aware of Crashpad in any
   //! way. The Crashpad handler will receive crashes from child processes that
@@ skipping 25 matching lines @@
   //!     situations where a CrashpadClient object is not otherwise available.
   //!     This may be useful when a child process inherits its parent’s Crashpad
   //!     handler, but wants to sever this tie.
   static void UseSystemDefaultHandler();
 #endif
 
  private:
 #if defined(OS_MACOSX)
   base::mac::ScopedMachSendRight exception_port_;
 #elif defined(OS_WIN)
-  std::string ipc_port_;
+  std::wstring ipc_pipe_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(CrashpadClient);
 };
 
 }  // namespace crashpad
 
 #endif  // CRASHPAD_CLIENT_CRASHPAD_CLIENT_H_