gecko-dev/dom/serviceworkers/ServiceWorkerRegistrationDescriptor.cpp

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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 "mozilla/dom/ServiceWorkerRegistrationDescriptor.h"

#include "mozilla/dom/IPCServiceWorkerRegistrationDescriptor.h"
#include "mozilla/ipc/PBackgroundSharedTypes.h"
#include "ServiceWorkerInfo.h"

namespace mozilla {
namespace dom {

using mozilla::ipc::PrincipalInfo;
using mozilla::ipc::PrincipalInfoToPrincipal;

Maybe<IPCServiceWorkerDescriptor>
ServiceWorkerRegistrationDescriptor::NewestInternal() const
{
  Maybe<IPCServiceWorkerDescriptor> result;
  if (mData->installing().type() != OptionalIPCServiceWorkerDescriptor::Tvoid_t) {
    result.emplace(mData->installing().get_IPCServiceWorkerDescriptor());
  } else if (mData->waiting().type() != OptionalIPCServiceWorkerDescriptor::Tvoid_t) {
    result.emplace(mData->waiting().get_IPCServiceWorkerDescriptor());
  } else if (mData->active().type() != OptionalIPCServiceWorkerDescriptor::Tvoid_t) {
    result.emplace(mData->active().get_IPCServiceWorkerDescriptor());
  }
  return result;
}

ServiceWorkerRegistrationDescriptor::ServiceWorkerRegistrationDescriptor(
                                    uint64_t aId,
                                    uint64_t aVersion,
                                    nsIPrincipal* aPrincipal,
                                    const nsACString& aScope,
                                    ServiceWorkerUpdateViaCache aUpdateViaCache)
  : mData(MakeUnique<IPCServiceWorkerRegistrationDescriptor>())
{
  MOZ_ALWAYS_SUCCEEDS(
    PrincipalToPrincipalInfo(aPrincipal, &mData->principalInfo()));

  mData->id() = aId;
  mData->version() = aVersion;
  mData->scope() = aScope;
  mData->updateViaCache() = aUpdateViaCache;
  mData->installing() = void_t();
  mData->waiting() = void_t();
  mData->active() = void_t();
}

ServiceWorkerRegistrationDescriptor::ServiceWorkerRegistrationDescriptor(
                                    uint64_t aId,
                                    uint64_t aVersion,
                                    const mozilla::ipc::PrincipalInfo& aPrincipalInfo,
                                    const nsACString& aScope,
                                    ServiceWorkerUpdateViaCache aUpdateViaCache)
  : mData(MakeUnique<IPCServiceWorkerRegistrationDescriptor>(aId,
                                                             aVersion,
                                                             aPrincipalInfo,
                                                             nsCString(aScope),
                                                             aUpdateViaCache,
                                                             void_t(),
                                                             void_t(),
                                                             void_t()))
{
}

ServiceWorkerRegistrationDescriptor::ServiceWorkerRegistrationDescriptor(const IPCServiceWorkerRegistrationDescriptor& aDescriptor)
  : mData(MakeUnique<IPCServiceWorkerRegistrationDescriptor>(aDescriptor))
{
  MOZ_DIAGNOSTIC_ASSERT(IsValid());
}

ServiceWorkerRegistrationDescriptor::ServiceWorkerRegistrationDescriptor(const ServiceWorkerRegistrationDescriptor& aRight)
{
  // UniquePtr doesn't have a default copy constructor, so we can't rely
  // on default copy construction.  Use the assignment operator to
  // minimize duplication.
  operator=(aRight);
}

ServiceWorkerRegistrationDescriptor&
ServiceWorkerRegistrationDescriptor::operator=(const ServiceWorkerRegistrationDescriptor& aRight)
{
  if (this == &aRight) {
    return *this;
  }
  mData.reset();
  mData = MakeUnique<IPCServiceWorkerRegistrationDescriptor>(*aRight.mData);
  MOZ_DIAGNOSTIC_ASSERT(IsValid());
  return *this;
}

ServiceWorkerRegistrationDescriptor::ServiceWorkerRegistrationDescriptor(ServiceWorkerRegistrationDescriptor&& aRight)
  : mData(std::move(aRight.mData))
{
  MOZ_DIAGNOSTIC_ASSERT(IsValid());
}

ServiceWorkerRegistrationDescriptor&
ServiceWorkerRegistrationDescriptor::operator=(ServiceWorkerRegistrationDescriptor&& aRight)
{
  mData.reset();
  mData = std::move(aRight.mData);
  MOZ_DIAGNOSTIC_ASSERT(IsValid());
  return *this;
}

ServiceWorkerRegistrationDescriptor::~ServiceWorkerRegistrationDescriptor()
{
  // Non-default destructor to avoid exposing the IPC type in the header.
}

bool
ServiceWorkerRegistrationDescriptor::operator==(const ServiceWorkerRegistrationDescriptor& aRight) const
{
  return *mData == *aRight.mData;
}

uint64_t
ServiceWorkerRegistrationDescriptor::Id() const
{
  return mData->id();
}

uint64_t
ServiceWorkerRegistrationDescriptor::Version() const
{
  return mData->version();
}

ServiceWorkerUpdateViaCache
ServiceWorkerRegistrationDescriptor::UpdateViaCache() const
{
  return mData->updateViaCache();
}

const mozilla::ipc::PrincipalInfo&
ServiceWorkerRegistrationDescriptor::PrincipalInfo() const
{
  return mData->principalInfo();
}

nsCOMPtr<nsIPrincipal>
ServiceWorkerRegistrationDescriptor::GetPrincipal() const
{
  AssertIsOnMainThread();
  nsCOMPtr<nsIPrincipal> ref =  PrincipalInfoToPrincipal(mData->principalInfo());
  return ref;
}

const nsCString&
ServiceWorkerRegistrationDescriptor::Scope() const
{
  return mData->scope();
}

Maybe<ServiceWorkerDescriptor>
ServiceWorkerRegistrationDescriptor::GetInstalling() const
{
  Maybe<ServiceWorkerDescriptor> result;

  if (mData->installing().type() != OptionalIPCServiceWorkerDescriptor::Tvoid_t) {
    result.emplace(ServiceWorkerDescriptor(
      mData->installing().get_IPCServiceWorkerDescriptor()));
  }

  return result;
}

Maybe<ServiceWorkerDescriptor>
ServiceWorkerRegistrationDescriptor::GetWaiting() const
{
  Maybe<ServiceWorkerDescriptor> result;

  if (mData->waiting().type() != OptionalIPCServiceWorkerDescriptor::Tvoid_t) {
    result.emplace(ServiceWorkerDescriptor(
      mData->waiting().get_IPCServiceWorkerDescriptor()));
  }

  return result;
}

Maybe<ServiceWorkerDescriptor>
ServiceWorkerRegistrationDescriptor::GetActive() const
{
  Maybe<ServiceWorkerDescriptor> result;

  if (mData->active().type() != OptionalIPCServiceWorkerDescriptor::Tvoid_t) {
    result.emplace(ServiceWorkerDescriptor(
      mData->active().get_IPCServiceWorkerDescriptor()));
  }

  return result;
}

Maybe<ServiceWorkerDescriptor>
ServiceWorkerRegistrationDescriptor::Newest() const
{
  Maybe<ServiceWorkerDescriptor> result;
  Maybe<IPCServiceWorkerDescriptor> newest(NewestInternal());
  if (newest.isSome()) {
    result.emplace(ServiceWorkerDescriptor(newest.ref()));
  }
  return result;
}

bool
ServiceWorkerRegistrationDescriptor::HasWorker(const ServiceWorkerDescriptor& aDescriptor) const
{
  Maybe<ServiceWorkerDescriptor> installing = GetInstalling();
  Maybe<ServiceWorkerDescriptor> waiting = GetWaiting();
  Maybe<ServiceWorkerDescriptor> active = GetActive();
  return (installing.isSome() && installing.ref().Matches(aDescriptor)) ||
         (waiting.isSome() && waiting.ref().Matches(aDescriptor)) ||
         (active.isSome() && active.ref().Matches(aDescriptor));
}

namespace {

bool
IsValidWorker(const OptionalIPCServiceWorkerDescriptor& aWorker,
              const nsACString& aScope,
              const mozilla::ipc::ContentPrincipalInfo& aContentPrincipal)
{
  if (aWorker.type() == OptionalIPCServiceWorkerDescriptor::Tvoid_t) {
    return true;
  }

  auto& worker = aWorker.get_IPCServiceWorkerDescriptor();
  if (worker.scope() != aScope) {
    return false;
  }

  auto& principalInfo = worker.principalInfo();
  if (principalInfo.type() != mozilla::ipc::PrincipalInfo::TContentPrincipalInfo) {
    return false;
  }

  auto& contentPrincipal = principalInfo.get_ContentPrincipalInfo();
  if (contentPrincipal.originNoSuffix() != aContentPrincipal.originNoSuffix() ||
      contentPrincipal.attrs() != aContentPrincipal.attrs()) {
    return false;
  }

  return true;
}

} // anonymous namespace

bool
ServiceWorkerRegistrationDescriptor::IsValid() const
{
  auto& principalInfo = PrincipalInfo();
  if (principalInfo.type() != mozilla::ipc::PrincipalInfo::TContentPrincipalInfo) {
    return false;
  }

  auto& contentPrincipal = principalInfo.get_ContentPrincipalInfo();
  if (!IsValidWorker(mData->installing(), Scope(), contentPrincipal) ||
      !IsValidWorker(mData->waiting(), Scope(), contentPrincipal) ||
      !IsValidWorker(mData->active(), Scope(), contentPrincipal)) {
    return false;
  }

  return true;
}

void
ServiceWorkerRegistrationDescriptor::SetUpdateViaCache(ServiceWorkerUpdateViaCache aUpdateViaCache)
{
  mData->updateViaCache() = aUpdateViaCache;
}

void
ServiceWorkerRegistrationDescriptor::SetWorkers(ServiceWorkerInfo* aInstalling,
                                                ServiceWorkerInfo* aWaiting,
                                                ServiceWorkerInfo* aActive)
{
  if (aInstalling) {
    aInstalling->SetRegistrationVersion(Version());
    mData->installing() = aInstalling->Descriptor().ToIPC();
  } else {
    mData->installing() = void_t();
  }

  if (aWaiting) {
    aWaiting->SetRegistrationVersion(Version());
    mData->waiting() = aWaiting->Descriptor().ToIPC();
  } else {
    mData->waiting() = void_t();
  }

  if (aActive) {
    aActive->SetRegistrationVersion(Version());
    mData->active() = aActive->Descriptor().ToIPC();
  } else {
    mData->active() = void_t();
  }

  MOZ_DIAGNOSTIC_ASSERT(IsValid());
}

void
ServiceWorkerRegistrationDescriptor::SetVersion(uint64_t aVersion)
{
  MOZ_DIAGNOSTIC_ASSERT(aVersion > mData->version());
  mData->version() = aVersion;
}

const IPCServiceWorkerRegistrationDescriptor&
ServiceWorkerRegistrationDescriptor::ToIPC() const
{
  return *mData;
}

} // namespace dom
} // namespace mozilla