Add the ability to defer the initialization of the SyzyAsan crash reporter.

syzygy/agent/asan/rtl_impl_unittest.cc

 // Copyright 2012 Google Inc. 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 "syzygy/agent/asan/rtl_impl.h"
 
 #include <windows.h>  // NOLINT
 
 #include "base/rand_util.h"
 #include "gtest/gtest.h"
 #include "syzygy/agent/asan/runtime.h"
 #include "syzygy/agent/asan/shadow.h"
 #include "syzygy/agent/asan/unittest_util.h"
 #include "syzygy/core/unittest_util.h"
 
+namespace agent {
+namespace asan {
+
 namespace {
 
 class AsanRtlImplTest : public testing::TestWithAsanLogger {
  public:
   AsanRtlImplTest() : heap_(NULL) {
   }
 
   void SetUp() override {
     testing::TestWithAsanLogger::SetUp();
-    asan_runtime_.SetUp(std::wstring());
+    asan_runtime_.SetUp(runtime_command_line_);
     agent::asan::SetUpRtl(&asan_runtime_);
     heap_ = asan_HeapCreate(0, 0, 0);
     ASSERT_TRUE(heap_ != NULL);
   }
 
   void TearDown() override {
     if (heap_ != NULL) {
       asan_HeapDestroy(heap_);
       heap_ = NULL;
     }
     agent::asan::TearDownRtl();
     asan_runtime_.TearDown();
     testing::TestWithAsanLogger::TearDown();
   }
 
  protected:
   agent::asan::AsanRuntime asan_runtime_;
 
   // Arbitrary constant for all size limit.
   static const size_t kMaxAllocSize = 134584;
 
   // Scratch heap handle valid from SetUp to TearDown.
   HANDLE heap_;
+
+  // The command line used to initialize the runtime. Empty by default but
+  // can be override by the derived classes to enable some runtime flags
+  // during setup.
+  std::wstring runtime_command_line_;
 };
 
 }  // namespace
 
 TEST_F(AsanRtlImplTest, CreateDestroy) {
   HANDLE heap = asan_HeapCreate(0, 0, 0);
   ASSERT_TRUE(heap != NULL);
   ASSERT_TRUE(asan_HeapDestroy(heap));
 }
 
@@ skipping 75 matching lines @@
                               &compat_flag, sizeof(compat_flag)));
 }
 
 TEST_F(AsanRtlImplTest, SetInformationWithNullHeapPtr) {
   // The documentation of HeapSetInformation specify that the heap handle is
   // optional.
   ASSERT_TRUE(
       asan_HeapSetInformation(NULL, HeapEnableTerminationOnCorruption,
                               NULL, 0));
 }
+
+namespace {
+
+// Derived class that defers the crash reporter initialization.
+class AsanRtlImplTestCrashHandlerInitialization : public AsanRtlImplTest {
+ public:
+  AsanRtlImplTestCrashHandlerInitialization() {
+    runtime_command_line_ = L"--defer_crash_reporter_initialization";
+  }
+};
+
+}  // namespace
+
+TEST_F(AsanRtlImplTestCrashHandlerInitialization, InitializeCrashHandler) {
+  EXPECT_FALSE(asan_runtime_.crash_reporter_initialized());
+  asan_InitializeCrashHandler();
+  EXPECT_TRUE(asan_runtime_.crash_reporter_initialized());
+}
+
+}  // namespace asan
+}  // namespace agent