Recognize crashreporter_annotations_t version 5 found on OS X 10.11

snapshot/mac/process_types.h

 // 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,
@@ skipping 67 matching lines @@
                               struct_name* generic);                           \
                                                                                \
     /* Returns the size of the object that was read. This is the size of the   \
      * storage in the process that the data is read from, and is not the same  \
      * as the size of the generic struct. */                                   \
     size_t Size() const { return size_; }                                      \
                                                                                \
     /* Similar to Size(), but computes the expected size of a structure based  \
      * on the process’ bitness. This can be used prior to reading any data     \
      * from a process. */                                                      \
-    static size_t ExpectedSize(ProcessReader* process_reader);
+    static size_t ExpectedSize(ProcessReader* process_reader);                 \
+                                                                               \
+    /* Similar to ExpectedSize(), but computes the expected size of a          \
+     * structure based on the process’ bitness and a custom value, such as a   \
+     * structure version number. This can be used prior to reading any data    \
+     * from a process. */                                                      \
+    static size_t ExpectedSizeForVersion(ProcessReader* process_reader,        \
+                                         uint64_t version);
 
 #define PROCESS_TYPE_STRUCT_MEMBER(member_type, member_name, ...)              \
     member_type member_name __VA_ARGS__;
 
 #define PROCESS_TYPE_STRUCT_END(struct_name)                                   \
    private:                                                                    \
     /* The static form of Read(). Populates the struct at |generic|. */        \
     static bool ReadInto(ProcessReader* process_reader,                        \
                          mach_vm_address_t address,                            \
                          struct_name* generic);                                \
@@ skipping 37 matching lines @@
   template <typename Traits>                                                   \
   struct struct_name {                                                         \
    public:                                                                     \
     using Long = typename Traits::Long;                                        \
     using ULong = typename Traits::ULong;                                      \
     using Pointer = typename Traits::Pointer;                                  \
     using IntPtr = typename Traits::IntPtr;                                    \
     using UIntPtr = typename Traits::UIntPtr;                                  \
     using Reserved64Only = typename Traits::Reserved64Only;                    \
                                                                                \
-    /* Read(), ReadArrayInto(), and Size() are as in the generic user-visible  \
-     * struct above. */                                                        \
+    /* Read(), ReadArrayInto(), Size(), and ExpectedSizeForVersion() are as in \
+     * the generic user-visible struct above. */                               \
     bool Read(ProcessReader* process_reader, mach_vm_address_t address) {      \
       return ReadInto(process_reader, address, this);                          \
     }                                                                          \
     static bool ReadArrayInto(ProcessReader* process_reader,                   \
                               mach_vm_address_t address,                       \
                               size_t count,                                    \
                               struct_name<Traits>* specific);                  \
     static size_t Size() { return sizeof(struct_name<Traits>); }               \
+    static size_t ExpectedSizeForVersion(uint64_t version);                    \
                                                                                \
     /* Translates a struct from the representation used in the remote process  \
      * into the generic form. */                                               \
     void GenericizeInto(process_types::struct_name* generic,                   \
                         size_t* specific_size);
 
 #define PROCESS_TYPE_STRUCT_MEMBER(member_type, member_name, ...)              \
     member_type member_name __VA_ARGS__;
 
 #define PROCESS_TYPE_STRUCT_END(struct_name)                                   \
    private:                                                                    \
     /* ReadInto() is as in the generic user-visible struct above. */           \
     static bool ReadInto(ProcessReader* process_reader,                        \
                          mach_vm_address_t address,                            \
                          struct_name<Traits>* specific);                       \
   };                                                                           \
   }  /* namespace internal */                                                  \
   }  /* namespace process_types */                                             \
   }  /* namespace crashpad */
 
 #include "snapshot/mac/process_types/all.proctype"
 
 #undef PROCESS_TYPE_STRUCT_BEGIN
 #undef PROCESS_TYPE_STRUCT_MEMBER
 #undef PROCESS_TYPE_STRUCT_END
 #undef PROCESS_TYPE_STRUCT_DECLARE_INTERNAL
 
 #endif  // CRASHPAD_SNAPSHOT_MAC_PROCESS_TYPES_H_