Updated suborigin serialization to latest spec proposal

third_party/WebKit/Source/platform/weborigin/SecurityOriginTest.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 18 matching lines @@
  */
 
 #include "platform/weborigin/SecurityOrigin.h"
 
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/blob/BlobURL.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/weborigin/SecurityPolicy.h"
 #include "platform/weborigin/Suborigin.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "url/url_util.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
 const int MaxAllowedPort = 65535;
 
-class SecurityOriginTest : public ::testing::Test { };
+class SecurityOriginTest : public ::testing::Test {
+public:
+    void SetUp() override
+    {
+        url::AddStandardScheme("http-so", url::SCHEME_WITH_PORT);
+        url::AddStandardScheme("https-so", url::SCHEME_WITH_PORT);
+    }
+};
 
 TEST_F(SecurityOriginTest, InvalidPortsCreateUniqueOrigins)
 {
     int ports[] = { -100, -1, MaxAllowedPort + 1, 1000000 };
 
     for (size_t i = 0; i < WTF_ARRAY_LENGTH(ports); ++i) {
         RefPtr<SecurityOrigin> origin = SecurityOrigin::create("http", "example.com", ports[i]);
         EXPECT_TRUE(origin->isUnique()) << "Port " << ports[i] << " should have generated a unique origin.";
     }
 }
@@ skipping 164 matching lines @@
     RuntimeEnabledFeatures::setSuboriginsEnabled(true);
 
     RefPtr<SecurityOrigin> origin = SecurityOrigin::createFromString("https://test.com");
     Suborigin suborigin;
     suborigin.setName("foobar");
     EXPECT_FALSE(origin->hasSuborigin());
     origin->addSuborigin(suborigin);
     EXPECT_TRUE(origin->hasSuborigin());
     EXPECT_EQ("foobar", origin->suborigin()->name());
 
-    origin = SecurityOrigin::createFromString("https://foobar_test.com");
+    origin = SecurityOrigin::createFromString("https-so://foobar.test.com");
     EXPECT_EQ("https", origin->protocol());
     EXPECT_EQ("test.com", origin->host());
     EXPECT_EQ("foobar", origin->suborigin()->name());
 
-    origin = SecurityOrigin::createFromString("https://foobar_test.com");
+    origin = SecurityOrigin::createFromString("https-so://foobar.test.com");
     EXPECT_TRUE(origin->hasSuborigin());
     EXPECT_EQ("foobar", origin->suborigin()->name());
 
     origin = SecurityOrigin::createFromString("https://foobar+test.com");
     EXPECT_FALSE(origin->hasSuborigin());
 
+    origin = SecurityOrigin::createFromString("https.so://foobar+test.com");
+    EXPECT_FALSE(origin->hasSuborigin());
+
     origin = SecurityOrigin::createFromString("https://_test.com");
     EXPECT_FALSE(origin->hasSuborigin());
 
+    origin = SecurityOrigin::createFromString("https-so://_test.com");
+    EXPECT_TRUE(origin->hasSuborigin());
+    EXPECT_EQ("_test", origin->suborigin()->name());
+
     origin = adoptRef<SecurityOrigin>(new SecurityOrigin);
     EXPECT_FALSE(origin->hasSuborigin());
 
-    origin = SecurityOrigin::createFromString("https://foobar_test.com");
+    origin = SecurityOrigin::createFromString("https-so://foobar.test.com");
     Suborigin emptySuborigin;
     EXPECT_DEATH(origin->addSuborigin(emptySuborigin), "");
 }

[nasko, 2016/09/19 22:20:21]

What about "http-so-so://foobar.test.com"?

[jww, 2016/09/20 00:24:32]

Test added to reject.

 
 TEST_F(SecurityOriginTest, SuboriginsParsing)
 {
     RuntimeEnabledFeatures::setSuboriginsEnabled(true);
-    String host, realHost, suborigin;
+    String protocol, realProtocol, host, realHost, suborigin;
+    protocol = "https";
     host = "test.com";
-    EXPECT_FALSE(SecurityOrigin::deserializeSuboriginAndHost(host, suborigin, realHost));
+    EXPECT_FALSE(SecurityOrigin::deserializeSuboriginAndProtocolAndHost(protocol, host, suborigin, realProtocol, realHost));
 
-    host = "foobar_test.com";
-    EXPECT_TRUE(SecurityOrigin::deserializeSuboriginAndHost(host, suborigin, realHost));
+    protocol = "https-so";
+    host = "foobar.test.com";
+    EXPECT_TRUE(SecurityOrigin::deserializeSuboriginAndProtocolAndHost(protocol, host, suborigin, realProtocol, realHost));
+    EXPECT_EQ("https", realProtocol);
     EXPECT_EQ("test.com", realHost);
     EXPECT_EQ("foobar", suborigin);
 
     RefPtr<SecurityOrigin> origin;
     StringBuilder builder;
 
-    origin = SecurityOrigin::createFromString("https://foobar_test.com");
+    origin = SecurityOrigin::createFromString("https-so://foobar.test.com");
     origin->buildRawString(builder, true);
-    EXPECT_EQ("https://foobar_test.com", builder.toString());
-    EXPECT_EQ("https://foobar_test.com", origin->toString());
+    EXPECT_EQ("https-so://foobar.test.com", builder.toString());
+    EXPECT_EQ("https-so://foobar.test.com", origin->toString());
     builder.clear();
     origin->buildRawString(builder, false);
     EXPECT_EQ("https://test.com", builder.toString());
     EXPECT_EQ("https://test.com", origin->toPhysicalOriginString());
 
     Suborigin suboriginObj;
     suboriginObj.setName("foobar");
     builder.clear();
     origin = SecurityOrigin::createFromString("https://test.com");
     origin->addSuborigin(suboriginObj);
     origin->buildRawString(builder, true);
-    EXPECT_EQ("https://foobar_test.com", builder.toString());
-    EXPECT_EQ("https://foobar_test.com", origin->toString());
+    EXPECT_EQ("https-so://foobar.test.com", builder.toString());
+    EXPECT_EQ("https-so://foobar.test.com", origin->toString());
     builder.clear();
     origin->buildRawString(builder, false);
     EXPECT_EQ("https://test.com", builder.toString());
     EXPECT_EQ("https://test.com", origin->toPhysicalOriginString());
 }
 
 TEST_F(SecurityOriginTest, SuboriginsIsSameSchemeHostPortAndSuborigin)
 {
     blink::RuntimeEnabledFeatures::setSuboriginsEnabled(true);
-    RefPtr<SecurityOrigin> origin = SecurityOrigin::createFromString("https://foobar_test.com");
-    RefPtr<SecurityOrigin> other1 = SecurityOrigin::createFromString("https://bazbar_test.com");
-    RefPtr<SecurityOrigin> other2 = SecurityOrigin::createFromString("http://foobar_test.com");
-    RefPtr<SecurityOrigin> other3 = SecurityOrigin::createFromString("https://foobar_test.com:1234");
+    RefPtr<SecurityOrigin> origin = SecurityOrigin::createFromString("https-so://foobar.test.com");
+    RefPtr<SecurityOrigin> other1 = SecurityOrigin::createFromString("https-so://bazbar.test.com");
+    RefPtr<SecurityOrigin> other2 = SecurityOrigin::createFromString("http-so://foobar.test.com");
+    RefPtr<SecurityOrigin> other3 = SecurityOrigin::createFromString("https-so://foobar.test.com:1234");
     RefPtr<SecurityOrigin> other4 = SecurityOrigin::createFromString("https://test.com");
 
     EXPECT_TRUE(origin->isSameSchemeHostPortAndSuborigin(origin.get()));
     EXPECT_FALSE(origin->isSameSchemeHostPortAndSuborigin(other1.get()));
     EXPECT_FALSE(origin->isSameSchemeHostPortAndSuborigin(other2.get()));
     EXPECT_FALSE(origin->isSameSchemeHostPortAndSuborigin(other3.get()));
     EXPECT_FALSE(origin->isSameSchemeHostPortAndSuborigin(other4.get()));
 }
 
 TEST_F(SecurityOriginTest, CanAccess)
 {
     RuntimeEnabledFeatures::setSuboriginsEnabled(true);
 
     struct TestCase {
         bool canAccess;
         bool canAccessCheckSuborigins;
         const char* origin1;
         const char* origin2;
     };
 
     TestCase tests[] = {
         { true, true, "https://foobar.com", "https://foobar.com" },
         { false, false, "https://foobar.com", "https://bazbar.com" },
-        { true, false, "https://foobar.com", "https://name_foobar.com" },
-        { true, false, "https://name_foobar.com", "https://foobar.com" },
-        { true, true, "https://name_foobar.com", "https://name_foobar.com" },
+        { true, false, "https://foobar.com", "https-so://name.foobar.com" },
+        { true, false, "https-so://name.foobar.com", "https://foobar.com" },
+        { true, true, "https-so://name.foobar.com", "https-so://name.foobar.com" },
     };
 
     for (size_t i = 0; i < WTF_ARRAY_LENGTH(tests); ++i) {
         RefPtr<SecurityOrigin> origin1 = SecurityOrigin::createFromString(tests[i].origin1);
         RefPtr<SecurityOrigin> origin2 = SecurityOrigin::createFromString(tests[i].origin2);
         EXPECT_EQ(tests[i].canAccess, origin1->canAccess(origin2.get()));
         EXPECT_EQ(tests[i].canAccessCheckSuborigins, origin1->canAccessCheckSuborigins(origin2.get()));
     }
 }
 
 TEST_F(SecurityOriginTest, CanRequest)
 {
     RuntimeEnabledFeatures::setSuboriginsEnabled(true);
 
     struct TestCase {
         bool canRequest;
         bool canRequestNoSuborigin;
         const char* origin;
         const char* url;
     };
 
     TestCase tests[] = {
         { true, true, "https://foobar.com", "https://foobar.com" },
         { false, false, "https://foobar.com", "https://bazbar.com" },
-        { true, false, "https://name_foobar.com", "https://foobar.com" },
-        { false, false, "https://name_foobar.com", "https://bazbar.com" },
+        { true, false, "https-so://name.foobar.com", "https://foobar.com" },
+        { false, false, "https-so://name.foobar.com", "https://bazbar.com" },
     };
 
     for (size_t i = 0; i < WTF_ARRAY_LENGTH(tests); ++i) {
         RefPtr<SecurityOrigin> origin = SecurityOrigin::createFromString(tests[i].origin);
         blink::KURL url(blink::ParsedURLString, tests[i].url);
         EXPECT_EQ(tests[i].canRequest, origin->canRequest(url));
         EXPECT_EQ(tests[i].canRequestNoSuborigin, origin->canRequestNoSuborigin(url));
     }
 }
 
@@ skipping 79 matching lines @@
     RefPtr<SecurityOrigin> uniqueOrigin = SecurityOrigin::createUnique();
     RefPtr<SecurityOrigin> tupleOrigin = SecurityOrigin::createFromString("http://example.com");
 
     EXPECT_TRUE(uniqueOrigin->isSameSchemeHostPort(uniqueOrigin.get()));
     EXPECT_FALSE(SecurityOrigin::createUnique()->isSameSchemeHostPort(uniqueOrigin.get()));
     EXPECT_FALSE(tupleOrigin->isSameSchemeHostPort(uniqueOrigin.get()));
     EXPECT_FALSE(uniqueOrigin->isSameSchemeHostPort(tupleOrigin.get()));
 }
 
 } // namespace blink