1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "third_party/blink/public/web/web_document.h"
6
7 #include <string>
8
9 #include "base/stl_util.h"
10 #include "testing/gtest/include/gtest/gtest.h"
11 #include "third_party/blink/public/common/origin_trials/origin_trial_policy.h"
12 #include "third_party/blink/public/common/origin_trials/trial_token_validator.h"
13 #include "third_party/blink/public/web/web_origin_trials.h"
14 #include "third_party/blink/renderer/core/css/css_property_names.h"
15 #include "third_party/blink/renderer/core/css/style_engine.h"
16 #include "third_party/blink/renderer/core/dom/node_computed_style.h"
17 #include "third_party/blink/renderer/core/frame/frame_test_helpers.h"
18 #include "third_party/blink/renderer/core/frame/local_frame.h"
19 #include "third_party/blink/renderer/core/frame/web_local_frame_impl.h"
20 #include "third_party/blink/renderer/core/html/html_element.h"
21 #include "third_party/blink/renderer/core/html/html_link_element.h"
22 #include "third_party/blink/renderer/core/html_names.h"
23 #include "third_party/blink/renderer/core/page/page.h"
24 #include "third_party/blink/renderer/core/style/computed_style.h"
25 #include "third_party/blink/renderer/platform/graphics/color.h"
26 #include "third_party/blink/renderer/platform/testing/unit_test_helpers.h"
27 #include "third_party/blink/renderer/platform/testing/url_test_helpers.h"
28 #include "third_party/blink/renderer/platform/weborigin/scheme_registry.h"
29 #include "third_party/blink/renderer/platform/weborigin/security_origin.h"
30 #include "third_party/blink/renderer/platform/wtf/functional.h"
31
32 namespace blink {
33
34 using blink::frame_test_helpers::WebViewHelper;
35 using blink::url_test_helpers::ToKURL;
36
37 const char kDefaultOrigin[] = "https://example.test/";
38 const char kOriginTrialDummyFilePath[] = "origin-trial-dummy.html";
39 const char kNoOriginTrialDummyFilePath[] = "simple_div.html";
40
41 class WebDocumentTest : public testing::Test {
42 protected:
43 static void SetUpTestCase();
44
45 void LoadURL(const std::string& url);
46 Document* TopDocument() const;
47 WebDocument TopWebDocument() const;
48
49 WebViewHelper web_view_helper_;
50 };
51
SetUpTestCase()52 void WebDocumentTest::SetUpTestCase() {
53 url_test_helpers::RegisterMockedURLLoad(
54 ToKURL(std::string(kDefaultOrigin) + kNoOriginTrialDummyFilePath),
55 test::CoreTestDataPath(kNoOriginTrialDummyFilePath));
56 url_test_helpers::RegisterMockedURLLoad(
57 ToKURL(std::string(kDefaultOrigin) + kOriginTrialDummyFilePath),
58 test::CoreTestDataPath(kOriginTrialDummyFilePath));
59 }
60
LoadURL(const std::string & url)61 void WebDocumentTest::LoadURL(const std::string& url) {
62 web_view_helper_.InitializeAndLoad(url);
63 }
64
TopDocument() const65 Document* WebDocumentTest::TopDocument() const {
66 return To<LocalFrame>(web_view_helper_.GetWebView()->GetPage()->MainFrame())
67 ->GetDocument();
68 }
69
TopWebDocument() const70 WebDocument WebDocumentTest::TopWebDocument() const {
71 return web_view_helper_.LocalMainFrame()->GetDocument();
72 }
73
TEST_F(WebDocumentTest,InsertAndRemoveStyleSheet)74 TEST_F(WebDocumentTest, InsertAndRemoveStyleSheet) {
75 LoadURL("about:blank");
76
77 WebDocument web_doc = TopWebDocument();
78 Document* core_doc = TopDocument();
79
80 unsigned start_count = core_doc->GetStyleEngine().StyleForElementCount();
81
82 WebStyleSheetKey style_sheet_key =
83 web_doc.InsertStyleSheet("body { color: green }");
84
85 // Check insertStyleSheet did not cause a synchronous style recalc.
86 unsigned element_count =
87 core_doc->GetStyleEngine().StyleForElementCount() - start_count;
88 ASSERT_EQ(0U, element_count);
89
90 HTMLElement* body_element = core_doc->body();
91 DCHECK(body_element);
92
93 const ComputedStyle& style_before_insertion =
94 body_element->ComputedStyleRef();
95
96 // Inserted style sheet not yet applied.
97 ASSERT_EQ(Color(0, 0, 0), style_before_insertion.VisitedDependentColor(
98 GetCSSPropertyColor()));
99
100 // Apply inserted style sheet.
101 core_doc->UpdateStyleAndLayoutTree();
102
103 const ComputedStyle& style_after_insertion = body_element->ComputedStyleRef();
104
105 // Inserted style sheet applied.
106 ASSERT_EQ(Color(0, 128, 0),
107 style_after_insertion.VisitedDependentColor(GetCSSPropertyColor()));
108
109 start_count = core_doc->GetStyleEngine().StyleForElementCount();
110
111 // Check RemoveInsertedStyleSheet did not cause a synchronous style recalc.
112 web_doc.RemoveInsertedStyleSheet(style_sheet_key);
113 element_count =
114 core_doc->GetStyleEngine().StyleForElementCount() - start_count;
115 ASSERT_EQ(0U, element_count);
116
117 const ComputedStyle& style_before_removing = body_element->ComputedStyleRef();
118
119 // Removed style sheet not yet applied.
120 ASSERT_EQ(Color(0, 128, 0),
121 style_before_removing.VisitedDependentColor(GetCSSPropertyColor()));
122
123 // Apply removed style sheet.
124 core_doc->UpdateStyleAndLayoutTree();
125
126 const ComputedStyle& style_after_removing = body_element->ComputedStyleRef();
127 ASSERT_EQ(Color(0, 0, 0),
128 style_after_removing.VisitedDependentColor(GetCSSPropertyColor()));
129 }
130
131 namespace {
132
133 // This is the public key which the test below will use to enable origin
134 // trial features. Trial tokens for use in tests can be created with the
135 // tool in /tools/origin_trials/generate_token.py, using the private key
136 // contained in /tools/origin_trials/eftest.key.
137 static const uint8_t kOriginTrialPublicKey[] = {
138 0x75, 0x10, 0xac, 0xf9, 0x3a, 0x1c, 0xb8, 0xa9, 0x28, 0x70, 0xd2,
139 0x9a, 0xd0, 0x0b, 0x59, 0xe1, 0xac, 0x2b, 0xb7, 0xd5, 0xca, 0x1f,
140 0x64, 0x90, 0x08, 0x8e, 0xa8, 0xe0, 0x56, 0x3a, 0x04, 0xd0,
141 };
142
143 } // anonymous namespace
144
145 // Origin Trial Policy which vends the test public key so that the token
146 // can be validated.
147 class TestOriginTrialPolicy : public blink::OriginTrialPolicy {
148 public:
TestOriginTrialPolicy()149 TestOriginTrialPolicy() {
150 public_keys_.push_back(base::StringPiece(
151 reinterpret_cast<const char*>(kOriginTrialPublicKey),
152 base::size(kOriginTrialPublicKey)));
153 }
IsOriginTrialsSupported() const154 bool IsOriginTrialsSupported() const override { return true; }
GetPublicKeys() const155 std::vector<base::StringPiece> GetPublicKeys() const override {
156 return public_keys_;
157 }
IsOriginSecure(const GURL & url) const158 bool IsOriginSecure(const GURL& url) const override { return true; }
159
160 private:
161 std::vector<base::StringPiece> public_keys_;
162 };
163
TEST_F(WebDocumentTest,OriginTrialDisabled)164 TEST_F(WebDocumentTest, OriginTrialDisabled) {
165 // Set an origin trial policy.
166 TestOriginTrialPolicy policy;
167 blink::TrialTokenValidator::SetOriginTrialPolicyGetter(WTF::BindRepeating(
168 [](TestOriginTrialPolicy* policy_ptr) -> blink::OriginTrialPolicy* {
169 return policy_ptr;
170 },
171 base::Unretained(&policy)));
172
173 // Load a document with no origin trial token.
174 LoadURL(std::string(kDefaultOrigin) + kNoOriginTrialDummyFilePath);
175 WebDocument web_doc = TopWebDocument();
176 EXPECT_FALSE(WebOriginTrials::isTrialEnabled(&web_doc, "Frobulate"));
177 // Reset the origin trial policy.
178 TrialTokenValidator::ResetOriginTrialPolicyGetter();
179 }
180
TEST_F(WebDocumentTest,OriginTrialEnabled)181 TEST_F(WebDocumentTest, OriginTrialEnabled) {
182 // Set an origin trial policy.
183 TestOriginTrialPolicy policy;
184 blink::TrialTokenValidator::SetOriginTrialPolicyGetter(WTF::BindRepeating(
185 [](TestOriginTrialPolicy* policy_ptr) -> blink::OriginTrialPolicy* {
186 return policy_ptr;
187 },
188 base::Unretained(&policy)));
189
190 // Load a document with a valid origin trial token for the test trial.
191 LoadURL(std::string(kDefaultOrigin) + kOriginTrialDummyFilePath);
192 WebDocument web_doc = TopWebDocument();
193 EXPECT_TRUE(WebOriginTrials::isTrialEnabled(&web_doc, "Frobulate"));
194 // Ensure that other trials are not also enabled
195 EXPECT_FALSE(WebOriginTrials::isTrialEnabled(&web_doc, "NotATrial"));
196 // Reset the origin trial policy.
197 TrialTokenValidator::ResetOriginTrialPolicyGetter();
198 }
199
200 namespace {
201
202 const char* g_base_url_origin_a = "http://example.test:0/";
203 const char* g_base_url_origin_sub_a = "http://subdomain.example.test:0/";
204 const char* g_base_url_origin_secure_a = "https://example.test:0/";
205 const char* g_base_url_sandbox_origin_a = "http://sandbox.example.test:0/";
206 const char* g_base_url_origin_b = "http://not-example.test:0/";
207 const char* g_empty_file = "first_party/empty.html";
208 const char* g_nested_data = "first_party/nested-data.html";
209 const char* g_nested_origin_a = "first_party/nested-originA.html";
210 const char* g_nested_origin_sub_a = "first_party/nested-originSubA.html";
211 const char* g_nested_origin_secure_a = "first_party/nested-originSecureA.html";
212 const char* g_nested_origin_a_in_origin_a =
213 "first_party/nested-originA-in-originA.html";
214 const char* g_nested_origin_a_in_origin_b =
215 "first_party/nested-originA-in-originB.html";
216 const char* g_nested_origin_b = "first_party/nested-originB.html";
217 const char* g_nested_origin_b_in_origin_a =
218 "first_party/nested-originB-in-originA.html";
219 const char* g_nested_origin_b_in_origin_b =
220 "first_party/nested-originB-in-originB.html";
221 const char* g_nested_src_doc = "first_party/nested-srcdoc.html";
222
ToFile(const char * file)223 KURL ToFile(const char* file) {
224 return ToKURL(std::string("file:///") + file);
225 }
226
ToOriginA(const char * file)227 KURL ToOriginA(const char* file) {
228 return ToKURL(std::string(g_base_url_origin_a) + file);
229 }
230
ToOriginSubA(const char * file)231 KURL ToOriginSubA(const char* file) {
232 return ToKURL(std::string(g_base_url_origin_sub_a) + file);
233 }
234
ToOriginSecureA(const char * file)235 KURL ToOriginSecureA(const char* file) {
236 return ToKURL(std::string(g_base_url_origin_secure_a) + file);
237 }
238
ToOriginSandboxA(const char * file)239 KURL ToOriginSandboxA(const char* file) {
240 return ToKURL(std::string(g_base_url_sandbox_origin_a) + file);
241 }
242
ToOriginB(const char * file)243 KURL ToOriginB(const char* file) {
244 return ToKURL(std::string(g_base_url_origin_b) + file);
245 }
246
RegisterMockedURLLoad(const KURL & url,const char * path)247 void RegisterMockedURLLoad(const KURL& url, const char* path) {
248 url_test_helpers::RegisterMockedURLLoad(url, test::CoreTestDataPath(path));
249 }
250
251 } // anonymous namespace
252
253 class WebDocumentFirstPartyTest : public WebDocumentTest {
254 public:
255 static void SetUpTestCase();
256
257 protected:
258 void Load(const char*);
259 Document* NestedDocument() const;
260 Document* NestedNestedDocument() const;
261 };
262
SetUpTestCase()263 void WebDocumentFirstPartyTest::SetUpTestCase() {
264 RegisterMockedURLLoad(ToOriginA(g_empty_file), g_empty_file);
265 RegisterMockedURLLoad(ToOriginA(g_nested_data), g_nested_data);
266 RegisterMockedURLLoad(ToOriginA(g_nested_origin_a), g_nested_origin_a);
267 RegisterMockedURLLoad(ToOriginA(g_nested_origin_sub_a),
268 g_nested_origin_sub_a);
269 RegisterMockedURLLoad(ToOriginA(g_nested_origin_secure_a),
270 g_nested_origin_secure_a);
271 RegisterMockedURLLoad(ToOriginA(g_nested_origin_a_in_origin_a),
272 g_nested_origin_a_in_origin_a);
273 RegisterMockedURLLoad(ToOriginA(g_nested_origin_a_in_origin_b),
274 g_nested_origin_a_in_origin_b);
275 RegisterMockedURLLoad(ToOriginA(g_nested_origin_b), g_nested_origin_b);
276 RegisterMockedURLLoad(ToOriginA(g_nested_origin_b_in_origin_a),
277 g_nested_origin_b_in_origin_a);
278 RegisterMockedURLLoad(ToOriginA(g_nested_origin_b_in_origin_b),
279 g_nested_origin_b_in_origin_b);
280 RegisterMockedURLLoad(ToOriginA(g_nested_src_doc), g_nested_src_doc);
281
282 RegisterMockedURLLoad(ToOriginSubA(g_empty_file), g_empty_file);
283 RegisterMockedURLLoad(ToOriginSecureA(g_empty_file), g_empty_file);
284
285 WebURLResponse response(ToOriginSandboxA(g_empty_file));
286 response.SetMimeType(WebString::FromUTF8("text/html"));
287 response.SetHttpHeaderField(http_names::kContentType,
288 WebString::FromUTF8("text/html"));
289 response.SetHttpHeaderField(http_names::kContentSecurityPolicy,
290 WebString::FromUTF8("sandbox"));
291 response.SetHttpStatusCode(200);
292 url_test_helpers::RegisterMockedURLLoadWithCustomResponse(
293 ToOriginSandboxA(g_empty_file), test::CoreTestDataPath(g_empty_file),
294 response);
295
296 RegisterMockedURLLoad(ToOriginB(g_empty_file), g_empty_file);
297 RegisterMockedURLLoad(ToOriginB(g_nested_origin_a), g_nested_origin_a);
298 RegisterMockedURLLoad(ToOriginB(g_nested_origin_b), g_nested_origin_b);
299
300 RegisterMockedURLLoad(ToFile(g_nested_origin_a), g_nested_origin_a);
301 }
302
Load(const char * file)303 void WebDocumentFirstPartyTest::Load(const char* file) {
304 web_view_helper_.InitializeAndLoad(std::string(g_base_url_origin_a) + file);
305 }
306
NestedDocument() const307 Document* WebDocumentFirstPartyTest::NestedDocument() const {
308 return To<LocalFrame>(web_view_helper_.GetWebView()
309 ->GetPage()
310 ->MainFrame()
311 ->Tree()
312 .FirstChild())
313 ->GetDocument();
314 }
315
NestedNestedDocument() const316 Document* WebDocumentFirstPartyTest::NestedNestedDocument() const {
317 return To<LocalFrame>(web_view_helper_.GetWebView()
318 ->GetPage()
319 ->MainFrame()
320 ->Tree()
321 .FirstChild()
322 ->Tree()
323 .FirstChild())
324 ->GetDocument();
325 }
326
OriginsEqual(const char * path,scoped_refptr<const SecurityOrigin> origin)327 bool OriginsEqual(const char* path,
328 scoped_refptr<const SecurityOrigin> origin) {
329 return SecurityOrigin::Create(ToOriginA(path))
330 ->IsSameOriginWith(origin.get());
331 }
332
SiteForCookiesEqual(const char * path,const net::SiteForCookies & site_for_cookies)333 bool SiteForCookiesEqual(const char* path,
334 const net::SiteForCookies& site_for_cookies) {
335 KURL ref_url = ToOriginA(path);
336 ref_url.SetPort(80); // url::Origin takes exception with :0.
337 return net::SiteForCookies::FromUrl(ref_url).IsEquivalent(site_for_cookies);
338 }
339
TEST_F(WebDocumentFirstPartyTest,Empty)340 TEST_F(WebDocumentFirstPartyTest, Empty) {
341 Load(g_empty_file);
342
343 ASSERT_TRUE(
344 SiteForCookiesEqual(g_empty_file, TopDocument()->SiteForCookies()));
345 ASSERT_TRUE(OriginsEqual(g_empty_file, TopDocument()->TopFrameOrigin()));
346 }
347
TEST_F(WebDocumentFirstPartyTest,EmptySandbox)348 TEST_F(WebDocumentFirstPartyTest, EmptySandbox) {
349 web_view_helper_.InitializeAndLoad(std::string(g_base_url_sandbox_origin_a) +
350 g_empty_file);
351
352 ASSERT_TRUE(TopDocument()->TopFrameOrigin()->IsOpaque())
353 << TopDocument()->TopFrameOrigin()->ToUrlOrigin().GetDebugString();
354 ASSERT_TRUE(TopDocument()->SiteForCookies().IsNull());
355 }
356
TEST_F(WebDocumentFirstPartyTest,NestedOriginA)357 TEST_F(WebDocumentFirstPartyTest, NestedOriginA) {
358 Load(g_nested_origin_a);
359
360 ASSERT_TRUE(
361 SiteForCookiesEqual(g_nested_origin_a, TopDocument()->SiteForCookies()));
362 ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_a,
363 NestedDocument()->SiteForCookies()));
364
365 ASSERT_TRUE(OriginsEqual(g_nested_origin_a, TopDocument()->TopFrameOrigin()));
366 ASSERT_TRUE(
367 OriginsEqual(g_nested_origin_a, NestedDocument()->TopFrameOrigin()));
368 }
369
TEST_F(WebDocumentFirstPartyTest,NestedOriginASchemefulSiteForCookies)370 TEST_F(WebDocumentFirstPartyTest, NestedOriginASchemefulSiteForCookies) {
371 Load(g_nested_origin_a);
372
373 // TopDocument is same scheme with itself so expect true.
374 ASSERT_TRUE(TopDocument()->SiteForCookies().schemefully_same());
375 // NestedDocument is same scheme with TopDocument so expect true.
376 ASSERT_TRUE(NestedDocument()->SiteForCookies().schemefully_same());
377 }
378
TEST_F(WebDocumentFirstPartyTest,NestedOriginSubA)379 TEST_F(WebDocumentFirstPartyTest, NestedOriginSubA) {
380 Load(g_nested_origin_sub_a);
381
382 ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_sub_a,
383 TopDocument()->SiteForCookies()));
384 ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_sub_a,
385 NestedDocument()->SiteForCookies()));
386
387 ASSERT_TRUE(
388 OriginsEqual(g_nested_origin_sub_a, TopDocument()->TopFrameOrigin()));
389 ASSERT_TRUE(
390 OriginsEqual(g_nested_origin_sub_a, NestedDocument()->TopFrameOrigin()));
391 }
392
TEST_F(WebDocumentFirstPartyTest,NestedOriginSecureA)393 TEST_F(WebDocumentFirstPartyTest, NestedOriginSecureA) {
394 Load(g_nested_origin_secure_a);
395
396 ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_secure_a,
397 TopDocument()->SiteForCookies()));
398 ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_secure_a,
399 NestedDocument()->SiteForCookies()));
400
401 ASSERT_TRUE(
402 OriginsEqual(g_nested_origin_secure_a, TopDocument()->TopFrameOrigin()));
403 ASSERT_TRUE(OriginsEqual(g_nested_origin_secure_a,
404 NestedDocument()->TopFrameOrigin()));
405 }
406
TEST_F(WebDocumentFirstPartyTest,NestedOriginSecureASchemefulSiteForCookies)407 TEST_F(WebDocumentFirstPartyTest, NestedOriginSecureASchemefulSiteForCookies) {
408 Load(g_nested_origin_secure_a);
409
410 // TopDocument is same scheme with itself so expect true.
411 ASSERT_TRUE(TopDocument()->SiteForCookies().schemefully_same());
412
413 // Since NestedDocument is secure, and the parent is insecure, the scheme will
414 // differ.
415 ASSERT_FALSE(NestedDocument()->SiteForCookies().schemefully_same());
416 }
417
TEST_F(WebDocumentFirstPartyTest,NestedOriginAInOriginA)418 TEST_F(WebDocumentFirstPartyTest, NestedOriginAInOriginA) {
419 Load(g_nested_origin_a_in_origin_a);
420
421 ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_a_in_origin_a,
422 TopDocument()->SiteForCookies()));
423 ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_a_in_origin_a,
424 NestedDocument()->SiteForCookies()));
425 ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_a_in_origin_a,
426 NestedNestedDocument()->SiteForCookies()));
427
428 ASSERT_TRUE(OriginsEqual(g_nested_origin_a_in_origin_a,
429 TopDocument()->TopFrameOrigin()));
430 ASSERT_TRUE(OriginsEqual(g_nested_origin_a_in_origin_a,
431 NestedDocument()->TopFrameOrigin()));
432 }
433
TEST_F(WebDocumentFirstPartyTest,NestedOriginAInOriginB)434 TEST_F(WebDocumentFirstPartyTest, NestedOriginAInOriginB) {
435 Load(g_nested_origin_a_in_origin_b);
436
437 ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_a_in_origin_b,
438 TopDocument()->SiteForCookies()));
439 ASSERT_TRUE(NestedDocument()->SiteForCookies().IsNull());
440 ASSERT_TRUE(NestedNestedDocument()->SiteForCookies().IsNull());
441
442 ASSERT_TRUE(OriginsEqual(g_nested_origin_a_in_origin_b,
443 TopDocument()->TopFrameOrigin()));
444 ASSERT_TRUE(OriginsEqual(g_nested_origin_a_in_origin_b,
445 NestedDocument()->TopFrameOrigin()));
446 ASSERT_TRUE(OriginsEqual(g_nested_origin_a_in_origin_b,
447 NestedNestedDocument()->TopFrameOrigin()));
448 }
449
TEST_F(WebDocumentFirstPartyTest,NestedOriginB)450 TEST_F(WebDocumentFirstPartyTest, NestedOriginB) {
451 Load(g_nested_origin_b);
452
453 ASSERT_TRUE(
454 SiteForCookiesEqual(g_nested_origin_b, TopDocument()->SiteForCookies()));
455 ASSERT_TRUE(NestedDocument()->SiteForCookies().IsNull());
456
457 ASSERT_TRUE(OriginsEqual(g_nested_origin_b, TopDocument()->TopFrameOrigin()));
458 ASSERT_TRUE(
459 OriginsEqual(g_nested_origin_b, NestedDocument()->TopFrameOrigin()));
460 }
461
TEST_F(WebDocumentFirstPartyTest,NestedOriginBInOriginA)462 TEST_F(WebDocumentFirstPartyTest, NestedOriginBInOriginA) {
463 Load(g_nested_origin_b_in_origin_a);
464
465 ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_b_in_origin_a,
466 TopDocument()->SiteForCookies()));
467 ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_b_in_origin_a,
468 NestedDocument()->SiteForCookies()));
469 ASSERT_TRUE(NestedNestedDocument()->SiteForCookies().IsNull());
470
471 ASSERT_TRUE(OriginsEqual(g_nested_origin_b_in_origin_a,
472 TopDocument()->TopFrameOrigin()));
473 ASSERT_TRUE(OriginsEqual(g_nested_origin_b_in_origin_a,
474 NestedDocument()->TopFrameOrigin()));
475 ASSERT_TRUE(OriginsEqual(g_nested_origin_b_in_origin_a,
476 NestedNestedDocument()->TopFrameOrigin()));
477 }
478
TEST_F(WebDocumentFirstPartyTest,NestedOriginBInOriginB)479 TEST_F(WebDocumentFirstPartyTest, NestedOriginBInOriginB) {
480 Load(g_nested_origin_b_in_origin_b);
481
482 ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_b_in_origin_b,
483 TopDocument()->SiteForCookies()));
484 ASSERT_TRUE(NestedDocument()->SiteForCookies().IsNull());
485 ASSERT_TRUE(NestedNestedDocument()->SiteForCookies().IsNull());
486
487 ASSERT_TRUE(OriginsEqual(g_nested_origin_b_in_origin_b,
488 TopDocument()->TopFrameOrigin()));
489 ASSERT_TRUE(OriginsEqual(g_nested_origin_b_in_origin_b,
490 NestedDocument()->TopFrameOrigin()));
491 ASSERT_TRUE(OriginsEqual(g_nested_origin_b_in_origin_b,
492 NestedNestedDocument()->TopFrameOrigin()));
493 }
494
TEST_F(WebDocumentFirstPartyTest,NestedSrcdoc)495 TEST_F(WebDocumentFirstPartyTest, NestedSrcdoc) {
496 Load(g_nested_src_doc);
497
498 ASSERT_TRUE(
499 SiteForCookiesEqual(g_nested_src_doc, TopDocument()->SiteForCookies()));
500 ASSERT_TRUE(SiteForCookiesEqual(g_nested_src_doc,
501 NestedDocument()->SiteForCookies()));
502
503 ASSERT_TRUE(OriginsEqual(g_nested_src_doc, TopDocument()->TopFrameOrigin()));
504 ASSERT_TRUE(
505 OriginsEqual(g_nested_src_doc, NestedDocument()->TopFrameOrigin()));
506 }
507
TEST_F(WebDocumentFirstPartyTest,NestedData)508 TEST_F(WebDocumentFirstPartyTest, NestedData) {
509 Load(g_nested_data);
510
511 ASSERT_TRUE(
512 SiteForCookiesEqual(g_nested_data, TopDocument()->SiteForCookies()));
513 ASSERT_TRUE(NestedDocument()->SiteForCookies().IsNull());
514
515 ASSERT_TRUE(OriginsEqual(g_nested_data, TopDocument()->TopFrameOrigin()));
516 ASSERT_TRUE(OriginsEqual(g_nested_data, NestedDocument()->TopFrameOrigin()));
517 }
518
TEST_F(WebDocumentFirstPartyTest,NestedOriginAInOriginBWithFirstPartyOverride)519 TEST_F(WebDocumentFirstPartyTest,
520 NestedOriginAInOriginBWithFirstPartyOverride) {
521 Load(g_nested_origin_a_in_origin_b);
522
523 SchemeRegistry::RegisterURLSchemeAsFirstPartyWhenTopLevel("http");
524
525 ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_a_in_origin_b,
526 TopDocument()->SiteForCookies()));
527 ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_a_in_origin_b,
528 NestedDocument()->SiteForCookies()));
529 ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_a_in_origin_b,
530 NestedNestedDocument()->SiteForCookies()));
531
532 ASSERT_TRUE(OriginsEqual(g_nested_origin_a_in_origin_b,
533 TopDocument()->TopFrameOrigin()));
534 ASSERT_TRUE(OriginsEqual(g_nested_origin_a_in_origin_b,
535 NestedDocument()->TopFrameOrigin()));
536 ASSERT_TRUE(OriginsEqual(g_nested_origin_a_in_origin_b,
537 NestedNestedDocument()->TopFrameOrigin()));
538 }
539
TEST_F(WebDocumentFirstPartyTest,FileScheme)540 TEST_F(WebDocumentFirstPartyTest, FileScheme) {
541 web_view_helper_.InitializeAndLoad(std::string("file:///") +
542 g_nested_origin_a);
543
544 net::SiteForCookies top_site_for_cookies = TopDocument()->SiteForCookies();
545 EXPECT_EQ("file", top_site_for_cookies.scheme());
546 EXPECT_EQ("", top_site_for_cookies.registrable_domain());
547
548 // Nested a.com is 3rd-party to file://
549 EXPECT_TRUE(NestedDocument()->SiteForCookies().IsNull());
550 }
551
552 } // namespace blink
553