Rename Origin.unique() to opaque().

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 17 matching lines @@
   EXPECT_EQ(a_parsed.port.begin, b_parsed.port.begin);
   EXPECT_EQ(a_parsed.port.len, b_parsed.port.len);
   EXPECT_EQ(a_parsed.path.begin, b_parsed.path.begin);
   EXPECT_EQ(a_parsed.path.len, b_parsed.path.len);
   EXPECT_EQ(a_parsed.query.begin, b_parsed.query.begin);
   EXPECT_EQ(a_parsed.query.len, b_parsed.query.len);
   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));
+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));
 
   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.unique());
+    EXPECT_TRUE(origin.opaque());
     EXPECT_FALSE(origin.IsSameOriginWith(origin));
-    EXPECT_FALSE(unique_origin.IsSameOriginWith(origin));
-    EXPECT_FALSE(origin.IsSameOriginWith(unique_origin));
+    EXPECT_FALSE(opaque_origin.IsSameOriginWith(origin));
+    EXPECT_FALSE(origin.IsSameOriginWith(opaque_origin));
 
     ExpectParsedUrlsEqual(GURL(origin.Serialize()), origin.GetURL());
   }
 }
 
 TEST(OriginTest, ConstructFromTuple) {
   struct TestCases {
     const char* const scheme;
     const char* const host;
     const uint16_t port;
@@ skipping 80 matching lines @@
   };
 
   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_FALSE(origin.opaque());
     EXPECT_TRUE(origin.IsSameOriginWith(origin));
     EXPECT_FALSE(different_origin.IsSameOriginWith(origin));
     EXPECT_FALSE(origin.IsSameOriginWith(different_origin));
 
     ExpectParsedUrlsEqual(GURL(origin.Serialize()), origin.GetURL());
   }
 }
 
 TEST(OriginTest, Serialization) {
   struct TestCases {
@@ skipping 63 matching lines @@
   };
 
   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);
     std::string serialized = origin.Serialize();
     std::string serialized_physical_origin =
         origin.GetPhysicalOrigin().Serialize();
-    EXPECT_FALSE(origin.unique());
+    EXPECT_FALSE(origin.opaque());
     EXPECT_EQ(test_case.expected_suborigin, origin.suborigin());
     ExpectParsedUrlsEqual(GURL(serialized), origin.GetURL());
 
     EXPECT_EQ(test_case.expected, serialized);
     EXPECT_EQ(test_case.expected_physical_origin, serialized_physical_origin);
 
     // The '<<' operator should produce the same serialization as Serialize().
     std::stringstream out;
     out << origin;
     EXPECT_EQ(test_case.expected, out.str());
   }
 
   const char* const failure_cases[] = {
       "http-so://.",  "http-so://foo",  "http-so://.foo",  "http-so://foo.",
       "https-so://.", "https-so://foo", "https-so://.foo", "https-so://foo.",
   };
 
   for (auto* test_case : failure_cases) {
     SCOPED_TRACE(test_case);
     GURL url(test_case);
     EXPECT_TRUE(url.is_valid());
     url::Origin origin(url);
     std::string serialized = origin.Serialize();
     std::string serialized_physical_origin =
         origin.GetPhysicalOrigin().Serialize();
-    EXPECT_TRUE(origin.unique());
+    EXPECT_TRUE(origin.opaque());
     EXPECT_EQ("", origin.suborigin());
     ExpectParsedUrlsEqual(GURL(serialized), origin.GetURL());
 
     EXPECT_EQ("null", serialized);
     EXPECT_EQ("null", serialized_physical_origin);
   }
 }
 
 TEST(OriginTest, SuboriginIsSameOriginWith) {
   struct TestCases {
@@ skipping 76 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(test.scheme, origin.scheme());
     EXPECT_EQ(test.host, origin.host());
     EXPECT_EQ(test.port, origin.port());
-    EXPECT_FALSE(origin.unique());
+    EXPECT_FALSE(origin.opaque());
     EXPECT_TRUE(origin.IsSameOriginWith(origin));
 
     ExpectParsedUrlsEqual(GURL(origin.Serialize()), origin.GetURL());
   }
 }
 
 TEST(OriginTest, UnsafelyCreateUniqueOnInvalidInput) {
   struct TestCases {
     const char* scheme;
     const char* host;
@@ skipping 16 matching lines @@
                {"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_TRUE(origin.opaque());
     EXPECT_FALSE(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.unique());
+    EXPECT_TRUE(origin.opaque());
     EXPECT_FALSE(origin.IsSameOriginWith(origin));
 
     ExpectParsedUrlsEqual(GURL(origin.Serialize()), origin.GetURL());
   }
 }
 
 TEST(OriginTest, DomainIs) {
   const struct {
     const char* url;
     const char* lower_ascii_domain;
@@ skipping 44 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