Allow a unique origin to compare equal to itself

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"
@@ skipping 23 matching lines @@
   EXPECT_EQ(a_parsed.ref.begin, b_parsed.ref.begin);
   EXPECT_EQ(a_parsed.ref.len, b_parsed.ref.len);
 }
 
 TEST(OriginTest, OpaqueOriginComparison) {
   url::Origin opaque_origin;
   EXPECT_EQ("", opaque_origin.scheme());
   EXPECT_EQ("", opaque_origin.host());
   EXPECT_EQ(0, opaque_origin.port());
   EXPECT_TRUE(opaque_origin.opaque());
-  EXPECT_FALSE(opaque_origin.IsSameOriginWith(opaque_origin));
+  // An opaque origin is same origin with itself
+  EXPECT_TRUE(opaque_origin.IsSameOriginWith(opaque_origin));
+  // An opaque origin is not same origin with any other opaque origin
+  url::Origin second_opaque_origin;
+  EXPECT_FALSE(opaque_origin.IsSameOriginWith(second_opaque_origin));
+  EXPECT_FALSE(second_opaque_origin.IsSameOriginWith(opaque_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);
     EXPECT_EQ("", origin.scheme());
     EXPECT_EQ("", origin.host());
     EXPECT_EQ(0, origin.port());
     EXPECT_TRUE(origin.opaque());
-    EXPECT_FALSE(origin.IsSameOriginWith(origin));
+
+    // An opaque origin is same origin with itself
+    EXPECT_TRUE(origin.IsSameOriginWith(origin));
+
+    // An opaque origin is not same origin with any other opaque origin
     EXPECT_FALSE(opaque_origin.IsSameOriginWith(origin));
     EXPECT_FALSE(origin.IsSameOriginWith(opaque_origin));
 
+    // A second opaque origin from the same source string is not same origin
+    // with the first.
+    url::Origin duplicated_origin(url);
+    EXPECT_FALSE(origin.IsSameOriginWith(duplicated_origin));
+    EXPECT_FALSE(duplicated_origin.IsSameOriginWith(origin));
+
+    // A copy of an opaque origin is not same origin with the original.
+    url::Origin copied_origin(origin);
+    EXPECT_FALSE(origin.IsSameOriginWith(copied_origin));
+    EXPECT_FALSE(copied_origin.IsSameOriginWith(origin));
+
     ExpectParsedUrlsEqual(GURL(origin.Serialize()), origin.GetURL());
   }
 }
 
 TEST(OriginTest, ConstructFromTuple) {
   struct TestCases {
     const char* const scheme;
     const char* const host;
     const uint16_t port;
     const char* const suborigin;
@@ skipping 324 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.opaque());
-    EXPECT_FALSE(origin.IsSameOriginWith(origin));
+
+    // An opaque origin is same origin with itself
+    EXPECT_TRUE(origin.IsSameOriginWith(origin));
+
+    // A second opaque origin from the same URL components is not same origin
+    // with the first.
+    url::Origin duplicated_origin =
+        url::Origin::UnsafelyCreateOriginWithoutNormalization(
+            test.scheme, test.host, test.port, "");
+    EXPECT_FALSE(origin.IsSameOriginWith(duplicated_origin));
+    EXPECT_FALSE(duplicated_origin.IsSameOriginWith(origin));
 
     ExpectParsedUrlsEqual(GURL(origin.Serialize()), origin.GetURL());
   }
 }
 
 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.opaque());
-    EXPECT_FALSE(origin.IsSameOriginWith(origin));
+
+    // An opaque origin is same origin with itself
+    EXPECT_TRUE(origin.IsSameOriginWith(origin));
+
+    // A second opaque origin from the same URL components is not same origin
+    // with the first.
+    url::Origin duplicated_origin =
+        url::Origin::UnsafelyCreateOriginWithoutNormalization(
+            std::string(test.scheme, test.scheme_length),
+            std::string(test.host, test.host_length), test.port, "");
+    EXPECT_FALSE(origin.IsSameOriginWith(duplicated_origin));
+    EXPECT_FALSE(duplicated_origin.IsSameOriginWith(origin));
 
     ExpectParsedUrlsEqual(GURL(origin.Serialize()), origin.GetURL());
   }
 }
 
 TEST(OriginTest, DomainIs) {
   const struct {
     const char* url;
     const char* lower_ascii_domain;
     bool expected_domain_is;
@@ skipping 43 matching lines @@
   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"));
 }
 
 }  // namespace url