Contains/Intersects methods for ui::Range

 This will be used to implement text style/coloring for TextfieldViews.
BUG=none
TEST=new unit tests are added in range_unittests.cc

Review URL: http://codereview.chromium.org/7039051

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@86040 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 87 insertions, 0 deletions

diff --git a/ui/base/range/range.cc b/ui/base/range/range.cc
index a7ce516..0c5b506 100644
--- a/ui/base/range/range.cc
+++ b/ui/base/range/range.cc
@@ -55,6 +55,26 @@ bool Range::EqualsIgnoringDirection(const Range& other) const {
   return GetMin() == other.GetMin() && GetMax() == other.GetMax();
 }
 
+bool Range::Intersects(const Range& range) const {
+  return IsValid() && range.IsValid() &&
+      !(range.GetMax() < GetMin() || range.GetMin() >= GetMax());
+}
+
+bool Range::Contains(const Range& range) const {
+  return IsValid() && range.IsValid() &&
+      GetMin() <= range.GetMin() && range.GetMax() <= GetMax();
+}
+
+Range Range::Intersect(const Range& range) const {
+  size_t min = std::max(GetMin(), range.GetMin());
+  size_t max = std::min(GetMax(), range.GetMax());
+
+  if (min >= max)  // No intersection.
+    return InvalidRange();
+
+  return Range(min, max);
+}
+
 #if defined(OS_WIN)
 Range::Range(const CHARRANGE& range, LONG total_length) {
   // Check if this is an invalid range.
diff --git a/ui/base/range/range.h b/ui/base/range/range.h
index a0614d0..c1ddaf5 100644
--- a/ui/base/range/range.h
+++ b/ui/base/range/range.h
@@ -79,6 +79,16 @@ class Range {
   bool operator!=(const Range& other) const;
   bool EqualsIgnoringDirection(const Range& other) const;
 
+  // Returns true if this range intersects the specified |range|.
+  bool Intersects(const Range& range) const;
+
+  // Returns true if this range contains the specified |range|.
+  bool Contains(const Range& range) const;
+
+  // Computes the intersection of this range with the given |range|.
+  // If they don't intersects, it returns an InvalidRange().
+  Range Intersect(const Range& range) const;
+
 #if defined(OS_MACOSX)
   Range& operator=(const NSRange& range);
 
diff --git a/ui/base/range/range_unittest.cc b/ui/base/range/range_unittest.cc
index b650c15..cf0da5a 100644
--- a/ui/base/range/range_unittest.cc
+++ b/ui/base/range/range_unittest.cc
@@ -150,6 +150,63 @@ TEST(RangeTest, SetReversedRange) {
   EXPECT_EQ(25U, r.GetMax());
 }
 
+void TestContainsAndIntersects(const ui::Range& r1,
+                               const ui::Range& r2,
+                               const ui::Range& r3) {
+  EXPECT_TRUE(r1.Intersects(r1));
+  EXPECT_TRUE(r1.Contains(r1));
+  EXPECT_EQ(ui::Range(10, 12), r1.Intersect(r1));
+
+  EXPECT_FALSE(r1.Intersects(r2));
+  EXPECT_FALSE(r1.Contains(r2));
+  EXPECT_TRUE(r1.Intersect(r2).is_empty());
+  EXPECT_FALSE(r2.Intersects(r1));
+  EXPECT_FALSE(r2.Contains(r1));
+  EXPECT_TRUE(r2.Intersect(r1).is_empty());
+
+  EXPECT_TRUE(r1.Intersects(r3));
+  EXPECT_TRUE(r3.Intersects(r1));
+  EXPECT_TRUE(r3.Contains(r1));
+  EXPECT_FALSE(r1.Contains(r3));
+  EXPECT_EQ(ui::Range(10, 12), r1.Intersect(r3));
+  EXPECT_EQ(ui::Range(10, 12), r3.Intersect(r1));
+
+  EXPECT_TRUE(r2.Intersects(r3));
+  EXPECT_TRUE(r3.Intersects(r2));
+  EXPECT_FALSE(r3.Contains(r2));
+  EXPECT_FALSE(r2.Contains(r3));
+  EXPECT_EQ(ui::Range(5, 8), r2.Intersect(r3));
+  EXPECT_EQ(ui::Range(5, 8), r3.Intersect(r2));
+}
+
+TEST(RangeTest, ContainAndIntersect) {
+  {
+    SCOPED_TRACE("contain and intersect");
+    ui::Range r1(10, 12);
+    ui::Range r2(1, 8);
+    ui::Range r3(5, 12);
+    TestContainsAndIntersects(r1, r2, r3);
+  }
+  {
+    SCOPED_TRACE("contain and intersect: reversed");
+    ui::Range r1(12, 10);
+    ui::Range r2(8, 1);
+    ui::Range r3(12, 5);
+    TestContainsAndIntersects(r1, r2, r3);
+  }
+  // Invalid rect tests
+  ui::Range r1(10, 12);
+  ui::Range r2(8, 1);
+  ui::Range invalid = r1.Intersect(r2);
+  EXPECT_FALSE(invalid.IsValid());
+  EXPECT_FALSE(invalid.Contains(invalid));
+  EXPECT_FALSE(invalid.Contains(r1));
+  EXPECT_FALSE(invalid.Intersects(invalid));
+  EXPECT_FALSE(invalid.Intersects(r1));
+  EXPECT_FALSE(r1.Contains(invalid));
+  EXPECT_FALSE(r1.Intersects(invalid));
+}
+
 #if defined(OS_WIN)
 TEST(RangeTest, FromCHARRANGE) {
   CHARRANGE cr = { 10, 32 };