// 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 "third_party/blink/public/web/web_document.h"

#include <string>

#include "base/stl_util.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/blink/public/common/origin_trials/origin_trial_policy.h"
#include "third_party/blink/public/common/origin_trials/trial_token_validator.h"
#include "third_party/blink/public/web/web_origin_trials.h"
#include "third_party/blink/renderer/core/css/css_property_names.h"
#include "third_party/blink/renderer/core/css/style_engine.h"
#include "third_party/blink/renderer/core/dom/node_computed_style.h"
#include "third_party/blink/renderer/core/frame/frame_test_helpers.h"
#include "third_party/blink/renderer/core/frame/local_frame.h"
#include "third_party/blink/renderer/core/frame/web_local_frame_impl.h"
#include "third_party/blink/renderer/core/html/html_element.h"
#include "third_party/blink/renderer/core/html/html_link_element.h"
#include "third_party/blink/renderer/core/html_names.h"
#include "third_party/blink/renderer/core/page/page.h"
#include "third_party/blink/renderer/core/style/computed_style.h"
#include "third_party/blink/renderer/platform/graphics/color.h"
#include "third_party/blink/renderer/platform/testing/unit_test_helpers.h"
#include "third_party/blink/renderer/platform/testing/url_test_helpers.h"
#include "third_party/blink/renderer/platform/weborigin/scheme_registry.h"
#include "third_party/blink/renderer/platform/weborigin/security_origin.h"
#include "third_party/blink/renderer/platform/wtf/functional.h"

namespace blink {

using blink::frame_test_helpers::WebViewHelper;
using blink::url_test_helpers::ToKURL;

const char kDefaultOrigin[] = "https://example.test/";
const char kOriginTrialDummyFilePath[] = "origin-trial-dummy.html";
const char kNoOriginTrialDummyFilePath[] = "simple_div.html";

class WebDocumentTest : public testing::Test {
 protected:
  static void SetUpTestCase();

  void LoadURL(const std::string& url);
  Document* TopDocument() const;
  WebDocument TopWebDocument() const;

