Introduce RegistrationServer.

handler/win/registration_test_base.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 "handler/win/registration_test_base.h"
+
+#include "base/strings/stringprintf.h"
+#include "base/strings/utf_string_conversions.h"
+
+namespace crashpad {
+namespace test {
+
+RegistrationTestBase::MockDelegate::Entry::Entry(
+    ScopedKernelHANDLE client_process,
+    WinVMAddress crashpad_info_address,
+    uint32_t fake_request_dump_event,
+    uint32_t fake_dump_complete_event)
+    : client_process(client_process.Pass()),
+      crashpad_info_address(crashpad_info_address),
+      fake_request_dump_event(fake_request_dump_event),
+      fake_dump_complete_event(fake_dump_complete_event) {
+}
+RegistrationTestBase::MockDelegate::MockDelegate()
+    : started_event_(CreateEvent(nullptr, true, false, nullptr)),
+      registered_processes_(),
+      next_fake_handle_(1),
+      fail_(false) {
+  EXPECT_TRUE(started_event_.is_valid());
+}
+
+RegistrationTestBase::MockDelegate::~MockDelegate() {
+}
+
+void RegistrationTestBase::MockDelegate::WaitForStart() {
+  DWORD wait_result = WaitForSingleObject(started_event_.get(), INFINITE);
+  if (wait_result == WAIT_FAILED)
+    PLOG(ERROR);
+  ASSERT_EQ(wait_result, WAIT_OBJECT_0);
+}
+
+void RegistrationTestBase::MockDelegate::OnStarted() {
+  EXPECT_EQ(WAIT_TIMEOUT, WaitForSingleObject(started_event_.get(), 0));
+  SetEvent(started_event_.get());
+}
+
+bool RegistrationTestBase::MockDelegate::RegisterClient(
+    ScopedKernelHANDLE client_process,
+    WinVMAddress crashpad_info_address,
+    HANDLE* request_dump_event,
+    HANDLE* dump_complete_event) {
+  if (fail_)
+    return false;
+
+  if (!request_dump_event || !dump_complete_event) {
+    ADD_FAILURE() << "NULL 'out' parameter.";
+    return false;
+  }
+  *request_dump_event = reinterpret_cast<HANDLE>(next_fake_handle_++);
+  *dump_complete_event = reinterpret_cast<HANDLE>(next_fake_handle_++);
+
+  registered_processes_.push_back(
+      new Entry(client_process.Pass(),
+                crashpad_info_address,
+                reinterpret_cast<uint32_t>(*request_dump_event),
+                reinterpret_cast<uint32_t>(*dump_complete_event)));
+  return true;
+}
+
+RegistrationTestBase::RegistrationTestBase()
+    : pipe_name_(
+          L"\\\\.\\pipe\\registration_server_test_pipe_" +
+          base::UTF8ToUTF16(base::StringPrintf("%08x", GetCurrentProcessId()))),
+      delegate_() {
+}
+
+RegistrationTestBase::~RegistrationTestBase() {
+}
+
+// Returns a pipe handle connected to the RegistrationServer.
+ScopedFileHANDLE RegistrationTestBase::Connect() {
+  ScopedFileHANDLE pipe;
+  const int kMaxRetries = 5;
+  for (int retries = 0; !pipe.is_valid() && retries < kMaxRetries; ++retries) {
+    if (!WaitNamedPipe(pipe_name_.c_str(), NMPWAIT_WAIT_FOREVER))
+      break;
+    pipe.reset(CreateFile(pipe_name_.c_str(),
+                          GENERIC_READ | GENERIC_WRITE,
+                          0,
+                          NULL,
+                          OPEN_EXISTING,
+                          SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION,
+                          NULL));
+    if (pipe.is_valid()) {
+      DWORD mode = PIPE_READMODE_MESSAGE;
+      if (!SetNamedPipeHandleState(pipe.get(),
+                                   &mode,
+                                   nullptr,  // don't set maximum bytes
+                                   nullptr)) {  // don't set maximum time
+        pipe.reset();
+      }
+    }
+  }
+  EXPECT_TRUE(pipe.is_valid());
+  return pipe.Pass();
+}
+
+// Sends the provided request and receives a response via the provided pipe.
+bool RegistrationTestBase::SendRequest(ScopedFileHANDLE pipe,
+                                       const void* request_buffer,
+                                       size_t request_size,
+                                       RegistrationResponse* response) {
+  return WriteRequest(pipe.get(), request_buffer, request_size) &&
+         ReadResponse(pipe.get(), response);
+}
+
+bool RegistrationTestBase::WriteRequest(HANDLE pipe,
+                                        const void* request_buffer,
+                                        size_t request_size) {
+  DWORD byte_count = 0;
+  if (!WriteFile(pipe,
+                 request_buffer,
+                 static_cast<DWORD>(request_size),
+                 &byte_count,
+                 nullptr)) {
+    return false;
+  }
+
+  return byte_count == request_size;
+}
+
+bool RegistrationTestBase::ReadResponse(HANDLE pipe,
+                                        RegistrationResponse* response) {
+  DWORD byte_count = 0;
+  if (!ReadFile(pipe, response, sizeof(*response), &byte_count, nullptr))
+    return false;
+  return byte_count == sizeof(*response);
+}
+
+// Verifies that the request and response match what was received and sent by
+// the MockDelegate.
+void RegistrationTestBase::VerifyRegistration(
+    const MockDelegate::Entry& registered_process,
+    const RegistrationRequest& request,
+    const RegistrationResponse& response) {
+  EXPECT_EQ(request.crashpad_info_address,
+            registered_process.crashpad_info_address);
+  EXPECT_EQ(registered_process.fake_request_dump_event,
+            response.request_report_event);
+  EXPECT_EQ(registered_process.fake_dump_complete_event,
+            response.report_complete_event);
+  EXPECT_EQ(request.client_process_id,
+            GetProcessId(registered_process.client_process.get()));
+}
+
+}  // namespace test
+}  // namespace crashpad