Sharing more origin tests across url::Origin and blink::SecurityOrigin.

Bug: 1164416
Change-Id: Ie30d03a446c57f27af03aaccb8f199c9ce8c24cc
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2623152
Commit-Queue: Łukasz Anforowicz <lukasza@chromium.org>
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Auto-Submit: Łukasz Anforowicz <lukasza@chromium.org>
Cr-Commit-Position: refs/heads/master@{#845811}

third_party/blink/renderer/platform/weborigin/security_origin_test.cc

@@ -647,24 +647,6 @@ TEST_F(SecurityOriginTest, PunycodeNotUnicode) {
   EXPECT_FALSE(origin->CanRequest(unicode_url));
 }
 
-TEST_F(SecurityOriginTest, Port) {
-  struct TestCase {
-    uint16_t port;
-    const char* origin;
-  } cases[] = {
-      {80, "http://example.com"},       {80, "http://example.com:80"},
-      {81, "http://example.com:81"},    {443, "https://example.com"},
-      {443, "https://example.com:443"}, {444, "https://example.com:444"},
-      {0, "https://example.com:0"},     {0, "file:///"},
-  };
-
-  for (const auto& test : cases) {
-    scoped_refptr<const SecurityOrigin> origin =
-        SecurityOrigin::CreateFromString(test.origin);
-    EXPECT_EQ(test.port, origin->Port());
-  }
-}
-
 TEST_F(SecurityOriginTest, CreateFromTuple) {
   struct TestCase {
     const char* scheme;
@@ -979,29 +961,6 @@ TEST_F(SecurityOriginTest, ToTokenForFastCheck) {
   }
 }
 
-// See also OriginTest.ConstructFromGURL_OpaqueOrigin and
-// NavigationUrlRewriteBrowserTest.RewriteToNoAccess.
-TEST_F(SecurityOriginTest, StandardNoAccessScheme) {
-  url::ScopedSchemeRegistryForTests scoped_registry;
-  url::AddStandardScheme("std-no-access", url::SCHEME_WITH_HOST);
-  url::AddNoAccessScheme("std-no-access");
-  url::AddStandardScheme("std", url::SCHEME_WITH_HOST);
-
-  scoped_refptr<const SecurityOrigin> custom_standard_noaccess_origin =
-      SecurityOrigin::CreateFromString("std-no-access://host");
-  EXPECT_TRUE(custom_standard_noaccess_origin->IsOpaque());
-
-  scoped_refptr<const SecurityOrigin> custom_standard_origin =
-      SecurityOrigin::CreateFromString("std://host");
-  EXPECT_FALSE(custom_standard_origin->IsOpaque());
-}
-
-TEST_F(SecurityOriginTest, NonStandardScheme) {
-  scoped_refptr<const SecurityOrigin> origin =
-      SecurityOrigin::CreateFromString("cow://");
-  EXPECT_TRUE(origin->IsOpaque());
-}
-
 TEST_F(SecurityOriginTest, OpaqueIsolatedCopy) {
   scoped_refptr<const SecurityOrigin> origin =
       SecurityOrigin::CreateUniqueOpaque();
@@ -1297,25 +1256,60 @@ namespace url {
 class BlinkSecurityOriginTestTraits final
     : public url::OriginTraitsBase<scoped_refptr<blink::SecurityOrigin>> {
  public:
-  OriginType CreateOriginFromString(base::StringPiece s) const override {
-    return blink::SecurityOrigin::CreateFromString(
-        String(s.data(), s.length()));
+  OriginType CreateOriginFromString(base::StringPiece s) override {
+    return blink::SecurityOrigin::CreateFromString(String::FromUTF8(s));
+  }
+
+  OriginType CreateUniqueOpaqueOrigin() override {
+    return blink::SecurityOrigin::CreateUniqueOpaque();
+  }
+
+  OriginType CreateWithReferenceOrigin(
+      base::StringPiece url,
+      const OriginType& reference_origin) override {
+    return blink::SecurityOrigin::CreateWithReferenceOrigin(
+        blink::KURL(String::FromUTF8(url)), reference_origin.get());
+  }
+
+  OriginType DeriveNewOpaqueOrigin(
+      const OriginType& reference_origin) override {
+    return reference_origin->DeriveNewOpaqueOrigin();
   }
 
-  bool IsOpaque(const OriginType& origin) const override {
+  bool IsOpaque(const OriginType& origin) override {
     return origin->IsOpaque();
   }
 
-  std::string GetScheme(const OriginType& origin) const override {
+  std::string GetScheme(const OriginType& origin) override {
     return origin->Protocol().Utf8();
   }
 
-  std::string GetHost(const OriginType& origin) const override {
+  std::string GetHost(const OriginType& origin) override {
     return origin->Host().Utf8();
   }
 
-  uint16_t GetPort(const OriginType& origin) const override {
-    return origin->Port();
+  uint16_t GetPort(const OriginType& origin) override { return origin->Port(); }
+
+  SchemeHostPort GetTupleOrPrecursorTupleIfOpaque(
+      const OriginType& origin) override {
+    const blink::SecurityOrigin* precursor =
+        origin->GetOriginOrPrecursorOriginIfOpaque();
+    if (!precursor)
+      return SchemeHostPort();
+    return SchemeHostPort(precursor->Protocol().Utf8(),
+                          precursor->Host().Utf8(), precursor->Port());
+  }
+
+  bool IsSameOrigin(const OriginType& a, const OriginType& b) override {
+    return a->IsSameOriginWith(b.get());
+  }
+
+  std::string Serialize(const OriginType& origin) override {
+    return origin->ToString().Utf8();
+  }
+
+  bool IsValidUrl(base::StringPiece str) override {
+    return blink::KURL(String::FromUTF8(str)).IsValid();
   }
 };
 

url/origin_unittest.cc

@@ -262,8 +262,6 @@ TEST_F(OriginTest, OpaqueOriginComparison) {
       EXPECT_EQ(0, origin_copy.port());
       EXPECT_TRUE(origin_copy.opaque());
       EXPECT_EQ(origin, origin_copy);
-      // And it should always be cross-origin to another opaque Origin.
-      EXPECT_NE(origin, opaque_origin);
       // Re-creating from the URL should also be cross-origin.
       EXPECT_NE(origin, Origin::Create(url));
 
@@ -671,11 +669,6 @@ TEST_F(OriginTest, DebugAlias) {
   EXPECT_STREQ("https://foo.com", origin1_debug_alias);
 }
 
-TEST_F(OriginTest, NonStandardScheme) {
-  Origin origin = Origin::Create(GURL("cow://"));
-  EXPECT_TRUE(origin.opaque());
-}
-
 TEST_F(OriginTest, CanBeDerivedFrom) {
   AddStandardScheme("new-standard", SchemeType::SCHEME_WITH_HOST);
   Origin opaque_unique_origin = Origin();
@@ -965,24 +958,50 @@ TEST_F(OriginTest, DeserializeValidNonce) {
 
 class UrlOriginTestTraits final : public OriginTraitsBase<Origin> {
  public:
-  OriginType CreateOriginFromString(base::StringPiece s) const override {
+  OriginType CreateOriginFromString(base::StringPiece s) override {
     return Origin::Create(GURL(s));
   }
 
-  bool IsOpaque(const OriginType& origin) const override {
-    return origin.opaque();
+  OriginType CreateUniqueOpaqueOrigin() override { return Origin(); }
+
+  OriginType CreateWithReferenceOrigin(
+      base::StringPiece url,
+      const OriginType& reference_origin) override {
+    return Origin::Resolve(GURL(url), reference_origin);
   }
 
-  std::string GetScheme(const OriginType& origin) const override {
+  OriginType DeriveNewOpaqueOrigin(
+      const OriginType& reference_origin) override {
+    return reference_origin.DeriveNewOpaqueOrigin();
+  }
+
+  bool IsOpaque(const OriginType& origin) override { return origin.opaque(); }
+
+  std::string GetScheme(const OriginType& origin) override {
     return origin.scheme();
   }
 
-  std::string GetHost(const OriginType& origin) const override {
+  std::string GetHost(const OriginType& origin) override {
     return origin.host();
   }
 
-  uint16_t GetPort(const OriginType& origin) const override {
-    return origin.port();
+  uint16_t GetPort(const OriginType& origin) override { return origin.port(); }
+
+  SchemeHostPort GetTupleOrPrecursorTupleIfOpaque(
+      const OriginType& origin) override {
+    return origin.GetTupleOrPrecursorTupleIfOpaque();
+  }
+
+  bool IsSameOrigin(const OriginType& a, const OriginType& b) override {
+    return a.IsSameOriginWith(b);
+  }
+
+  std::string Serialize(const OriginType& origin) override {
+    return origin.Serialize();
+  }
+
+  bool IsValidUrl(base::StringPiece str) override {
+    return GURL(str).is_valid();
   }
 };