Refactor handler/main for Windows, implement CrashHandlerExceptionServer

util/win/exception_handler_server.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 166 matching lines @@
   WinVMAddress exception_information_address_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientData);
 };
 
 }  // namespace internal
 
 ExceptionHandlerServer::Delegate::~Delegate() {
 }
 
-ExceptionHandlerServer::ExceptionHandlerServer(Delegate* delegate)
-    : delegate_(delegate),
-      port_(CreateIoCompletionPort(INVALID_HANDLE_VALUE, nullptr, 0, 1)),
+ExceptionHandlerServer::ExceptionHandlerServer()
+    : port_(CreateIoCompletionPort(INVALID_HANDLE_VALUE, nullptr, 0, 1)),
       clients_lock_(),
       clients_() {
 }
 
 ExceptionHandlerServer::~ExceptionHandlerServer() {
 }
 
-void ExceptionHandlerServer::Run(const std::string& pipe_name) {
+void ExceptionHandlerServer::Run(Delegate* delegate,
+                                 const std::string& pipe_name) {
   uint64_t shutdown_token = base::RandUint64();
   // We create two pipe instances, so that there's one listening while the
   // PipeServiceProc is processing a registration.
   ScopedKernelHANDLE thread_handles[2];
   base::string16 pipe_name_16(base::UTF8ToUTF16(pipe_name));
   for (int i = 0; i < arraysize(thread_handles); ++i) {
     HANDLE pipe =
         CreateNamedPipe(pipe_name_16.c_str(),
                         PIPE_ACCESS_DUPLEX,
                         PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT,
                         arraysize(thread_handles),
                         512,
                         512,
                         0,
                         nullptr);
 
     // Ownership of this object (and the pipe instance) is given to the new
     // thread. We close the thread handles at the end of the scope. They clean
     // up the context object and the pipe instance on termination.
     internal::PipeServiceContext* context =
         new internal::PipeServiceContext(port_.get(),
                                          pipe,
-                                         delegate_,
+                                         delegate,
                                          &clients_lock_,
                                          &clients_,
                                          shutdown_token);
     thread_handles[i].reset(
         CreateThread(nullptr, 0, &PipeServiceProc, context, 0, nullptr));
   }
 
-  delegate_->ExceptionHandlerServerStarted();
+  delegate->ExceptionHandlerServerStarted();
 
   // This is the main loop of the server. Most work is done on the threadpool,
   // other than process end handling which is posted back to this main thread,
   // as we must unregister the threadpool waits here.
   for (;;) {
     OVERLAPPED* ov = nullptr;
     ULONG_PTR key = 0;
     DWORD bytes = 0;
     GetQueuedCompletionStatus(port_.get(), &bytes, &key, &ov, INFINITE);
     if (!key) {
@@ skipping 174 matching lines @@
 void __stdcall ExceptionHandlerServer::OnProcessEnd(void* ctx, BOOLEAN) {
   // This function is executed on the thread pool.
   internal::ClientData* client = reinterpret_cast<internal::ClientData*>(ctx);
   base::AutoLock lock(*client->lock());
 
   // Post back to the main thread to have it delete this client record.
   PostQueuedCompletionStatus(client->port(), 0, ULONG_PTR(client), nullptr);
 }
 
 }  // namespace crashpad