Have Permission{Manager,Service} use Origin.

url/origin_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
 namespace {
 
 TEST(OriginTest, UniqueOriginComparison) {
   url::Origin unique_origin;
   EXPECT_EQ("", unique_origin.scheme());
   EXPECT_EQ("", unique_origin.host());
   EXPECT_EQ(0, unique_origin.port());
   EXPECT_TRUE(unique_origin.unique());
   EXPECT_FALSE(unique_origin.IsSameOriginWith(unique_origin));
 
   const char* const urls[] = {"data:text/html,Hello!",
                               "javascript:alert(1)",
                               "file://example.com:443/etc/passwd",
-                              "yay",
                               "http::///invalid.example.com/"};
 
   for (const auto& test_url : urls) {
     SCOPED_TRACE(test_url);
     GURL url(test_url);
     url::Origin origin(url);
     EXPECT_EQ("", origin.scheme());
     EXPECT_EQ("", origin.host());
     EXPECT_EQ(0, origin.port());
     EXPECT_TRUE(origin.unique());
@@ skipping 41 matching lines @@
       {"file://example.com/etc/passwd", "file", "example.com", 0},
 
       // Filesystem:
       {"filesystem:http://example.com/type/", "http", "example.com", 80},
       {"filesystem:http://example.com:123/type/", "http", "example.com", 123},
       {"filesystem:https://example.com/type/", "https", "example.com", 443},
       {"filesystem:https://example.com:123/type/", "https", "example.com", 123},
 
       // Blob:
       {"blob:http://example.com/guid-goes-here", "http", "example.com", 80},
-      {"blob:http://example.com:123/guid-goes-here", "http", "example.com", 123},
+      {"blob:http://example.com:123/guid-goes-here", "http", "example.com",
+       123},
       {"blob:https://example.com/guid-goes-here", "https", "example.com", 443},
       {"blob:http://u:p@example.com/guid-goes-here", "http", "example.com", 80},
   };
 
   for (const auto& test_case : cases) {
     SCOPED_TRACE(test_case.url);
     GURL url(test_case.url);
     EXPECT_TRUE(url.is_valid());
     url::Origin origin(url);
     EXPECT_EQ(test_case.expected_scheme, origin.scheme());
     EXPECT_EQ(test_case.expected_host, origin.host());
     EXPECT_EQ(test_case.expected_port, origin.port());
     EXPECT_FALSE(origin.unique());
     EXPECT_TRUE(origin.IsSameOriginWith(origin));
     EXPECT_FALSE(different_origin.IsSameOriginWith(origin));
     EXPECT_FALSE(origin.IsSameOriginWith(different_origin));
   }
+
+  const char* empties[] = {"yay", ""};

[Mike West, 2016/03/04 06:09:56]

Hrm. Why is "GURL('yay')" empty? I would have expected an invalid URL to produce
a unique origin. Though maybe I'm misremembering what GURL does? Is
`GURL('yay')` both invalid and empty? I expect it to be invalid but non-empty...

[palmer, 2016/03/08 01:20:00]

GURL("yay") is invalid and empty.

I'm not sure why, or if that is correct or desirable. But that's how it is now.
:)

+  for (const auto& empty : empties) {
+    GURL test_url(empty);
+    url::Origin origin(test_url);
+    EXPECT_EQ("", origin.scheme());
+    EXPECT_EQ("", origin.host());
+    EXPECT_EQ(0, origin.port());
+    EXPECT_TRUE(origin.empty());
+  }
 }
 
 TEST(OriginTest, Serialization) {
   struct TestCases {
     const char* const url;
     const char* const expected;
   } cases[] = {
       {"http://192.168.9.1/", "http://192.168.9.1"},
       {"http://[2001:db8::1]/", "http://[2001:db8::1]"},
       {"http://☃.net/", "http://xn--n3h.net"},
       {"http://example.com/", "http://example.com"},
       {"http://example.com:123/", "http://example.com:123"},
       {"https://example.com/", "https://example.com"},
       {"https://example.com:123/", "https://example.com:123"},
       {"file:///etc/passwd", "file://"},
       {"file://example.com/etc/passwd", "file://"},
+      {"data:uniqueness", "null"},
   };
 
   for (const auto& test_case : cases) {
     SCOPED_TRACE(test_case.url);
     GURL url(test_case.url);
     EXPECT_TRUE(url.is_valid());
     url::Origin origin(url);
     EXPECT_EQ(test_case.expected, origin.Serialize());
 
     // The '<<' operator should produce the same serialization as Serialize().
     std::stringstream out;
     out << origin;
     EXPECT_EQ(test_case.expected, out.str());
   }
+
+  GURL empty_url("");
+  EXPECT_FALSE(empty_url.is_valid());
+  url::Origin empty_origin(empty_url);
+  EXPECT_EQ("", empty_origin.Serialize());
+  std::stringstream out;
+  out << empty_origin;
+  EXPECT_EQ("", out.str());
 }
 
 TEST(OriginTest, Comparison) {
   // These URLs are arranged in increasing order:
   const char* const urls[] = {
       "data:uniqueness",
       "http://a:80",
       "http://b:80",
       "https://a:80",
       "https://b:80",
@@ skipping 40 matching lines @@
     EXPECT_FALSE(origin.unique());
     EXPECT_TRUE(origin.IsSameOriginWith(origin));
   }
 }
 
 TEST(OriginTest, UnsafelyCreateUniqueOnInvalidInput) {
   struct TestCases {
     const char* scheme;
     const char* host;
     uint16_t port;
-  } cases[] = {{"", "", 0},
-               {"data", "", 0},
+  } cases[] = {{"data", "", 0},
                {"blob", "", 0},
                {"filesystem", "", 0},
                {"data", "example.com", 80},
                {"http", "☃.net", 80},
                {"http\nmore", "example.com", 80},
                {"http\rmore", "example.com", 80},
                {"http\n", "example.com", 80},
                {"http\r", "example.com", 80},
                {"http", "example.com\nnot-example.com", 80},
                {"http", "example.com\rnot-example.com", 80},
                {"http", "example.com\n", 80},
                {"http", "example.com\r", 80},
                {"http", "example.com", 0},
                {"file", "", 80}};
 
   for (const auto& test : cases) {
     SCOPED_TRACE(testing::Message() << test.scheme << "://" << test.host << ":"
                                     << test.port);
     url::Origin origin = url::Origin::UnsafelyCreateOriginWithoutNormalization(
         test.scheme, test.host, test.port);
     EXPECT_EQ("", origin.scheme());
     EXPECT_EQ("", origin.host());
     EXPECT_EQ(0, origin.port());
     EXPECT_TRUE(origin.unique());
     EXPECT_FALSE(origin.IsSameOriginWith(origin));
   }
+
+  url::Origin origin =
+      url::Origin::UnsafelyCreateOriginWithoutNormalization("", "", 0);
+  EXPECT_EQ("", origin.scheme());
+  EXPECT_EQ("", origin.host());
+  EXPECT_EQ(0, origin.port());
+  EXPECT_TRUE(origin.unique());
+  EXPECT_TRUE(origin.IsSameOriginWith(origin));

[Mike West, 2016/03/04 06:09:56]

Nit: `EXPECT_TRUE(origin.empty());`

[palmer, 2016/03/08 01:20:00]

Done.

 }
 
 TEST(OriginTest, UnsafelyCreateUniqueViaEmbeddedNulls) {
   struct TestCases {
     const char* scheme;
     size_t scheme_length;
     const char* host;
     size_t host_length;
     uint16_t port;
   } cases[] = {{"http\0more", 9, "example.com", 11, 80},
@@ skipping 11 matching lines @@
         std::string(test.host, test.host_length), test.port);
     EXPECT_EQ("", origin.scheme());
     EXPECT_EQ("", origin.host());
     EXPECT_EQ(0, origin.port());
     EXPECT_TRUE(origin.unique());
     EXPECT_FALSE(origin.IsSameOriginWith(origin));
   }
 }
 
 }  // namespace url