win: Add memory map range intersection helper

util/win/process_info.h

 // Copyright 2015 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_WIN_PROCESS_INFO_H_
 #define CRASHPAD_UTIL_WIN_PROCESS_INFO_H_
 
 #include <sys/types.h>
 #include <windows.h>
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "util/misc/initialization_state_dcheck.h"
+#include "util/numeric/checked_range.h"
 #include "util/win/address_types.h"
 
 namespace crashpad {
 
 //! \brief Gathers information about a process given its `HANDLE`. This consists
 //!     primarily of information stored in the Process Environment Block.
 class ProcessInfo {
  public:
   //! \brief Contains information about a module loaded into a process.
   struct Module {
     Module();
     ~Module();
 
     //! \brief The pathname used to load the module from disk.
     std::wstring name;
 
     //! \brief The base address of the loaded DLL.
     WinVMAddress dll_base;
 
     //! \brief The size of the module.
     WinVMSize size;
 
     //! \brief The module's timestamp.
     time_t timestamp;
   };
 
   // \brief Contains information about a range of pages in the virtual address
   //    space of a process.
   struct MemoryInfo {
+    MemoryInfo();

[Mark Mentovai, 2015/10/01 17:38:59]

We killed this in
https://codereview.chromium.org/1369833002/diff/60001/util/win/process_info.h....
Since it’s only used in the test, maybe it’d be better to debloat by not having
this and instead moving the bloat to the test by building MemoryInfo objects
from MEMORY_BASIC_INFORMATION.

[scottmg, 2015/10/01 18:10:02]

Done.

     explicit MemoryInfo(const MEMORY_BASIC_INFORMATION& mbi);
     ~MemoryInfo();
 
     //! \brief The base address of the region of pages.
     WinVMAddress base_address;
 
     //! \brief The size of the region beginning at base_address in bytes.
     WinVMSize region_size;
 
     //! \brief The base address of a range of pages that was allocated by
@@ skipping 57 matching lines @@
   //! \brief Retrieves the modules loaded into the target process.
   //!
   //! The modules are enumerated in initialization order as detailed in the
   //!     Process Environment Block. The main executable will always be the
   //!     first element.
   bool Modules(std::vector<Module>* modules) const;
 
   //! \brief Retrieves information about all pages mapped into the process.
   const std::vector<MemoryInfo>& MemoryInformation() const;
 
+  //! \brief Given a range to be read from the target process, returns a vector
+  //!     of ranges, representing the readable portions of the original range.
+  //!
+  //! \param[in] range The range being identified.
+  //!
+  //! \return A vector of ranges corresponding to the portion of the range
+  //!     identified by \a range that are readable, based on the memory map.
+  std::vector<CheckedRange<WinVMAddress, WinVMSize>> GetReadableRanges(
+      const CheckedRange<WinVMAddress, WinVMSize>& range) const;
+
  private:
   template <class Traits>
   friend bool GetProcessBasicInformation(HANDLE process,
                                          bool is_wow64,
                                          ProcessInfo* process_info,
                                          WinVMAddress* peb_address,
                                          WinVMSize* peb_size);
   template <class Traits>
   friend bool ReadProcessData(HANDLE process,
                               WinVMAddress peb_address_vmaddr,
                               ProcessInfo* process_info);
 
   friend bool ReadMemoryInfo(HANDLE process, ProcessInfo* process_info);
 
   pid_t process_id_;
   pid_t inherited_from_process_id_;
   std::wstring command_line_;
   WinVMAddress peb_address_;
   WinVMSize peb_size_;
   std::vector<Module> modules_;
   std::vector<MemoryInfo> memory_info_;
   bool is_64_bit_;
   bool is_wow64_;
   InitializationStateDcheck initialized_;
 
   DISALLOW_COPY_AND_ASSIGN(ProcessInfo);
 };
 
+//! \brief Given a memory map of a process, and a range to be read from the
+//!     target process, returns a vector of ranges, representing the readable
+//!     portions of the original range.
+//!
+//! This is a free function for testing, but prefer
+//! ProcessInfo::GetReadableRanges().
+//!
+//! \sa ProcessInfo::GetReadableRanges()

[Mark Mentovai, 2015/10/01 17:38:59]

I don’t think you need to say \sa when you just gave the name of the alternative
in full above.

[scottmg, 2015/10/01 18:10:02]

Done.

+std::vector<CheckedRange<WinVMAddress, WinVMSize>> GetReadableRangesOfMemoryMap(
+    const CheckedRange<WinVMAddress, WinVMSize>& range,
+    const std::vector<ProcessInfo::MemoryInfo>& memory_info);
+
 }  // namespace crashpad
 
 #endif  // CRASHPAD_UTIL_WIN_PROCESS_INFO_H_