RemoteTypeTest.cpp

Enable keyboard shortcuts

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this file,

 * You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "gtest/gtest.h"

#include "mozilla/OriginAttributes.h"

#include "mozilla/dom/RemoteType.h"

#include "mozilla/gtest/MozAssertions.h"

namespace mozilla::dom {

TEST(RemoteTypeTest, FormatSimple)

  // NotRemote is special in that it has a different value for Stringify() and

  // StringifyKind(). This will be changed in the future.

  EXPECT_TRUE(RemoteType::NotRemote().IsKnown());

  EXPECT_EQ(RemoteType::NotRemote().Stringify(), VoidCString());

  EXPECT_EQ(RemoteType::NotRemote().StringifyKind(), "parent"_ns);

  EXPECT_FALSE(RemoteType::NotRemote().HasMeta());

  EXPECT_EQ(RemoteType::NotRemote().StringifyMeta(), ""_ns);

  auto formatSimple = [](RemoteType::Kind aKind, const nsACString& aString) {

    RemoteType remoteType(aKind);

    EXPECT_TRUE(remoteType.IsKnown());

    EXPECT_EQ(remoteType.StringifyKind(), aString);

    EXPECT_FALSE(remoteType.HasMeta());

    EXPECT_EQ(remoteType.StringifyMeta(), ""_ns);

    EXPECT_EQ(remoteType.Stringify(), aString);

};

  formatSimple(RemoteType::Kind::Prealloc, "prealloc"_ns);

  formatSimple(RemoteType::Kind::WebContent, "web"_ns);

  formatSimple(RemoteType::Kind::File, "file"_ns);

  formatSimple(RemoteType::Kind::PrivilegedAbout, "privilegedabout"_ns);

  formatSimple(RemoteType::Kind::PrivilegedMozilla, "privilegedmozilla"_ns);

  formatSimple(RemoteType::Kind::Extension, "extension"_ns);

  formatSimple(RemoteType::Kind::Inference, "inference"_ns);

TEST(RemoteTypeTest, FormatCompound)

  auto formatCompound = [](RemoteType aRemoteType, const nsACString& aKind,

                           const nsACString& aMeta) {

    EXPECT_TRUE(aRemoteType.IsKnown());

    EXPECT_EQ(aRemoteType.StringifyKind(), aKind);

    EXPECT_TRUE(aRemoteType.HasMeta());

    EXPECT_EQ(aRemoteType.StringifyMeta(), aMeta);

    nsCString expected = aKind + "="_ns + aMeta;

    EXPECT_EQ(aRemoteType.Stringify(), expected);

};

  OriginAttributes attrs;

  attrs.mUserContextId = 2;

  attrs.mPrivateBrowsingId = 1;

  formatCompound(

      RemoteType::SharedWeb(attrs).WithDisableJit(true).WithSiteOrigin(

          "https://example.com"_ns),

      "webIsolated"_ns,

      "https://example.com^userContextId=2&privateBrowsingId=1&disableJit=1"_ns);

  formatCompound(RemoteType::SharedWeb({})

                     .WithSiteOrigin("https://example.com"_ns)

                     .WithDisableJit(true),

                 "webIsolated"_ns, "https://example.com^disableJit=1"_ns);

  formatCompound(

      RemoteType::SharedWeb({}).WithSiteOrigin("https://example.com"_ns),

      "webIsolated"_ns, "https://example.com"_ns);

  formatCompound(RemoteType::SharedWeb({}).WithSiteOrigin(

                     "https://example.com"_ns, RemoteType::Kind::WebCoopCoep),

                 "webCOOP+COEP"_ns, "https://example.com"_ns);

  formatCompound(

      RemoteType::SharedWeb({}).WithSiteOrigin(

          "https://example.com"_ns, RemoteType::Kind::WebServiceWorker),

      "webServiceWorker"_ns, "https://example.com"_ns);

TEST(RemoteTypeTest, ParseValid)

  EXPECT_EQ(RemoteType::Parse(VoidCString()), RemoteType::NotRemote());

  EXPECT_EQ(RemoteType::Parse("prealloc"_ns),

            RemoteType(RemoteType::Kind::Prealloc));

  EXPECT_EQ(RemoteType::Parse("file"_ns), RemoteType(RemoteType::Kind::File));

  EXPECT_EQ(RemoteType::Parse("privilegedabout"_ns),

            RemoteType(RemoteType::Kind::PrivilegedAbout));

  EXPECT_EQ(RemoteType::Parse("privilegedmozilla"_ns),

            RemoteType(RemoteType::Kind::PrivilegedMozilla));

  EXPECT_EQ(RemoteType::Parse("extension"_ns),

            RemoteType(RemoteType::Kind::Extension));

  EXPECT_EQ(RemoteType::Parse("inference"_ns),

            RemoteType(RemoteType::Kind::Inference));

  EXPECT_EQ(RemoteType::Parse("web"_ns),

            RemoteType(RemoteType::Kind::WebContent));

  EXPECT_EQ(RemoteType::Parse("web=^disableJit=1"_ns),

            RemoteType::SharedWeb({}).WithDisableJit(true));

    OriginAttributes attrs;

    attrs.mUserContextId = 2;

    attrs.mPrivateBrowsingId = 1;

    EXPECT_EQ(RemoteType::Parse("web=^userContextId=2&privateBrowsingId=1"_ns),

              RemoteType::SharedWeb(attrs));

    OriginAttributes attrs;

    attrs.mGeckoViewSessionContextId = u"session 1"_ns;

    EXPECT_EQ(RemoteType::Parse("web=^geckoViewUserContextId=session+1"_ns),

              RemoteType::SharedWeb(attrs));

  EXPECT_EQ(RemoteType::Parse("webIsolated=https://example.com"_ns),

            RemoteType::SharedWeb({}).WithSiteOrigin("https://example.com"_ns));

  EXPECT_EQ(RemoteType::Parse("webCOOP+COEP=https://example.com"_ns),

            RemoteType::SharedWeb({}).WithSiteOrigin(

                "https://example.com"_ns, RemoteType::Kind::WebCoopCoep));

  EXPECT_EQ(RemoteType::Parse("webServiceWorker=https://example.com"_ns),

            RemoteType::SharedWeb({}).WithSiteOrigin(

                "https://example.com"_ns, RemoteType::Kind::WebServiceWorker));

TEST(RemoteTypeTest, ParseInvalid)

  constexpr nsLiteralCString kRemoteTypes[] = {

      ""_ns,

      "unknown"_ns,

      "parent"_ns,

      "web=^unknown=1"_ns,

      "web=^disableJit=0"_ns,

      "web=^disableJit=true"_ns,

      "web=^userContextId=abc"_ns,

      "web=^userContextId=1&userContextId=2"_ns,

      "web=^privateBrowsingId=1&userContextId=2"_ns,

      "web=https://example.com"_ns,

      "web=^"_ns,

      "webIsolated=https://example.com^"_ns,

      "webIsolated=https://example.com/"_ns,

      "webIsolated=https://user@example.com"_ns,

      "webIsolated="_ns,

      "webCOOP+COEP"_ns,

      "webServiceWorker"_ns,

      "file=^userContextId=1"_ns,

      "privilegedabout=https://example.com"_ns,

      "privilegedabout=^userContextId=1"_ns,

};

  for (const auto& string : kRemoteTypes) {

    EXPECT_FALSE(RemoteType::Parse(string)) << string;

}  // namespace mozilla::dom