win: make CrashpadInfo retrievable

util/numeric/checked_address_range_test.cc

Index: util/numeric/checked_address_range_test.cc
diff --git a/util/mac/checked_mach_address_range_test.cc b/util/numeric/checked_address_range_test.cc
similarity index 86%
copy from util/mac/checked_mach_address_range_test.cc
copy to util/numeric/checked_address_range_test.cc
index 702715d092a0afec4aa4e7c36351cea658821785..804fa038f208c386d768314c1b674a937142abe0 100644
--- a/util/mac/checked_mach_address_range_test.cc
+++ b/util/numeric/checked_address_range_test.cc
@@ -12,13 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "util/mac/checked_mach_address_range.h"
-
-#include <mach/mach.h>
+#include "util/numeric/checked_address_range.h"
 
 #include <limits>
 
 #include "base/basictypes.h"
+#include "base/format_macros.h"
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "gtest/gtest.h"
@@ -27,6 +26,8 @@ namespace crashpad {
 namespace test {
 namespace {
 
+using CheckedAddressRange = CheckedAddressRangeGeneric<uintptr_t, size_t>;
+
 enum Validity {
   kInvalid = false,
   kValid,
@@ -41,10 +42,10 @@ bool ExpectationForValidity64(Validity validity) {
   return validity == kValid || validity == kValid64Invalid32;
 }
 
-TEST(CheckedMachAddressRange, IsValid) {
+TEST(CheckedAddressRange, IsValid) {
   const struct TestData {
-    mach_vm_address_t base;
-    mach_vm_size_t size;
+    uintptr_t base;

[Mark Mentovai, 2015/05/01 19:05:31]

I think these should both be uint64_t or this test will fall apart when run on
32-bit systems. It might even legitimately fail to compile, because many of the
test cases use constants too big to be expressed with 32 bits. Same on lines 29,
136, and 189.

[scottmg, 2015/05/01 19:46:32]

Sorry, that was dumb. Done.

+    size_t size;
     Validity validity;
   } kTestData[] = {
       {0, 0, kValid},
@@ -117,22 +118,22 @@ TEST(CheckedMachAddressRange, IsValid) {
 
   for (size_t index = 0; index < arraysize(kTestData); ++index) {
     const TestData& testcase = kTestData[index];
-    SCOPED_TRACE(base::StringPrintf("index %zu, base 0x%llx, size 0x%llx",
+    SCOPED_TRACE(base::StringPrintf("index %" PRIuS ", base 0x%lx, size 0x%lx",
                                     index,
                                     testcase.base,
                                     testcase.size));
 
-    CheckedMachAddressRange range_32(false, testcase.base, testcase.size);
+    CheckedAddressRange range_32(false, testcase.base, testcase.size);
     EXPECT_EQ(ExpectationForValidity32(testcase.validity), range_32.IsValid());
 
-    CheckedMachAddressRange range_64(true, testcase.base, testcase.size);
+    CheckedAddressRange range_64(true, testcase.base, testcase.size);
     EXPECT_EQ(ExpectationForValidity64(testcase.validity), range_64.IsValid());
   }
 }
 
-TEST(CheckedMachAddressRange, ContainsValue) {
+TEST(CheckedAddressRange, ContainsValue) {
   const struct TestData {
-    mach_vm_address_t value;
+    uintptr_t value;
     bool expectation;
   } kTestData[] = {
       {0, false},
@@ -162,19 +163,19 @@ TEST(CheckedMachAddressRange, ContainsValue) {
       {0xffffffffffffffff, false},
   };
 
-  CheckedMachAddressRange parent_range_32(false, 0x2000, 0x1000);
+  CheckedAddressRange parent_range_32(false, 0x2000, 0x1000);
   ASSERT_TRUE(parent_range_32.IsValid());
 
   for (size_t index = 0; index < arraysize(kTestData); ++index) {
     const TestData& testcase = kTestData[index];
-    SCOPED_TRACE(
-        base::StringPrintf("index %zu, value 0x%llx", index, testcase.value));
+    SCOPED_TRACE(base::StringPrintf(
+        "index %" PRIuS ", value 0x%lx", index, testcase.value));
 
     EXPECT_EQ(testcase.expectation,
               parent_range_32.ContainsValue(testcase.value));
   }
 
-  CheckedMachAddressRange parent_range_64(true, 0x100000000, 0x1000);
+  CheckedAddressRange parent_range_64(true, 0x100000000, 0x1000);
   ASSERT_TRUE(parent_range_64.IsValid());
   EXPECT_FALSE(parent_range_64.ContainsValue(0xffffffff));
   EXPECT_TRUE(parent_range_64.ContainsValue(0x100000000));
@@ -183,10 +184,10 @@ TEST(CheckedMachAddressRange, ContainsValue) {
   EXPECT_FALSE(parent_range_64.ContainsValue(0x100001000));
 }
 
-TEST(CheckedMachAddressRange, ContainsRange) {
+TEST(CheckedAddressRange, ContainsRange) {
   const struct TestData {
-    mach_vm_address_t base;
-    mach_vm_size_t size;
+    uintptr_t base;
+    size_t size;
     bool expectation;
   } kTestData[] = {
       {0, 0, false},
@@ -219,26 +220,26 @@ TEST(CheckedMachAddressRange, ContainsRange) {
       {0x3001, 1, false},
   };
 
-  CheckedMachAddressRange parent_range_32(false, 0x2000, 0x1000);
+  CheckedAddressRange parent_range_32(false, 0x2000, 0x1000);
   ASSERT_TRUE(parent_range_32.IsValid());
 
   for (size_t index = 0; index < arraysize(kTestData); ++index) {
     const TestData& testcase = kTestData[index];
-    SCOPED_TRACE(base::StringPrintf("index %zu, base 0x%llx, size 0x%llx",
+    SCOPED_TRACE(base::StringPrintf("index %" PRIuS ", base 0x%lx, size 0x%lx",
                                     index,
                                     testcase.base,
                                     testcase.size));
 
-    CheckedMachAddressRange child_range_32(false, testcase.base, testcase.size);
+    CheckedAddressRange child_range_32(false, testcase.base, testcase.size);
     ASSERT_TRUE(child_range_32.IsValid());
     EXPECT_EQ(testcase.expectation,
               parent_range_32.ContainsRange(child_range_32));
   }
 
-  CheckedMachAddressRange parent_range_64(true, 0x100000000, 0x1000);
+  CheckedAddressRange parent_range_64(true, 0x100000000, 0x1000);
   ASSERT_TRUE(parent_range_64.IsValid());
 
-  CheckedMachAddressRange child_range_64(true, 0xffffffff, 2);
+  CheckedAddressRange child_range_64(true, 0xffffffff, 2);
   EXPECT_FALSE(parent_range_64.ContainsRange(child_range_64));
 
   child_range_64.SetRange(true, 0x100000000, 2);