Add 'OriginAccessEntry::matchDomain'.

third_party/WebKit/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 "public/web/WebDocument.h"
 
 #include "core/CSSPropertyNames.h"
 #include "core/HTMLNames.h"
 #include "core/dom/NodeComputedStyle.h"
 #include "core/dom/StyleEngine.h"
@@ skipping 121 matching lines @@
 
     // Crossorigin set to 'use-credentials' should trigger using credentials.
     linkManifest->setAttribute(HTMLNames::crossoriginAttr, "use-credentials");
     ASSERT_TRUE(webDoc.manifestUseCredentials());
 }
 
 namespace {
 
 const char* baseURLOriginA = "http://example.test:0/";
 const char* baseURLOriginSubA = "http://subdomain.example.test:0/";
+const char* baseURLOriginSecureA = "https://example.test:0/";
 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* nestedOriginSecureA = "first_party/nested-originSecureA.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";
 
 KURL toOriginA(const char* file)
 {
     return toKURL(std::string(baseURLOriginA) + file);
 }
 
 KURL toOriginSubA(const char* file)
 {
     return toKURL(std::string(baseURLOriginSubA) + file);
 }
 
+KURL toOriginSecureA(const char* file)
+{
+    return toKURL(std::string(baseURLOriginSecureA) + file);
+}
+
 KURL toOriginB(const char* file)
 {
     return toKURL(std::string(baseURLOriginB) + file);
 }
 
 } // anonymous namespace
 
 class WebDocumentFirstPartyTest : public WebDocumentTest {
 public:
     static void SetUpTestCase();
 
 protected:
     void load(const char*);
     Document* nestedDocument() const;
     Document* nestedNestedDocument() const;
 };
 
 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(nestedOriginSecureA), WebString::fromUTF8(nestedOriginSecureA));
     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(toOriginSecureA(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 24 matching lines @@
 }
 
 TEST_F(WebDocumentFirstPartyTest, NestedOriginSubA)
 {
     load(nestedOriginSubA);
 
     ASSERT_EQ(toOriginA(nestedOriginSubA), topDocument()->firstPartyForCookies());
     ASSERT_EQ(toOriginA(nestedOriginSubA), nestedDocument()->firstPartyForCookies());
 }
 
+TEST_F(WebDocumentFirstPartyTest, NestedOriginSecureA)
+{
+    load(nestedOriginSecureA);
+
+    ASSERT_EQ(toOriginA(nestedOriginSecureA), topDocument()->firstPartyForCookies());
+    ASSERT_EQ(toOriginA(nestedOriginSecureA), nestedDocument()->firstPartyForCookies());
+}
+
 TEST_F(WebDocumentFirstPartyTest, NestedOriginAInOriginA)
 {
     load(nestedOriginAInOriginA);
 
     ASSERT_EQ(toOriginA(nestedOriginAInOriginA), topDocument()->firstPartyForCookies());
     ASSERT_EQ(toOriginA(nestedOriginAInOriginA), nestedDocument()->firstPartyForCookies());
     ASSERT_EQ(toOriginA(nestedOriginAInOriginA), nestedNestedDocument()->firstPartyForCookies());
 }
 
 TEST_F(WebDocumentFirstPartyTest, NestedOriginAInOriginB)
@@ skipping 52 matching lines @@
     load(nestedOriginAInOriginB);
 
     SchemeRegistry::registerURLSchemeAsFirstPartyWhenTopLevel("http");
 
     ASSERT_EQ(toOriginA(nestedOriginAInOriginB), topDocument()->firstPartyForCookies());
     ASSERT_EQ(toOriginA(nestedOriginAInOriginB), nestedDocument()->firstPartyForCookies());
     ASSERT_EQ(toOriginA(nestedOriginAInOriginB), nestedNestedDocument()->firstPartyForCookies());
 }
 
 } // namespace blink