Refactor handler/main for Windows, implement CrashHandlerExceptionServer

snapshot/win/exception_snapshot_win_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,
 // 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 "snapshot/win/exception_snapshot_win.h"
 
 #include <string>
 
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "client/crashpad_client.h"
 #include "gtest/gtest.h"
-#include "snapshot/win/process_reader_win.h"
 #include "snapshot/win/process_snapshot_win.h"
 #include "test/win/win_child_process.h"
 #include "util/thread/thread.h"
 #include "util/win/exception_handler_server.h"
 #include "util/win/registration_protocol_win.h"
 #include "util/win/scoped_handle.h"
 
 namespace crashpad {
 namespace test {
 namespace {
@@ skipping 22 matching lines @@
           break_near_(nullptr) {}
     ~Delegate() override {}
 
     void set_break_near(void* break_near) { break_near_ = break_near; }
 
     void ExceptionHandlerServerStarted() override { SetEvent(server_ready_); }
 
     unsigned int ExceptionHandlerServerException(
         HANDLE process,
         WinVMAddress exception_information_address) override {
-      // Snapshot the process and exception.
-      ProcessReaderWin process_reader;
-      EXPECT_TRUE(process_reader.Initialize(process));
-      if (HasFatalFailure())
-        return 0xffffffff;
-      ExceptionInformation exception_information;
-      EXPECT_TRUE(
-          process_reader.ReadMemory(exception_information_address,
-                                    sizeof(exception_information),
-                                    &exception_information));
-      if (HasFatalFailure())
-        return 0xffffffff;
       ProcessSnapshotWin snapshot;
       snapshot.Initialize(process);
-      snapshot.InitializeException(exception_information.thread_id,
-                                   exception_information.exception_pointers);
+      snapshot.InitializeException(exception_information_address);
 
       // Confirm the exception record was read correctly.
       EXPECT_NE(snapshot.Exception()->ThreadID(), 0u);
       EXPECT_EQ(snapshot.Exception()->Exception(), EXCEPTION_BREAKPOINT);
 
       // Verify the exception happened at the expected location with a bit of
       // slop space to allow for reading the current PC before the exception
       // happens. See CrashingChildProcess::Run().
       const uint64_t kAllowedOffset = 64;
       EXPECT_GT(snapshot.Exception()->ExceptionAddress(),
@@ skipping 14 matching lines @@
     DISALLOW_COPY_AND_ASSIGN(Delegate);
   };
 
  private:
   ScopedKernelHANDLE exception_happened_;
 };
 
 // Runs the ExceptionHandlerServer on a background thread.
 class RunServerThread : public Thread {
  public:
-  // Instantiates a thread which will invoke server->Run(pipe_name);
-  explicit 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);
 };
 
 // During destruction, ensures that the server is stopped and the background
 // thread joined.
 class ScopedStopServerAndJoinThread {
  public:
-  explicit ScopedStopServerAndJoinThread(ExceptionHandlerServer* server,
-                                         Thread* thread)
+  ScopedStopServerAndJoinThread(ExceptionHandlerServer* server, Thread* thread)
       : server_(server), thread_(thread) {}
   ~ScopedStopServerAndJoinThread() {
     server_->Stop();
     thread_->Join();
   }
 
  private:
   ExceptionHandlerServer* server_;
   Thread* thread_;
   DISALLOW_COPY_AND_ASSIGN(ScopedStopServerAndJoinThread);
@@ skipping 44 matching lines @@
   WinChildProcess::EntryPoint<CrashingChildProcess>();
   scoped_ptr<WinChildProcess::Handles> handle = WinChildProcess::Launch();
 
   // Set up the registration server on a background thread.
   std::string pipe_name = "\\\\.\\pipe\\handler_test_pipe_" +
                           base::StringPrintf("%08x", GetCurrentProcessId());
   ScopedKernelHANDLE server_ready(CreateEvent(nullptr, false, false, nullptr));
   ScopedKernelHANDLE completed(CreateEvent(nullptr, false, false, nullptr));
   Delegate delegate(server_ready.get(), completed.get());
 
-  ExceptionHandlerServer exception_handler_server(&delegate);
-  RunServerThread server_thread(&exception_handler_server, pipe_name);
+  ExceptionHandlerServer exception_handler_server;
+  RunServerThread server_thread(
+      &exception_handler_server, &delegate, pipe_name);
   server_thread.Start();
   ScopedStopServerAndJoinThread scoped_stop_server_and_join_thread(
       &exception_handler_server, &server_thread);
 
   WaitForSingleObject(server_ready.get(), INFINITE);
   // Allow the child to continue and tell it where to connect to.
   WriteString(handle->write.get(), pipe_name);
 
   // The child tells us (approximately) where it will crash.
   void* break_near_address;
   LoggingReadFile(
       handle->read.get(), &break_near_address, sizeof(break_near_address));
   delegate.set_break_near(break_near_address);
 
   // Wait for the child to crash and the exception information to be validated.
   WaitForSingleObject(completed.get(), INFINITE);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad