Add an identity component for unique/opaque url::Origins.

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 <map>
+
 #include "base/logging.h"
 #include "base/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
 namespace {
 
 void ExpectParsedUrlsEqual(const GURL& a, const GURL& b) {
   EXPECT_EQ(a, b);
@@ skipping 16 matching lines @@
   EXPECT_EQ(a_parsed.ref.begin, b_parsed.ref.begin);
   EXPECT_EQ(a_parsed.ref.len, b_parsed.ref.len);
 }
 
 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));
+  EXPECT_TRUE(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 (auto* test_url : urls) {
     SCOPED_TRACE(test_url);
     GURL url(test_url);
     url::Origin origin(url);
+    url::Origin origin_copy(origin);
     EXPECT_EQ("", origin.scheme());
     EXPECT_EQ("", origin.host());
     EXPECT_EQ(0, origin.port());
     EXPECT_TRUE(origin.unique());
-    EXPECT_FALSE(origin.IsSameOriginWith(origin));
+    EXPECT_TRUE(origin.IsSameOriginWith(origin));
     EXPECT_FALSE(unique_origin.IsSameOriginWith(origin));
     EXPECT_FALSE(origin.IsSameOriginWith(unique_origin));
 
     ExpectParsedUrlsEqual(GURL(origin.Serialize()), origin.GetURL());
+
+    // A unique origin should always be same origin to itself…
+    EXPECT_TRUE(origin.IsSameOriginWith(origin_copy));
+
+    // …but it shouldn't be same origin if it's created again.
+    url::Origin origin2(url);
+    EXPECT_FALSE(origin.IsSameOriginWith(origin2));
+    EXPECT_FALSE(origin2.IsSameOriginWith(origin));
   }
 }
 
 TEST(OriginTest, ConstructFromTuple) {
   struct TestCases {
     const char* const scheme;
     const char* const host;
     const uint16_t port;
     const char* const suborigin;
   } cases[] = {
@@ skipping 239 matching lines @@
     EXPECT_TRUE(origin2.IsSamePhysicalOriginWith(origin2));
     EXPECT_EQ(test_case.is_same_physical_origin,
               origin1.IsSamePhysicalOriginWith(origin2));
     EXPECT_EQ(test_case.is_same_physical_origin,
               origin2.IsSamePhysicalOriginWith(origin1));
   }
 }
 
 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",
-      "http://a:81",
-      "http://b:81",
-      "https://a:81",
-      "https://b:81",
+  url::Origin origins[] = {
+      url::Origin(GURL("data:uniqueness")), url::Origin(GURL("http://a:80")),
+      url::Origin(GURL("http://b:80")),     url::Origin(GURL("https://a:80")),
+      url::Origin(GURL("https://b:80")),    url::Origin(GURL("http://a:81")),
+      url::Origin(GURL("http://b:81")),     url::Origin(GURL("https://a:81")),
+      url::Origin(GURL("https://b:81")),
   };
 
-  for (size_t i = 0; i < arraysize(urls); i++) {
-    GURL current_url(urls[i]);
-    url::Origin current(current_url);
-    for (size_t j = i; j < arraysize(urls); j++) {
-      GURL compare_url(urls[j]);
-      url::Origin to_compare(compare_url);
-      EXPECT_EQ(i < j, current < to_compare) << i << " < " << j;
-      EXPECT_EQ(j < i, to_compare < current) << j << " < " << i;
+  for (size_t i = 0; i < arraysize(origins); i++) {
+    for (size_t j = i; j < arraysize(origins); j++) {
+      EXPECT_EQ(i < j, origins[i] < origins[j]) << i << " < " << j;
+      EXPECT_EQ(j < i, origins[j] < origins[i]) << j << " < " << i;
     }
   }
 }
 
 TEST(OriginTest, UnsafelyCreate) {
   struct TestCase {
     const char* scheme;
     const char* host;
     uint16_t port;
   } cases[] = {
@@ skipping 44 matching lines @@
 
   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));
 
     ExpectParsedUrlsEqual(GURL(origin.Serialize()), origin.GetURL());
+
+    // A unique origin should always be same origin to itself…
+    EXPECT_TRUE(origin.IsSameOriginWith(origin));
+
+    // …but it shouldn't be same origin if it's created again.
+    url::Origin origin2 = url::Origin::UnsafelyCreateOriginWithoutNormalization(
+        test.scheme, test.host, test.port);
+    EXPECT_FALSE(origin.IsSameOriginWith(origin2));
+    EXPECT_FALSE(origin2.IsSameOriginWith(origin));
   }
 }
 
 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},
                {"http\0", 5, "example.com", 11, 80},
                {"\0http", 5, "example.com", 11, 80},
                {"http", 4, "example.com\0not-example.com", 27, 80},
                {"http", 4, "example.com\0", 12, 80},
                {"http", 4, "\0example.com", 12, 80}};
 
   for (const auto& test : cases) {
     SCOPED_TRACE(testing::Message() << test.scheme << "://" << test.host << ":"
                                     << test.port);
     url::Origin origin = url::Origin::UnsafelyCreateOriginWithoutNormalization(
         std::string(test.scheme, test.scheme_length),
         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));
 
     ExpectParsedUrlsEqual(GURL(origin.Serialize()), origin.GetURL());
+
+    // A unique origin should always be same origin to itself…
+    EXPECT_TRUE(origin.IsSameOriginWith(origin));
+
+    // …but it shouldn't be same origin if it's created again.
+    url::Origin origin2 = url::Origin::UnsafelyCreateOriginWithoutNormalization(
+        std::string(test.scheme, test.scheme_length),
+        std::string(test.host, test.host_length), test.port);
+    EXPECT_FALSE(origin.IsSameOriginWith(origin2));
+    EXPECT_FALSE(origin2.IsSameOriginWith(origin));
   }
 }
 
 TEST(OriginTest, DomainIs) {
   const struct {
     const char* url;
     const char* lower_ascii_domain;
     bool expected_domain_is;
   } kTestCases[] = {
       {"http://google.com/foo", "google.com", true},
@@ skipping 40 matching lines @@
   // If the URL is invalid, DomainIs returns false.
   GURL invalid_url("google.com");
   ASSERT_FALSE(invalid_url.is_valid());
   EXPECT_FALSE(url::Origin(invalid_url).DomainIs("google.com"));
 
   // Unique origins.
   EXPECT_FALSE(url::Origin().DomainIs(""));
   EXPECT_FALSE(url::Origin().DomainIs("com"));
 }
 
+TEST(OriginTest, UniqueOriginsInSet) {
+  std::set<url::Origin> origins;
+  EXPECT_TRUE(origins.empty());
+
+  url::Origin origin1;
+  origins.insert(origin1);
+  EXPECT_EQ(1u, origins.size());
+  EXPECT_TRUE(origins.find(origin1) != origins.end());
+
+  url::Origin origin2;
+  origins.insert(origin2);
+  EXPECT_EQ(2u, origins.size());
+  EXPECT_TRUE(origins.find(origin2) != origins.end());
+
+  {
+    auto result = origins.insert(origin1);
+    EXPECT_FALSE(result.second);
+    EXPECT_TRUE(origin1.IsSameOriginWith(*result.first));
+  }
+
+  {
+    auto result = origins.insert(origin2);
+    EXPECT_FALSE(result.second);
+    EXPECT_TRUE(origin2.IsSameOriginWith(*result.first));
+  }
+
+  EXPECT_EQ(2u, origins.size());
+}
+
 }  // namespace url