  WebViewHelper web_view_helper_;
};

void WebDocumentTest::SetUpTestCase() {
  url_test_helpers::RegisterMockedURLLoad(
      ToKURL(std::string(kDefaultOrigin) + kNoOriginTrialDummyFilePath),
      test::CoreTestDataPath(kNoOriginTrialDummyFilePath));
  url_test_helpers::RegisterMockedURLLoad(
      ToKURL(std::string(kDefaultOrigin) + kOriginTrialDummyFilePath),
      test::CoreTestDataPath(kOriginTrialDummyFilePath));
}

void WebDocumentTest::LoadURL(const std::string& url) {
  web_view_helper_.InitializeAndLoad(url);
}

Document* WebDocumentTest::TopDocument() const {
  return To<LocalFrame>(web_view_helper_.GetWebView()->GetPage()->MainFrame())
      ->GetDocument();
}

WebDocument WebDocumentTest::TopWebDocument() const {
  return web_view_helper_.LocalMainFrame()->GetDocument();
}

TEST_F(WebDocumentTest, InsertAndRemoveStyleSheet) {
  LoadURL("about:blank");

  WebDocument web_doc = TopWebDocument();
  Document* core_doc = TopDocument();

  unsigned start_count = core_doc->GetStyleEngine().StyleForElementCount();

  WebStyleSheetKey style_sheet_key =
      web_doc.InsertStyleSheet("body { color: green }");

  // Check insertStyleSheet did not cause a synchronous style recalc.
  unsigned element_count =
      core_doc->GetStyleEngine().StyleForElementCount() - start_count;
  ASSERT_EQ(0U, element_count);

  HTMLElement* body_element = core_doc->body();
  DCHECK(body_element);

  const ComputedStyle& style_before_insertion =
      body_element->ComputedStyleRef();

  // Inserted style sheet not yet applied.
  ASSERT_EQ(Color(0, 0, 0), style_before_insertion.VisitedDependentColor(
                                GetCSSPropertyColor()));

  // Apply inserted style sheet.
  core_doc->UpdateStyleAndLayoutTree();

  const ComputedStyle& style_after_insertion = body_element->ComputedStyleRef();

  // Inserted style sheet applied.
  ASSERT_EQ(Color(0, 128, 0),
            style_after_insertion.VisitedDependentColor(GetCSSPropertyColor()));

  start_count = core_doc->GetStyleEngine().StyleForElementCount();

  // Check RemoveInsertedStyleSheet did not cause a synchronous style recalc.
  web_doc.RemoveInsertedStyleSheet(style_sheet_key);
  element_count =
      core_doc->GetStyleEngine().StyleForElementCount() - start_count;
  ASSERT_EQ(0U, element_count);

  const ComputedStyle& style_before_removing = body_element->ComputedStyleRef();

  // Removed style sheet not yet applied.
  ASSERT_EQ(Color(0, 128, 0),
            style_before_removing.VisitedDependentColor(GetCSSPropertyColor()));

  // Apply removed style sheet.
  core_doc->UpdateStyleAndLayoutTree();

  const ComputedStyle& style_after_removing = body_element->ComputedStyleRef();
  ASSERT_EQ(Color(0, 0, 0),
            style_after_removing.VisitedDependentColor(GetCSSPropertyColor()));
}

namespace {

// This is the public key which the test below will use to enable origin
// trial features. Trial tokens for use in tests can be created with the
// tool in /tools/origin_trials/generate_token.py, using the private key
// contained in /tools/origin_trials/eftest.key.
static const uint8_t kOriginTrialPublicKey[] = {
    0x75, 0x10, 0xac, 0xf9, 0x3a, 0x1c, 0xb8, 0xa9, 0x28, 0x70, 0xd2,
    0x9a, 0xd0, 0x0b, 0x59, 0xe1, 0xac, 0x2b, 0xb7, 0xd5, 0xca, 0x1f,
    0x64, 0x90, 0x08, 0x8e, 0xa8, 0xe0, 0x56, 0x3a, 0x04, 0xd0,
};

}  // anonymous namespace

// Origin Trial Policy which vends the test public key so that the token
// can be validated.
class TestOriginTrialPolicy : public blink::OriginTrialPolicy {
 public:
  TestOriginTrialPolicy() {
    public_keys_.push_back(base::StringPiece(
        reinterpret_cast<const char*>(kOriginTrialPublicKey),
        base::size(kOriginTrialPublicKey)));
  }
  bool IsOriginTrialsSupported() const override { return true; }
  std::vector<base::StringPiece> GetPublicKeys() const override {
    return public_keys_;
  }
  bool IsOriginSecure(const GURL& url) const override { return true; }

 private:
  std::vector<base::StringPiece> public_keys_;
};

TEST_F(WebDocumentTest, OriginTrialDisabled) {
  // Set an origin trial policy.
  TestOriginTrialPolicy policy;
  blink::TrialTokenValidator::SetOriginTrialPolicyGetter(WTF::BindRepeating(
      [](TestOriginTrialPolicy* policy_ptr) -> blink::OriginTrialPolicy* {
        return policy_ptr;
      },
      base::Unretained(&policy)));

  // Load a document with no origin trial token.
  LoadURL(std::string(kDefaultOrigin) + kNoOriginTrialDummyFilePath);
  WebDocument web_doc = TopWebDocument();
  EXPECT_FALSE(WebOriginTrials::isTrialEnabled(&web_doc, "Frobulate"));
  // Reset the origin trial policy.
  TrialTokenValidator::ResetOriginTrialPolicyGetter();
}

TEST_F(WebDocumentTest, OriginTrialEnabled) {
  // Set an origin trial policy.
  TestOriginTrialPolicy policy;
  blink::TrialTokenValidator::SetOriginTrialPolicyGetter(WTF::BindRepeating(
      [](TestOriginTrialPolicy* policy_ptr) -> blink::OriginTrialPolicy* {
        return policy_ptr;
      },
      base::Unretained(&policy)));

  // Load a document with a valid origin trial token for the test trial.
  LoadURL(std::string(kDefaultOrigin) + kOriginTrialDummyFilePath);
  WebDocument web_doc = TopWebDocument();
  EXPECT_TRUE(WebOriginTrials::isTrialEnabled(&web_doc, "Frobulate"));
  // Ensure that other trials are not also enabled
  EXPECT_FALSE(WebOriginTrials::isTrialEnabled(&web_doc, "NotATrial"));
  // Reset the origin trial policy.
  TrialTokenValidator::ResetOriginTrialPolicyGetter();
}

namespace {

const char* g_base_url_origin_a = "http://example.test:0/";
const char* g_base_url_origin_sub_a = "http://subdomain.example.test:0/";
const char* g_base_url_origin_secure_a = "https://example.test:0/";
const char* g_base_url_sandbox_origin_a = "http://sandbox.example.test:0/";
const char* g_base_url_origin_b = "http://not-example.test:0/";
const char* g_empty_file = "first_party/empty.html";
const char* g_nested_data = "first_party/nested-data.html";
const char* g_nested_origin_a = "first_party/nested-originA.html";
const char* g_nested_origin_sub_a = "first_party/nested-originSubA.html";
const char* g_nested_origin_secure_a = "first_party/nested-originSecureA.html";
const char* g_nested_origin_a_in_origin_a =
    "first_party/nested-originA-in-originA.html";
const char* g_nested_origin_a_in_origin_b =
    "first_party/nested-originA-in-originB.html";
const char* g_nested_origin_b = "first_party/nested-originB.html";
const char* g_nested_origin_b_in_origin_a =
    "first_party/nested-originB-in-originA.html";
const char* g_nested_origin_b_in_origin_b =
    "first_party/nested-originB-in-originB.html";
const char* g_nested_src_doc = "first_party/nested-srcdoc.html";

KURL ToFile(const char* file) {
  return ToKURL(std::string("file:///") + file);
}

KURL ToOriginA(const char* file) {
  return ToKURL(std::string(g_base_url_origin_a) + file);
}

KURL ToOriginSubA(const char* file) {
  return ToKURL(std::string(g_base_url_origin_sub_a) + file);
}

KURL ToOriginSecureA(const char* file) {
  return ToKURL(std::string(g_base_url_origin_secure_a) + file);
}

KURL ToOriginSandboxA(const char* file) {
  return ToKURL(std::string(g_base_url_sandbox_origin_a) + file);
}

KURL ToOriginB(const char* file) {
  return ToKURL(std::string(g_base_url_origin_b) + file);
}

void RegisterMockedURLLoad(const KURL& url, const char* path) {
  url_test_helpers::RegisterMockedURLLoad(url, test::CoreTestDataPath(path));
}

}  // anonymous namespace

class WebDocumentFirstPartyTest : public WebDocumentTest {
 public:
  static void SetUpTestCase();

 protected:
  void Load(const char*);
  Document* NestedDocument() const;
  Document* NestedNestedDocument() const;
};

void WebDocumentFirstPartyTest::SetUpTestCase() {
  RegisterMockedURLLoad(ToOriginA(g_empty_file), g_empty_file);
  RegisterMockedURLLoad(ToOriginA(g_nested_data), g_nested_data);
  RegisterMockedURLLoad(ToOriginA(g_nested_origin_a), g_nested_origin_a);
  RegisterMockedURLLoad(ToOriginA(g_nested_origin_sub_a),
                        g_nested_origin_sub_a);
  RegisterMockedURLLoad(ToOriginA(g_nested_origin_secure_a),
                        g_nested_origin_secure_a);
  RegisterMockedURLLoad(ToOriginA(g_nested_origin_a_in_origin_a),
                        g_nested_origin_a_in_origin_a);
  RegisterMockedURLLoad(ToOriginA(g_nested_origin_a_in_origin_b),
                        g_nested_origin_a_in_origin_b);
  RegisterMockedURLLoad(ToOriginA(g_nested_origin_b), g_nested_origin_b);
  RegisterMockedURLLoad(ToOriginA(g_nested_origin_b_in_origin_a),
                        g_nested_origin_b_in_origin_a);
  RegisterMockedURLLoad(ToOriginA(g_nested_origin_b_in_origin_b),
                        g_nested_origin_b_in_origin_b);
  RegisterMockedURLLoad(ToOriginA(g_nested_src_doc), g_nested_src_doc);

  RegisterMockedURLLoad(ToOriginSubA(g_empty_file), g_empty_file);
  RegisterMockedURLLoad(ToOriginSecureA(g_empty_file), g_empty_file);

  WebURLResponse response(ToOriginSandboxA(g_empty_file));
  response.SetMimeType(WebString::FromUTF8("text/html"));
  response.SetHttpHeaderField(http_names::kContentType,
                              WebString::FromUTF8("text/html"));
  response.SetHttpHeaderField(http_names::kContentSecurityPolicy,
                              WebString::FromUTF8("sandbox"));
  response.SetHttpStatusCode(200);
  url_test_helpers::RegisterMockedURLLoadWithCustomResponse(
      ToOriginSandboxA(g_empty_file), test::CoreTestDataPath(g_empty_file),
      response);

  RegisterMockedURLLoad(ToOriginB(g_empty_file), g_empty_file);
  RegisterMockedURLLoad(ToOriginB(g_nested_origin_a), g_nested_origin_a);
  RegisterMockedURLLoad(ToOriginB(g_nested_origin_b), g_nested_origin_b);

  RegisterMockedURLLoad(ToFile(g_nested_origin_a), g_nested_origin_a);
}

void WebDocumentFirstPartyTest::Load(const char* file) {
  web_view_helper_.InitializeAndLoad(std::string(g_base_url_origin_a) + file);
}

Document* WebDocumentFirstPartyTest::NestedDocument() const {
  return To<LocalFrame>(web_view_helper_.GetWebView()
                            ->GetPage()
                            ->MainFrame()
                            ->Tree()
                            .FirstChild())
      ->GetDocument();
}

Document* WebDocumentFirstPartyTest::NestedNestedDocument() const {
  return To<LocalFrame>(web_view_helper_.GetWebView()
                            ->GetPage()
                            ->MainFrame()
                            ->Tree()
                            .FirstChild()
                            ->Tree()
                            .FirstChild())
      ->GetDocument();
}

bool OriginsEqual(const char* path,
                  scoped_refptr<const SecurityOrigin> origin) {
  return SecurityOrigin::Create(ToOriginA(path))
      ->IsSameOriginWith(origin.get());
}

bool SiteForCookiesEqual(const char* path,
                         const net::SiteForCookies& site_for_cookies) {
  KURL ref_url = ToOriginA(path);
  ref_url.SetPort(80);  // url::Origin takes exception with :0.
  return net::SiteForCookies::FromUrl(ref_url).IsEquivalent(site_for_cookies);
}

TEST_F(WebDocumentFirstPartyTest, Empty) {
  Load(g_empty_file);

  ASSERT_TRUE(
      SiteForCookiesEqual(g_empty_file, TopDocument()->SiteForCookies()));
  ASSERT_TRUE(OriginsEqual(g_empty_file, TopDocument()->TopFrameOrigin()));
}

TEST_F(WebDocumentFirstPartyTest, EmptySandbox) {
  web_view_helper_.InitializeAndLoad(std::string(g_base_url_sandbox_origin_a) +
                                     g_empty_file);

  ASSERT_TRUE(TopDocument()->TopFrameOrigin()->IsOpaque())
      << TopDocument()->TopFrameOrigin()->ToUrlOrigin().GetDebugString();
  ASSERT_TRUE(TopDocument()->SiteForCookies().IsNull());
}

TEST_F(WebDocumentFirstPartyTest, NestedOriginA) {
  Load(g_nested_origin_a);

  ASSERT_TRUE(
      SiteForCookiesEqual(g_nested_origin_a, TopDocument()->SiteForCookies()));
  ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_a,
                                  NestedDocument()->SiteForCookies()));

  ASSERT_TRUE(OriginsEqual(g_nested_origin_a, TopDocument()->TopFrameOrigin()));
  ASSERT_TRUE(
      OriginsEqual(g_nested_origin_a, NestedDocument()->TopFrameOrigin()));
}

TEST_F(WebDocumentFirstPartyTest, NestedOriginASchemefulSiteForCookies) {
  Load(g_nested_origin_a);

  // TopDocument is same scheme with itself so expect true.
  ASSERT_TRUE(TopDocument()->SiteForCookies().schemefully_same());
  // NestedDocument is same scheme with TopDocument so expect true.
  ASSERT_TRUE(NestedDocument()->SiteForCookies().schemefully_same());
}

