Allow exception forwarding to the system’s native crash reporter to be disabled

snapshot/mac/mach_o_image_reader_test.cc

 // Copyright 2014 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/mac/mach_o_image_reader.h"
 
 #include <AvailabilityMacros.h>
 #include <dlfcn.h>
 #include <mach-o/dyld.h>
 #include <mach-o/dyld_images.h>
 #include <mach-o/getsect.h>
 #include <mach-o/ldsyms.h>
 #include <mach-o/loader.h>
 #include <mach-o/nlist.h>
 #include <stdint.h>
 
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
+#include "client/crashpad_info.h"
 #include "gtest/gtest.h"
 #include "snapshot/mac/mach_o_image_segment_reader.h"
 #include "snapshot/mac/process_reader.h"
 #include "snapshot/mac/process_types.h"
 #include "util/misc/uuid.h"
 #include "util/test/mac/dyld.h"
 
 // This file is responsible for testing MachOImageReader,
 // MachOImageSegmentReader, and MachOImageSymbolTableReader.
 
@@ skipping 486 matching lines @@
   ASSERT_NO_FATAL_FAILURE(ExpectSymbolTable(mh_execute_header, &image_reader));
 }
 
 TEST(MachOImageReader, Self_DyldImages) {
   ProcessReader process_reader;
   ASSERT_TRUE(process_reader.Initialize(mach_task_self()));
 
   uint32_t count = _dyld_image_count();
   ASSERT_GE(count, 1u);
 
+  size_t modules_with_crashpad_info = 0;
+
   for (uint32_t index = 0; index < count; ++index) {
     const char* image_name = _dyld_get_image_name(index);
     SCOPED_TRACE(base::StringPrintf("index %u, image %s", index, image_name));
 
     // _dyld_get_image_header() is poorly-declared: it’s declared as returning
     // const mach_header* in both 32-bit and 64-bit environments, but in the
     // 64-bit environment, it should be const mach_header_64*.
     const MachHeader* mach_header =
         reinterpret_cast<const MachHeader*>(_dyld_get_image_header(index));
     mach_vm_address_t image_address =
         reinterpret_cast<mach_vm_address_t>(mach_header);
 
     MachOImageReader image_reader;
     ASSERT_TRUE(
         image_reader.Initialize(&process_reader, image_address, image_name));
 
     uint32_t file_type = image_reader.FileType();
     if (index == 0) {
       EXPECT_EQ(implicit_cast<uint32_t>(MH_EXECUTE), file_type);
     } else {
       EXPECT_TRUE(file_type == MH_DYLIB || file_type == MH_BUNDLE);
     }
 
     intptr_t image_slide = _dyld_get_image_vmaddr_slide(index);
     ASSERT_NO_FATAL_FAILURE(ExpectMachImage(
         mach_header, image_address, image_slide, &image_reader, false));
 
     ASSERT_NO_FATAL_FAILURE(ExpectSymbolTable(mach_header, &image_reader));
+
+    process_types::CrashpadInfo crashpad_info;
+    if (image_reader.GetCrashpadInfo(&crashpad_info)) {
+      ++modules_with_crashpad_info;
+    }
   }
 
+  EXPECT_GE(modules_with_crashpad_info, 1u);
+
   // Now that all of the modules have been verified, make sure that dyld itself
   // can be read properly too.
   const struct dyld_all_image_infos* dyld_image_infos =
       _dyld_get_all_image_infos();
   ASSERT_GE(dyld_image_infos->version, 1u);
   EXPECT_EQ(count, dyld_image_infos->infoArrayCount);
 
   if (dyld_image_infos->version >= 2) {
     SCOPED_TRACE("dyld");
 
@@ skipping 50 matching lines @@
       image_reader.UUID(&actual_uuid);
       EXPECT_EQ(expected_uuid, actual_uuid);
     }
   }
 #endif
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad