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

snapshot/mac/mach_o_image_annotations_reader.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_annotations_reader.h"
 
 #include <mach-o/loader.h>
 #include <mach/mach.h>
 
 #include "base/logging.h"
 #include "client/crashpad_info.h"
 #include "client/simple_string_dictionary.h"
 #include "snapshot/mac/mach_o_image_reader.h"
 #include "snapshot/mac/process_reader.h"
-#include "snapshot/mac/process_types.h"
 #include "util/mach/task_memory.h"
 #include "util/stdlib/strnlen.h"
 
 namespace crashpad {
 
 MachOImageAnnotationsReader::MachOImageAnnotationsReader(
     ProcessReader* process_reader,
     const MachOImageReader* image_reader,
     const std::string& name)
     : name_(name),
@@ skipping 12 matching lines @@
 
 std::map<std::string, std::string> MachOImageAnnotationsReader::SimpleMap()
     const {
   std::map<std::string, std::string> simple_map_annotations;
 
   ReadCrashpadSimpleAnnotations(&simple_map_annotations);
 
   return simple_map_annotations;
 }
 
+bool MachOImageAnnotationsReader::GetCrashpadInfo(
+    process_types::CrashpadInfo* crashpad_info) const {
+  mach_vm_address_t crashpad_info_address;
+  const process_types::section* crashpad_info_section =
+      image_reader_->GetSectionByName(
+          SEG_DATA, "__crashpad_info", &crashpad_info_address);
+  if (!crashpad_info_section) {
+    return false;
+  }
+
+  if (crashpad_info_section->size <
+      crashpad_info->ExpectedSize(process_reader_)) {
+    LOG(WARNING) << "small crashpad info section size "
+                 << crashpad_info_section->size << " in " << name_;
+    return false;
+  }
+
+  if (!crashpad_info->Read(process_reader_, crashpad_info_address)) {
+    LOG(WARNING) << "could not read crashpad info from " << name_;
+    return false;
+  }
+
+  if (crashpad_info->signature != CrashpadInfo::kSignature ||
+      crashpad_info->size != crashpad_info_section->size ||
+      crashpad_info->version < 1) {
+    LOG(WARNING) << "unexpected crashpad info data in " << name_;
+    return false;
+  }
+
+  return true;
+}
+
 void MachOImageAnnotationsReader::ReadCrashReporterClientAnnotations(
     std::vector<std::string>* vector_annotations) const {
   mach_vm_address_t crash_info_address;
   const process_types::section* crash_info_section =
       image_reader_->GetSectionByName(
           SEG_DATA, "__crash_info", &crash_info_address);
   if (!crash_info_section) {
     return;
   }
 
@@ skipping 63 matching lines @@
     if (!message.empty()) {
       vector_annotations->push_back(message);
     }
   } else {
     LOG(WARNING) << "could not read dylinker error string from " << name_;
   }
 }
 
 void MachOImageAnnotationsReader::ReadCrashpadSimpleAnnotations(
     std::map<std::string, std::string>* simple_map_annotations) const {
-  mach_vm_address_t crashpad_info_address;
-  const process_types::section* crashpad_info_section =
-      image_reader_->GetSectionByName(
-          SEG_DATA, "__crashpad_info", &crashpad_info_address);
-  if (!crashpad_info_section) {
+  process_types::CrashpadInfo crashpad_info;
+  if (!GetCrashpadInfo(&crashpad_info)) {
     return;
   }
 
-  process_types::CrashpadInfo crashpad_info;
-  if (crashpad_info_section->size <
-      crashpad_info.ExpectedSize(process_reader_)) {
-    LOG(WARNING) << "small crashpad info section size "
-                 << crashpad_info_section->size << " in " << name_;
-    return;
-  }
-
-  if (!crashpad_info.Read(process_reader_, crashpad_info_address)) {
-    LOG(WARNING) << "could not read crashpad info from " << name_;
-    return;
-  }
-
-  if (crashpad_info.signature != CrashpadInfo::kSignature ||
-      crashpad_info.size != crashpad_info_section->size ||
-      crashpad_info.version < 1) {
-    LOG(WARNING) << "unexpected crashpad info data in " << name_;
-    return;
-  }
-
   if (!crashpad_info.simple_annotations) {
     return;
   }
 
   std::vector<SimpleStringDictionary::Entry>
       simple_annotations(SimpleStringDictionary::num_entries);
   if (!process_reader_->Memory()
            ->Read(crashpad_info.simple_annotations,
                   simple_annotations.size() * sizeof(simple_annotations[0]),
                   &simple_annotations[0])) {
@@ skipping 10 matching lines @@
         simple_map_annotations->insert(
             std::pair<std::string, std::string>(key, value));
       } else {
         LOG(INFO) << "duplicate simple annotation " << key << " in " << name_;
       }
     }
   }
 }
 
 }  // namespace crashpad