Create snapshot/mac and move some files from snapshot and util to there

util/mac/checked_mach_address_range.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,
 // 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.
 
 #ifndef CRASHPAD_UTIL_MAC_CHECKED_MACH_ADDRESS_RANGE_H_
 #define CRASHPAD_UTIL_MAC_CHECKED_MACH_ADDRESS_RANGE_H_
 
 #include <mach/mach.h>
 
 #include "util/numeric/checked_range.h"
 
 namespace crashpad {
 
-class ProcessReader;
-
 //! \brief Ensures that a range, composed of a base and a size, does not
 //!     overflow the pointer type of the process it describes a range in.
 //!
 //! This class checks bases of type `mach_vm_address_t` and sizes of type
-//! `mach_vm_address_t` against a process whose pointer type can be determined
-//! from its ProcessReader.
+//! `mach_vm_address_t` against a process whose pointer type is either 32 or 64
+//! bits wide.
 //!
 //! Aside from varying the overall range on the basis of a process’ pointer type
 //! width, this class functions very similarly to CheckedRange.
 class CheckedMachAddressRange {
  public:
   //! \brief Initializes a default range.
   //!
   //! The default range has base 0, size 0, and appears to be from a 32-bit
   //! process.
   CheckedMachAddressRange();
 
   //! \brief Initializes a range.
   //!
   //! See SetRange().
-  CheckedMachAddressRange(const ProcessReader* process_reader,
+  CheckedMachAddressRange(bool is_64_bit,
                           mach_vm_address_t base,
                           mach_vm_size_t size);
 
   //! \brief Sets a range’s fields.
   //!
-  //! \param[in] process_reader The ProcessReader that can read the process that
-  //!                           \a base is a pointer to.
+  //! \param[in] is_64_bit `true` if \a base and \a size refer to addresses in a
+  //!     64-bit process; `false` if they refer to addresses in a 32-bit
+  //!     process.
   //! \param[in] base The range’s base address.
   //! \param[in] size The range’s size.
-  void SetRange(const ProcessReader* process_reader,
-                mach_vm_address_t base,
-                mach_vm_size_t size);
+  void SetRange(bool is_64_bit, mach_vm_address_t base, mach_vm_size_t size);
 
   //! \brief The range’s base address.
   mach_vm_address_t Base() const;
 
   //! \brief The range’s size.
   mach_vm_size_t Size() const;
 
   //! \brief The range’s end address (its base address plus its size).
   mach_vm_address_t End() const;
 
@@ skipping 24 matching lines @@
   //!
   //! \return `true` if `this` address range, the containing address range,
   //!     contains \a that, the contained address range. `false` otherwise.
   //!
   //! An address range contains another address range when the contained address
   //! range’s base is greater than or equal to the containing address range’s
   //! base, and the contained address range’s end is less than or equal to the
   //! containing address range’s end.
   //!
   //! This method should only be called on two CheckedMachAddressRange objects
-  //! sharing the same ProcessReader.
+  //! representing address ranges in the same process.
   //!
   //! This method must only be called if IsValid() would return `true` for both
   //! CheckedMachAddressRange objects involved.
   bool ContainsRange(const CheckedMachAddressRange& that) const;
 
  private:
   // The field of the union that is expressed is determined by is_64_bit_.
   union {
     CheckedRange<uint32_t> range_32_;
     CheckedRange<uint64_t> range_64_;
@@ skipping 11 matching lines @@
   // mach_vm_size_t uniformly, but these types are too wide for the underlying
   // pointer and size types in 32-bit processes.
   bool range_ok_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckedMachAddressRange);
 };
 
 }  // namespace crashpad
 
 #endif  // CRASHPAD_UTIL_MAC_CHECKED_MACH_ADDRESS_RANGE_H_