Import Cobalt 21.master.0.260628
diff --git a/src/third_party/crashpad/util/win/exception_handler_server_test.cc b/src/third_party/crashpad/util/win/exception_handler_server_test.cc
new file mode 100644
index 0000000..ce31677
--- /dev/null
+++ b/src/third_party/crashpad/util/win/exception_handler_server_test.cc
@@ -0,0 +1,213 @@
+// 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 "util/win/exception_handler_server.h"
+
+#include <windows.h>
+#include <sys/types.h>
+
+#include <string>
+#include <vector>
+
+#include "base/macros.h"
+#include "base/strings/utf_string_conversions.h"
+#include "client/crashpad_client.h"
+#include "gtest/gtest.h"
+#include "test/win/win_child_process.h"
+#include "util/thread/thread.h"
+#include "util/win/address_types.h"
+#include "util/win/registration_protocol_win.h"
+#include "util/win/scoped_handle.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).
+ RunServerThread(ExceptionHandlerServer* server,
+ ExceptionHandlerServer::Delegate* delegate)
+ : server_(server), delegate_(delegate) {}
+ ~RunServerThread() override {}
+
+ private:
+ // Thread:
+ void ThreadMain() override { server_->Run(delegate_); }
+
+ ExceptionHandlerServer* server_;
+ ExceptionHandlerServer::Delegate* delegate_;
+
+ DISALLOW_COPY_AND_ASSIGN(RunServerThread);
+};
+
+class TestDelegate : public ExceptionHandlerServer::Delegate {
+ public:
+ explicit TestDelegate(HANDLE server_ready) : server_ready_(server_ready) {}
+ ~TestDelegate() {}
+
+ void ExceptionHandlerServerStarted() override {
+ SetEvent(server_ready_);
+ }
+ unsigned int ExceptionHandlerServerException(
+ HANDLE process,
+ WinVMAddress exception_information_address,
+ WinVMAddress debug_critical_section_address) override {
+ return 0;
+ }
+
+ void WaitForStart() { WaitForSingleObject(server_ready_, INFINITE); }
+
+ private:
+ HANDLE server_ready_; // weak
+
+ DISALLOW_COPY_AND_ASSIGN(TestDelegate);
+};
+
+class ExceptionHandlerServerTest : public testing::Test {
+ public:
+ ExceptionHandlerServerTest()
+ : server_(true),
+ pipe_name_(L"\\\\.\\pipe\\test_name"),
+ server_ready_(CreateEvent(nullptr, false, false, nullptr)),
+ delegate_(server_ready_.get()),
+ server_thread_(&server_, &delegate_) {
+ server_.SetPipeName(pipe_name_);
+ }
+
+ TestDelegate& delegate() { return delegate_; }
+ ExceptionHandlerServer& server() { return server_; }
+ Thread& server_thread() { return server_thread_; }
+ const std::wstring& pipe_name() const { return pipe_name_; }
+
+ private:
+ ExceptionHandlerServer server_;
+ std::wstring pipe_name_;
+ ScopedKernelHANDLE server_ready_;
+ TestDelegate delegate_;
+ RunServerThread server_thread_;
+
+ DISALLOW_COPY_AND_ASSIGN(ExceptionHandlerServerTest);
+};
+
+// During destruction, ensures that the server is stopped and the background
+// thread joined.
+class ScopedStopServerAndJoinThread {
+ public:
+ ScopedStopServerAndJoinThread(ExceptionHandlerServer* server, Thread* thread)
+ : server_(server), thread_(thread) {}
+ ~ScopedStopServerAndJoinThread() {
+ server_->Stop();
+ thread_->Join();
+ }
+
+ private:
+ ExceptionHandlerServer* server_;
+ Thread* thread_;
+ DISALLOW_COPY_AND_ASSIGN(ScopedStopServerAndJoinThread);
+};
+
+TEST_F(ExceptionHandlerServerTest, Instantiate) {
+}
+
+TEST_F(ExceptionHandlerServerTest, StartAndStop) {
+ server_thread().Start();
+ ScopedStopServerAndJoinThread scoped_stop_server_and_join_thread(
+ &server(), &server_thread());
+ ASSERT_NO_FATAL_FAILURE(delegate().WaitForStart());
+}
+
+TEST_F(ExceptionHandlerServerTest, StopWhileConnected) {
+ server_thread().Start();
+ ScopedStopServerAndJoinThread scoped_stop_server_and_join_thread(
+ &server(), &server_thread());
+ ASSERT_NO_FATAL_FAILURE(delegate().WaitForStart());
+ CrashpadClient client;
+ client.SetHandlerIPCPipe(pipe_name());
+ // Leaving this scope causes the server to be stopped, while the connection
+ // is still open.
+}
+
+std::wstring ReadWString(FileHandle handle) {
+ size_t length = 0;
+ EXPECT_TRUE(LoggingReadFileExactly(handle, &length, sizeof(length)));
+ std::wstring str(length, L'\0');
+ if (length > 0) {
+ EXPECT_TRUE(
+ LoggingReadFileExactly(handle, &str[0], length * sizeof(str[0])));
+ }
+ return str;
+}
+
+void WriteWString(FileHandle handle, const std::wstring& str) {
+ size_t length = str.size();
+ EXPECT_TRUE(LoggingWriteFile(handle, &length, sizeof(length)));
+ if (length > 0) {
+ EXPECT_TRUE(LoggingWriteFile(handle, &str[0], length * sizeof(str[0])));
+ }
+}
+
+class TestClient final : public WinChildProcess {
+ public:
+ TestClient() : WinChildProcess() {}
+
+ ~TestClient() {}
+
+ private:
+ int Run() override {
+ std::wstring pipe_name = ReadWString(ReadPipeHandle());
+ CrashpadClient client;
+ if (!client.SetHandlerIPCPipe(pipe_name)) {
+ ADD_FAILURE();
+ return EXIT_FAILURE;
+ }
+ WriteWString(WritePipeHandle(), L"OK");
+ return EXIT_SUCCESS;
+ }
+
+ DISALLOW_COPY_AND_ASSIGN(TestClient);
+};
+
+TEST_F(ExceptionHandlerServerTest, MultipleConnections) {
+ WinChildProcess::EntryPoint<TestClient>();
+
+ std::unique_ptr<WinChildProcess::Handles> handles_1 =
+ WinChildProcess::Launch();
+ std::unique_ptr<WinChildProcess::Handles> handles_2 =
+ WinChildProcess::Launch();
+ std::unique_ptr<WinChildProcess::Handles> handles_3 =
+ WinChildProcess::Launch();
+
+ // Must ensure the delegate outlasts the server.
+ {
+ server_thread().Start();
+ ScopedStopServerAndJoinThread scoped_stop_server_and_join_thread(
+ &server(), &server_thread());
+ ASSERT_NO_FATAL_FAILURE(delegate().WaitForStart());
+
+ // Tell all the children where to connect.
+ WriteWString(handles_1->write.get(), pipe_name());
+ WriteWString(handles_2->write.get(), pipe_name());
+ WriteWString(handles_3->write.get(), pipe_name());
+
+ ASSERT_EQ(ReadWString(handles_3->read.get()), L"OK");
+ ASSERT_EQ(ReadWString(handles_2->read.get()), L"OK");
+ ASSERT_EQ(ReadWString(handles_1->read.get()), L"OK");
+ }
+}
+
+} // namespace
+} // namespace test
+} // namespace crashpad
