Support requesting subsets of host permissions using the permissions API.

extensions/common/url_pattern_unittest.cc

Index: extensions/common/url_pattern_unittest.cc
diff --git a/extensions/common/url_pattern_unittest.cc b/extensions/common/url_pattern_unittest.cc
index c37b73d7734bd91a2e4ca10489c1ed5ca10e7f0d..939d6a5db86dd0774e4141989aaf34c00244f03b 100644
--- a/extensions/common/url_pattern_unittest.cc
+++ b/extensions/common/url_pattern_unittest.cc
@@ -7,6 +7,8 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "googleurl/src/gurl.h"
 
+namespace {
+
 // See url_pattern.h for examples of valid and invalid patterns.
 
 static const int kAllSchemes =
@@ -448,12 +450,18 @@ TEST(ExtensionURLPatternTest, GetAsString) {
   }
 }
 
-void TestPatternOverlap(const URLPattern& pattern1, const URLPattern& pattern2,
-                        bool expect_overlap) {
-  EXPECT_EQ(expect_overlap, pattern1.OverlapsWith(pattern2))
-      << pattern1.GetAsString() << ", " << pattern2.GetAsString();
-  EXPECT_EQ(expect_overlap, pattern2.OverlapsWith(pattern1))
-      << pattern2.GetAsString() << ", " << pattern1.GetAsString();
+testing::AssertionResult OverlapsWith(const URLPattern& pattern1,

[Matt Perry, 2013/02/12 19:07:17]

nit: Overlap would be more accurate since it doesn't imply direction

[not at google - send to devlin, 2013/02/12 19:56:20]

Done.

+                                      const URLPattern& pattern2) {
+  if (!pattern1.OverlapsWith(pattern2)) {
+    return testing::AssertionFailure()
+        << pattern1 << " does not overlap " << pattern2;
+  }
+  if (!pattern2.OverlapsWith(pattern1)) {
+    return testing::AssertionFailure()
+        << pattern2 << " does not overlap " << pattern1;
+  }
+  return testing::AssertionSuccess()
+      << pattern1 << " overlaps with " << pattern2;
 }
 
 TEST(ExtensionURLPatternTest, OverlapsWith) {
@@ -469,22 +477,22 @@ TEST(ExtensionURLPatternTest, OverlapsWith) {
   URLPattern pattern9(URLPattern::SCHEME_HTTPS, "*://*/*");
   URLPattern pattern10(kAllSchemes, "<all_urls>");
 
-  TestPatternOverlap(pattern1, pattern1, true);
-  TestPatternOverlap(pattern1, pattern2, false);
-  TestPatternOverlap(pattern1, pattern3, true);
-  TestPatternOverlap(pattern1, pattern4, false);
-  TestPatternOverlap(pattern3, pattern4, false);
-  TestPatternOverlap(pattern4, pattern5, false);
-  TestPatternOverlap(pattern5, pattern6, true);
+  EXPECT_TRUE(OverlapsWith(pattern1, pattern1));
+  EXPECT_FALSE(OverlapsWith(pattern1, pattern2));
+  EXPECT_TRUE(OverlapsWith(pattern1, pattern3));
+  EXPECT_FALSE(OverlapsWith(pattern1, pattern4));
+  EXPECT_FALSE(OverlapsWith(pattern3, pattern4));
+  EXPECT_FALSE(OverlapsWith(pattern4, pattern5));
+  EXPECT_TRUE(OverlapsWith(pattern5, pattern6));
 
   // Test that scheme restrictions work.
-  TestPatternOverlap(pattern1, pattern8, true);
-  TestPatternOverlap(pattern1, pattern9, false);
-  TestPatternOverlap(pattern1, pattern10, true);
+  EXPECT_TRUE(OverlapsWith(pattern1, pattern8));
+  EXPECT_FALSE(OverlapsWith(pattern1, pattern9));
+  EXPECT_TRUE(OverlapsWith(pattern1, pattern10));
 
   // Test that '<all_urls>' includes file URLs, while scheme '*' does not.
-  TestPatternOverlap(pattern7, pattern8, false);
-  TestPatternOverlap(pattern7, pattern10, true);
+  EXPECT_FALSE(OverlapsWith(pattern7, pattern8));
+  EXPECT_TRUE(OverlapsWith(pattern7, pattern10));
 
   // Test that wildcard schemes are handled correctly, especially when compared
   // to each-other.
@@ -492,14 +500,14 @@ TEST(ExtensionURLPatternTest, OverlapsWith) {
   URLPattern pattern12(kAllSchemes, "*://example.com/*");
   URLPattern pattern13(kAllSchemes, "*://example.com/foo/*");
   URLPattern pattern14(kAllSchemes, "*://google.com/*");
-  TestPatternOverlap(pattern8, pattern12, true);
-  TestPatternOverlap(pattern9, pattern12, true);
-  TestPatternOverlap(pattern10, pattern12, true);
-  TestPatternOverlap(pattern11, pattern12, true);
-  TestPatternOverlap(pattern12, pattern13, true);
-  TestPatternOverlap(pattern11, pattern13, true);
-  TestPatternOverlap(pattern14, pattern12, false);
-  TestPatternOverlap(pattern14, pattern13, false);
+  EXPECT_TRUE(OverlapsWith(pattern8, pattern12));
+  EXPECT_TRUE(OverlapsWith(pattern9, pattern12));
+  EXPECT_TRUE(OverlapsWith(pattern10, pattern12));
+  EXPECT_TRUE(OverlapsWith(pattern11, pattern12));
+  EXPECT_TRUE(OverlapsWith(pattern12, pattern13));
+  EXPECT_TRUE(OverlapsWith(pattern11, pattern13));
+  EXPECT_FALSE(OverlapsWith(pattern14, pattern12));
+  EXPECT_FALSE(OverlapsWith(pattern14, pattern13));
 }
 
 TEST(ExtensionURLPatternTest, ConvertToExplicitSchemes) {
@@ -657,3 +665,108 @@ TEST(ExtensionURLPatternTest, CanReusePatternWithParse) {
   EXPECT_FALSE(pattern3.MatchesURL(GURL("http://aa.com/path")));
   EXPECT_TRUE(pattern3.MatchesURL(GURL("http://aa.com:88/path")));
 }
+
+// Returns success if neither |a| nor |b| encompasses the other.
+testing::AssertionResult NeitherEncompasses(const URLPattern& a,
+                                            const URLPattern& b) {
+  if (a.Encompasses(b))
+    return testing::AssertionFailure() << a << " encompasses " << b;
+  if (b.Encompasses(a))
+    return testing::AssertionFailure() << b << " encompasses " << a;
+  return testing::AssertionSuccess() <<
+      "Neither " << a << " nor " << b << " encompass the other";
+}
+
+// Returns success if |a| encompasses |b| but not the other way around.
+testing::AssertionResult StrictlyEncompasses(const URLPattern& a,
+                                             const URLPattern& b) {
+  if (!a.Encompasses(b))
+    return testing::AssertionFailure() << a << " does not encompass " << b;
+  if (b.Encompasses(a))
+    return testing::AssertionFailure() << b << " encompasses " << a;
+  return testing::AssertionSuccess() << a << " strictly encompasses " << b;
+}
+
+TEST(ExtensionURLPatternTest, Subset) {
+  URLPattern pattern1(kAllSchemes, "http://www.google.com/foo/*");
+  URLPattern pattern2(kAllSchemes, "https://www.google.com/foo/*");
+  URLPattern pattern3(kAllSchemes, "http://*.google.com/foo/*");
+  URLPattern pattern4(kAllSchemes, "http://*.yahooo.com/foo/*");
+  URLPattern pattern5(kAllSchemes, "http://www.yahooo.com/bar/*");
+  URLPattern pattern6(kAllSchemes, "http://www.yahooo.com/bar/baz/*");
+  URLPattern pattern7(kAllSchemes, "file:///*");
+  URLPattern pattern8(kAllSchemes, "*://*/*");
+  URLPattern pattern9(URLPattern::SCHEME_HTTPS, "*://*/*");
+  URLPattern pattern10(kAllSchemes, "<all_urls>");
+  URLPattern pattern11(kAllSchemes, "http://example.com/*");
+  URLPattern pattern12(kAllSchemes, "*://example.com/*");
+  URLPattern pattern13(kAllSchemes, "*://example.com/foo/*");
+
+  // All patterns should encompass themselves.
+  EXPECT_TRUE(pattern1.Encompasses(pattern1));
+  EXPECT_TRUE(pattern2.Encompasses(pattern2));
+  EXPECT_TRUE(pattern3.Encompasses(pattern3));
+  EXPECT_TRUE(pattern4.Encompasses(pattern4));
+  EXPECT_TRUE(pattern5.Encompasses(pattern5));
+  EXPECT_TRUE(pattern6.Encompasses(pattern6));
+  EXPECT_TRUE(pattern7.Encompasses(pattern7));
+  EXPECT_TRUE(pattern8.Encompasses(pattern8));
+  EXPECT_TRUE(pattern9.Encompasses(pattern9));
+  EXPECT_TRUE(pattern10.Encompasses(pattern10));
+  EXPECT_TRUE(pattern11.Encompasses(pattern11));
+  EXPECT_TRUE(pattern12.Encompasses(pattern12));
+  EXPECT_TRUE(pattern13.Encompasses(pattern13));
+
+  // pattern1's relationship to the other patterns.
+  EXPECT_TRUE(NeitherEncompasses(pattern1, pattern2));
+  EXPECT_TRUE(StrictlyEncompasses(pattern3, pattern1));
+  EXPECT_TRUE(NeitherEncompasses(pattern1, pattern4));
+  EXPECT_TRUE(NeitherEncompasses(pattern1, pattern5));
+  EXPECT_TRUE(NeitherEncompasses(pattern1, pattern6));
+  EXPECT_TRUE(NeitherEncompasses(pattern1, pattern7));
+  EXPECT_TRUE(StrictlyEncompasses(pattern8, pattern1));
+  EXPECT_TRUE(NeitherEncompasses(pattern1, pattern9));
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern1));
+  EXPECT_TRUE(NeitherEncompasses(pattern1, pattern11));
+  EXPECT_TRUE(NeitherEncompasses(pattern1, pattern12));
+  EXPECT_TRUE(NeitherEncompasses(pattern1, pattern13));
+
+  // pattern2's relationship to the other patterns.
+  EXPECT_TRUE(NeitherEncompasses(pattern2, pattern3));
+  EXPECT_TRUE(NeitherEncompasses(pattern2, pattern4));
+  EXPECT_TRUE(NeitherEncompasses(pattern2, pattern5));
+  EXPECT_TRUE(NeitherEncompasses(pattern2, pattern6));
+  EXPECT_TRUE(NeitherEncompasses(pattern2, pattern7));
+  EXPECT_TRUE(StrictlyEncompasses(pattern8, pattern2));
+  EXPECT_TRUE(StrictlyEncompasses(pattern9, pattern2));
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern2));
+  EXPECT_TRUE(NeitherEncompasses(pattern2, pattern11));
+  EXPECT_TRUE(NeitherEncompasses(pattern2, pattern12));
+  EXPECT_TRUE(NeitherEncompasses(pattern2, pattern13));
+
+  // Specifically test file:// URLs.
+  EXPECT_TRUE(NeitherEncompasses(pattern7, pattern8));
+  EXPECT_TRUE(NeitherEncompasses(pattern7, pattern9));
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern7));
+
+  // <all_urls> encompasses everything.
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern1));
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern2));
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern3));
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern4));
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern5));
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern6));
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern7));
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern8));
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern9));
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern11));
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern12));
+  EXPECT_TRUE(StrictlyEncompasses(pattern10, pattern13));
+
+  // More...
+  EXPECT_TRUE(StrictlyEncompasses(pattern12, pattern11));
+  EXPECT_TRUE(NeitherEncompasses(pattern11, pattern13));
+  EXPECT_TRUE(StrictlyEncompasses(pattern12, pattern13));
+}
+
+}  // namespace