Refactor handler/main for Windows, implement CrashHandlerExceptionServer

util/win/exception_handler_server_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,
@@ skipping 18 matching lines @@
 #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(pipe_name).
-  RunServerThread(ExceptionHandlerServer* server, const std::string& pipe_name)
-      : server_(server), pipe_name_(pipe_name) {}
+  // Instantiates a thread which will invoke server->Run(delegate, pipe_name).
+  RunServerThread(ExceptionHandlerServer* server,
+                  ExceptionHandlerServer::Delegate* delegate,
+                  const std::string& pipe_name)
+      : server_(server), delegate_(delegate), pipe_name_(pipe_name) {}
   ~RunServerThread() override {}
 
  private:
   // Thread:
-  void ThreadMain() override { server_->Run(pipe_name_); }
+  void ThreadMain() override { server_->Run(delegate_, pipe_name_); }
 
   ExceptionHandlerServer* server_;
+  ExceptionHandlerServer::Delegate* delegate_;
   std::string pipe_name_;
 
   DISALLOW_COPY_AND_ASSIGN(RunServerThread);
 };
 
 class TestDelegate : public ExceptionHandlerServer::Delegate {
  public:
   explicit TestDelegate(HANDLE server_ready) : server_ready_(server_ready) {}
   ~TestDelegate() override {}
 
@@ skipping 15 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TestDelegate);
 };
 
 class ExceptionHandlerServerTest : public testing::Test {
  public:
   ExceptionHandlerServerTest()
       : pipe_name_("\\\\.\\pipe\\exception_handler_server_test_pipe_" +
                    base::StringPrintf("%08x", GetCurrentProcessId())),
         server_ready_(CreateEvent(nullptr, false, false, nullptr)),
         delegate_(server_ready_.get()),
-        server_(&delegate_),
-        server_thread_(&server_, pipe_name_) {}
+        server_(),
+        server_thread_(&server_, &delegate_, pipe_name_) {}
 
   TestDelegate& delegate() { return delegate_; }
   ExceptionHandlerServer& server() { return server_; }
   Thread& server_thread() { return server_thread_; }
   const std::string& pipe_name() const { return pipe_name_; }
 
  private:
   std::string pipe_name_;
   ScopedKernelHANDLE server_ready_;
   TestDelegate delegate_;
@@ skipping 101 matching lines @@
 
     ASSERT_EQ("OK", ReadString(handles_3->read.get()));
     ASSERT_EQ("OK", ReadString(handles_2->read.get()));
     ASSERT_EQ("OK", ReadString(handles_1->read.get()));
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad