Apply PSL to "first-party for cookies" ancestor restrictions.

Source/web/tests/WebDocumentTest.cpp

 // Copyright 2014 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 "config.h"
 
 #include "public/web/WebDocument.h"
 
 #include "core/CSSPropertyNames.h"
 #include "core/dom/NodeComputedStyle.h"
@@ skipping 190 matching lines @@
 
     frame->document().setIsTransitionDocument(true);
     ASSERT_TRUE(coreDoc->isTransitionDocument());
 
     frame->document().setIsTransitionDocument(false);
     ASSERT_FALSE(coreDoc->isTransitionDocument());
 }
 
 namespace {
     const char* baseURLOriginA = "http://example.test:0/";
+    const char* baseURLOriginSubA = "http://subdomain.example.test:0/";

[Ryan Sleevi, 2015/05/15 21:33:42]

An invalid origin, FWIW ;)

(:0 = oh noes)

     const char* baseURLOriginB = "http://not-example.test:0/";
     const char* emptyFile = "first_party/empty.html";
     const char* nestedData = "first_party/nested-data.html";
     const char* nestedOriginA = "first_party/nested-originA.html";
+    const char* nestedOriginSubA = "first_party/nested-originSubA.html";
     const char* nestedOriginAInOriginA = "first_party/nested-originA-in-originA.html";
     const char* nestedOriginAInOriginB = "first_party/nested-originA-in-originB.html";
     const char* nestedOriginB = "first_party/nested-originB.html";
     const char* nestedOriginBInOriginA = "first_party/nested-originB-in-originA.html";
     const char* nestedOriginBInOriginB = "first_party/nested-originB-in-originB.html";
     const char* nestedSrcDoc = "first_party/nested-srcdoc.html";
 
     static KURL toOriginA(const char* file)
     {
         return toKURL(std::string(baseURLOriginA) + file);
     }
 
+    static KURL toOriginSubA(const char* file)
+    {
+        return toKURL(std::string(baseURLOriginSubA) + file);
+    }
+
     static KURL toOriginB(const char* file)
     {
         return toKURL(std::string(baseURLOriginB) + file);
     }
 }
 
 class WebDocumentFirstPartyTest : public ::testing::Test {
 public:
     static void SetUpTestCase();
 
 protected:
     void load(const char*);
     Document* topDocument() const;
     Document* nestedDocument() const;
     Document* nestedNestedDocument() const;
 
     WebViewHelper m_webViewHelper;
 };
 
 void WebDocumentFirstPartyTest::SetUpTestCase()
 {
     URLTestHelpers::registerMockedURLLoad(toOriginA(emptyFile), WebString::fromUTF8(emptyFile));
     URLTestHelpers::registerMockedURLLoad(toOriginA(nestedData), WebString::fromUTF8(nestedData));
     URLTestHelpers::registerMockedURLLoad(toOriginA(nestedOriginA), WebString::fromUTF8(nestedOriginA));
+    URLTestHelpers::registerMockedURLLoad(toOriginA(nestedOriginSubA), WebString::fromUTF8(nestedOriginSubA));
     URLTestHelpers::registerMockedURLLoad(toOriginA(nestedOriginAInOriginA), WebString::fromUTF8(nestedOriginAInOriginA));
     URLTestHelpers::registerMockedURLLoad(toOriginA(nestedOriginAInOriginB), WebString::fromUTF8(nestedOriginAInOriginB));
     URLTestHelpers::registerMockedURLLoad(toOriginA(nestedOriginB), WebString::fromUTF8(nestedOriginB));
     URLTestHelpers::registerMockedURLLoad(toOriginA(nestedOriginBInOriginA), WebString::fromUTF8(nestedOriginBInOriginA));
     URLTestHelpers::registerMockedURLLoad(toOriginA(nestedOriginBInOriginB), WebString::fromUTF8(nestedOriginBInOriginB));
     URLTestHelpers::registerMockedURLLoad(toOriginA(nestedSrcDoc), WebString::fromUTF8(nestedSrcDoc));
 
+    URLTestHelpers::registerMockedURLLoad(toOriginSubA(emptyFile), WebString::fromUTF8(emptyFile));
+
     URLTestHelpers::registerMockedURLLoad(toOriginB(emptyFile), WebString::fromUTF8(emptyFile));
     URLTestHelpers::registerMockedURLLoad(toOriginB(nestedOriginA), WebString::fromUTF8(nestedOriginA));
     URLTestHelpers::registerMockedURLLoad(toOriginB(nestedOriginB), WebString::fromUTF8(nestedOriginB));
 }
 
 void WebDocumentFirstPartyTest::load(const char* file)
 {
     m_webViewHelper.initializeAndLoad(std::string(baseURLOriginA) + file);
 }
 
@@ skipping 29 matching lines @@
 
     RuntimeEnabledFeatures::setFirstPartyIncludesAncestorsEnabled(false);
     ASSERT_EQ(toOriginA(nestedOriginA), topDocument()->firstPartyForCookies());
     ASSERT_EQ(toOriginA(nestedOriginA), nestedDocument()->firstPartyForCookies());
 
     RuntimeEnabledFeatures::setFirstPartyIncludesAncestorsEnabled(true);
     ASSERT_EQ(toOriginA(nestedOriginA), topDocument()->firstPartyForCookies());
     ASSERT_EQ(toOriginA(nestedOriginA), nestedDocument()->firstPartyForCookies());
 }
 
+TEST_F(WebDocumentFirstPartyTest, NestedOriginSubA)
+{
+    load(nestedOriginSubA);
+
+    RuntimeEnabledFeatures::setFirstPartyIncludesAncestorsEnabled(false);
+    ASSERT_EQ(toOriginA(nestedOriginSubA), topDocument()->firstPartyForCookies());
+    ASSERT_EQ(toOriginA(nestedOriginSubA), nestedDocument()->firstPartyForCookies());
+
+    RuntimeEnabledFeatures::setFirstPartyIncludesAncestorsEnabled(true);
+    ASSERT_EQ(toOriginA(nestedOriginSubA), topDocument()->firstPartyForCookies());
+    ASSERT_EQ(toOriginA(nestedOriginSubA), nestedDocument()->firstPartyForCookies());
+}
+
 TEST_F(WebDocumentFirstPartyTest, NestedOriginAInOriginA)
 {
     load(nestedOriginAInOriginA);
 
     RuntimeEnabledFeatures::setFirstPartyIncludesAncestorsEnabled(false);
     ASSERT_EQ(toOriginA(nestedOriginAInOriginA), topDocument()->firstPartyForCookies());
     ASSERT_EQ(toOriginA(nestedOriginAInOriginA), nestedDocument()->firstPartyForCookies());
     ASSERT_EQ(toOriginA(nestedOriginAInOriginA), nestedNestedDocument()->firstPartyForCookies());
 
     RuntimeEnabledFeatures::setFirstPartyIncludesAncestorsEnabled(true);
@@ skipping 79 matching lines @@
 
     RuntimeEnabledFeatures::setFirstPartyIncludesAncestorsEnabled(false);
     ASSERT_EQ(toOriginA(nestedData), topDocument()->firstPartyForCookies());
     ASSERT_EQ(toOriginA(nestedData), nestedDocument()->firstPartyForCookies());
 
     RuntimeEnabledFeatures::setFirstPartyIncludesAncestorsEnabled(true);
     ASSERT_EQ(toOriginA(nestedData), topDocument()->firstPartyForCookies());
     ASSERT_EQ(SecurityOrigin::urlWithUniqueSecurityOrigin(), nestedDocument()->firstPartyForCookies());
 }
 }