TEST_F(WebDocumentFirstPartyTest, NestedOriginSubA) {
  Load(g_nested_origin_sub_a);

  ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_sub_a,
                                  TopDocument()->SiteForCookies()));
  ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_sub_a,
                                  NestedDocument()->SiteForCookies()));

  ASSERT_TRUE(
      OriginsEqual(g_nested_origin_sub_a, TopDocument()->TopFrameOrigin()));
  ASSERT_TRUE(
      OriginsEqual(g_nested_origin_sub_a, NestedDocument()->TopFrameOrigin()));
}

TEST_F(WebDocumentFirstPartyTest, NestedOriginSecureA) {
  Load(g_nested_origin_secure_a);

  ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_secure_a,
                                  TopDocument()->SiteForCookies()));
  ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_secure_a,
                                  NestedDocument()->SiteForCookies()));

  ASSERT_TRUE(
      OriginsEqual(g_nested_origin_secure_a, TopDocument()->TopFrameOrigin()));
  ASSERT_TRUE(OriginsEqual(g_nested_origin_secure_a,
                           NestedDocument()->TopFrameOrigin()));
}

TEST_F(WebDocumentFirstPartyTest, NestedOriginSecureASchemefulSiteForCookies) {
  Load(g_nested_origin_secure_a);

  // TopDocument is same scheme with itself so expect true.
  ASSERT_TRUE(TopDocument()->SiteForCookies().schemefully_same());

  // Since NestedDocument is secure, and the parent is insecure, the scheme will
  // differ.
  ASSERT_FALSE(NestedDocument()->SiteForCookies().schemefully_same());
}

TEST_F(WebDocumentFirstPartyTest, NestedOriginAInOriginA) {
  Load(g_nested_origin_a_in_origin_a);

  ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_a_in_origin_a,
                                  TopDocument()->SiteForCookies()));
  ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_a_in_origin_a,
                                  NestedDocument()->SiteForCookies()));
  ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_a_in_origin_a,
                                  NestedNestedDocument()->SiteForCookies()));

  ASSERT_TRUE(OriginsEqual(g_nested_origin_a_in_origin_a,
                           TopDocument()->TopFrameOrigin()));
  ASSERT_TRUE(OriginsEqual(g_nested_origin_a_in_origin_a,
                           NestedDocument()->TopFrameOrigin()));
}

TEST_F(WebDocumentFirstPartyTest, NestedOriginAInOriginB) {
  Load(g_nested_origin_a_in_origin_b);

  ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_a_in_origin_b,
                                  TopDocument()->SiteForCookies()));
  ASSERT_TRUE(NestedDocument()->SiteForCookies().IsNull());
  ASSERT_TRUE(NestedNestedDocument()->SiteForCookies().IsNull());

  ASSERT_TRUE(OriginsEqual(g_nested_origin_a_in_origin_b,
                           TopDocument()->TopFrameOrigin()));
  ASSERT_TRUE(OriginsEqual(g_nested_origin_a_in_origin_b,
                           NestedDocument()->TopFrameOrigin()));
  ASSERT_TRUE(OriginsEqual(g_nested_origin_a_in_origin_b,
                           NestedNestedDocument()->TopFrameOrigin()));
}

TEST_F(WebDocumentFirstPartyTest, NestedOriginB) {
  Load(g_nested_origin_b);

  ASSERT_TRUE(
      SiteForCookiesEqual(g_nested_origin_b, TopDocument()->SiteForCookies()));
  ASSERT_TRUE(NestedDocument()->SiteForCookies().IsNull());

  ASSERT_TRUE(OriginsEqual(g_nested_origin_b, TopDocument()->TopFrameOrigin()));
  ASSERT_TRUE(
      OriginsEqual(g_nested_origin_b, NestedDocument()->TopFrameOrigin()));
}

