win: Add memory map range intersection helper

util/numeric/checked_range_test.cc

Index: util/numeric/checked_range_test.cc
diff --git a/util/numeric/checked_range_test.cc b/util/numeric/checked_range_test.cc
index 9c72526a6a8379a27d1d509be2eaff10a0c4d6fb..cbff6612e67c0e82147fc630863af6e6a29e7d60 100644
--- a/util/numeric/checked_range_test.cc
+++ b/util/numeric/checked_range_test.cc
@@ -246,6 +246,59 @@ TEST(CheckedRange, ContainsRange) {
   }
 }
 
+TEST(CheckedRange, OverlapsRange) {
+  const struct TestData {
+    uint32_t base;
+    uint32_t size;
+    bool valid;

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

This is more “overlaps” than valid. The member names for the ContainsValue and
ContainsRange tests should also be updated to “contains”.

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

Done.

+  } kTestData[] = {
+      {0, 0, false},
+      {0, 1, false},
+      {0x2000, 0x1000, true},
+      {0, 0x2000, false},
+      {0x3000, 0x1000, false},
+      {0x1800, 0x1000, true},
+      {0x1800, 0x2000, true},
+      {0x2800, 0x1000, true},
+      {0x2000, 0x800, true},
+      {0x2800, 0x800, true},
+      {0x2400, 0x800, true},
+      {0x2800, 0, true},

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

This one might be a little weird. Should a 0-sized range be treated as
overlapping anything? It matches what ContainsRange() does, but now I’m
second-guessing that too.

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

Yeah, the other weird case is <0x2000, 0> = false which is also odd when
compared with this one.

Maybe the most sane thing is that 0-length ranges never overlap anything?

[Mark Mentovai, 2015/10/01 18:29:12]

scottmg wrote:
That works for me. The “contains” case is more of an academic stumper than this
(do you have any thoughts?) but the new “overlaps” looks great now.

+      {0x2000, 0xffffdfff, true},
+      {0x2800, 0xffffd7ff, true},
+      {0x3000, 0xffffcfff, false},
+      {0xfffffffe, 1, false},
+      {0xffffffff, 0, false},
+      {0x1fff, 0, false},
+      {0x2000, 0, false},
+      {0x2001, 0, true},
+      {0x2fff, 0, true},
+      {0x3000, 0, false},
+      {0x3001, 0, false},
+      {0x1fff, 1, false},
+      {0x2000, 1, true},
+      {0x2001, 1, true},
+      {0x2fff, 1, true},
+      {0x3000, 1, false},
+      {0x3001, 1, false},
+  };
+
+  CheckedRange<uint32_t> first_range(0x2000, 0x1000);
+  ASSERT_TRUE(first_range.IsValid());
+
+  for (size_t index = 0; index < arraysize(kTestData); ++index) {
+    const TestData& testcase = kTestData[index];
+    SCOPED_TRACE(base::StringPrintf("index %" PRIuS ", base 0x%x, size 0x%x",
+                                    index,
+                                    testcase.base,
+                                    testcase.size));
+
+    CheckedRange<uint32_t> second_range(testcase.base, testcase.size);
+    ASSERT_TRUE(second_range.IsValid());
+    EXPECT_EQ(testcase.valid, first_range.OverlapsRange(second_range));
+  }
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace crashpad