TEST_F(WebDocumentFirstPartyTest, NestedOriginBInOriginA) {
  Load(g_nested_origin_b_in_origin_a);

  ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_b_in_origin_a,
                                  TopDocument()->SiteForCookies()));
  ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_b_in_origin_a,
                                  NestedDocument()->SiteForCookies()));
  ASSERT_TRUE(NestedNestedDocument()->SiteForCookies().IsNull());

  ASSERT_TRUE(OriginsEqual(g_nested_origin_b_in_origin_a,
                           TopDocument()->TopFrameOrigin()));
  ASSERT_TRUE(OriginsEqual(g_nested_origin_b_in_origin_a,
                           NestedDocument()->TopFrameOrigin()));
  ASSERT_TRUE(OriginsEqual(g_nested_origin_b_in_origin_a,
                           NestedNestedDocument()->TopFrameOrigin()));
}

TEST_F(WebDocumentFirstPartyTest, NestedOriginBInOriginB) {
  Load(g_nested_origin_b_in_origin_b);

  ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_b_in_origin_b,
                                  TopDocument()->SiteForCookies()));
  ASSERT_TRUE(NestedDocument()->SiteForCookies().IsNull());
  ASSERT_TRUE(NestedNestedDocument()->SiteForCookies().IsNull());

  ASSERT_TRUE(OriginsEqual(g_nested_origin_b_in_origin_b,
                           TopDocument()->TopFrameOrigin()));
  ASSERT_TRUE(OriginsEqual(g_nested_origin_b_in_origin_b,
                           NestedDocument()->TopFrameOrigin()));
  ASSERT_TRUE(OriginsEqual(g_nested_origin_b_in_origin_b,
                           NestedNestedDocument()->TopFrameOrigin()));
}

TEST_F(WebDocumentFirstPartyTest, NestedSrcdoc) {
  Load(g_nested_src_doc);

  ASSERT_TRUE(
      SiteForCookiesEqual(g_nested_src_doc, TopDocument()->SiteForCookies()));
  ASSERT_TRUE(SiteForCookiesEqual(g_nested_src_doc,
                                  NestedDocument()->SiteForCookies()));

  ASSERT_TRUE(OriginsEqual(g_nested_src_doc, TopDocument()->TopFrameOrigin()));
  ASSERT_TRUE(
      OriginsEqual(g_nested_src_doc, NestedDocument()->TopFrameOrigin()));
}

TEST_F(WebDocumentFirstPartyTest, NestedData) {
  Load(g_nested_data);

  ASSERT_TRUE(
      SiteForCookiesEqual(g_nested_data, TopDocument()->SiteForCookies()));
  ASSERT_TRUE(NestedDocument()->SiteForCookies().IsNull());

  ASSERT_TRUE(OriginsEqual(g_nested_data, TopDocument()->TopFrameOrigin()));
  ASSERT_TRUE(OriginsEqual(g_nested_data, NestedDocument()->TopFrameOrigin()));
}

TEST_F(WebDocumentFirstPartyTest,
       NestedOriginAInOriginBWithFirstPartyOverride) {
  Load(g_nested_origin_a_in_origin_b);

  SchemeRegistry::RegisterURLSchemeAsFirstPartyWhenTopLevel("http");

  ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_a_in_origin_b,
                                  TopDocument()->SiteForCookies()));
  ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_a_in_origin_b,
                                  NestedDocument()->SiteForCookies()));
  ASSERT_TRUE(SiteForCookiesEqual(g_nested_origin_a_in_origin_b,
                                  NestedNestedDocument()->SiteForCookies()));

  ASSERT_TRUE(OriginsEqual(g_nested_origin_a_in_origin_b,
                           TopDocument()->TopFrameOrigin()));
  ASSERT_TRUE(OriginsEqual(g_nested_origin_a_in_origin_b,
                           NestedDocument()->TopFrameOrigin()));
  ASSERT_TRUE(OriginsEqual(g_nested_origin_a_in_origin_b,
                           NestedNestedDocument()->TopFrameOrigin()));
}

TEST_F(WebDocumentFirstPartyTest, FileScheme) {
  web_view_helper_.InitializeAndLoad(std::string("file:///") +
                                     g_nested_origin_a);

  net::SiteForCookies top_site_for_cookies = TopDocument()->SiteForCookies();
  EXPECT_EQ("file", top_site_for_cookies.scheme());
  EXPECT_EQ("", top_site_for_cookies.registrable_domain());

  // Nested a.com is 3rd-party to file://
  EXPECT_TRUE(NestedDocument()->SiteForCookies().IsNull());
}

}  // namespace blink