/* -*- 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 "ServiceWorkerEvents.h"

#include "nsAutoPtr.h"

#include "nsContentUtils.h"

#include "nsIConsoleReportCollector.h"

#include "nsIHttpChannelInternal.h"

#include "nsINetworkInterceptController.h"

#include "nsIOutputStream.h"

#include "nsIScriptError.h"

#include "nsITimedChannel.h"

#include "mozilla/Encoding.h"

#include "nsContentPolicyUtils.h"

#include "nsContentUtils.h"

#include "nsComponentManagerUtils.h"

#include "nsServiceManagerUtils.h"

#include "nsStreamUtils.h"

#include "nsNetCID.h"

#include "nsNetUtil.h"

#include "nsSerializationHelper.h"

#include "nsQueryObject.h"

#include "ServiceWorker.h"

#include "ServiceWorkerManager.h"

#include "mozilla/ErrorResult.h"

#include "mozilla/LoadInfo.h"

#include "mozilla/Move.h"

#include "mozilla/Preferences.h"

#include "mozilla/dom/BodyUtil.h"

#include "mozilla/dom/Client.h"

#include "mozilla/dom/EventBinding.h"

#include "mozilla/dom/FetchEventBinding.h"

#include "mozilla/dom/MessagePort.h"

#include "mozilla/dom/PromiseNativeHandler.h"

#include "mozilla/dom/PushEventBinding.h"

#include "mozilla/dom/PushMessageDataBinding.h"

#include "mozilla/dom/PushUtil.h"

#include "mozilla/dom/Request.h"

#include "mozilla/dom/TypedArray.h"

#include "mozilla/dom/Response.h"

#include "mozilla/dom/WorkerScope.h"

#include "mozilla/dom/WorkerPrivate.h"

#include "js/Conversions.h"

#include "js/TypeDecls.h"

#include "xpcpublic.h"

using namespace mozilla;

using namespace mozilla::dom;

namespace {

void

AsyncLog(nsIInterceptedChannel *aInterceptedChannel,

         const nsACString& aRespondWithScriptSpec,

         uint32_t aRespondWithLineNumber, uint32_t aRespondWithColumnNumber,

         const nsACString& aMessageName, const nsTArray<nsString>& aParams)

{

  MOZ_ASSERT(aInterceptedChannel);

  nsCOMPtr<nsIConsoleReportCollector> reporter =

    aInterceptedChannel->GetConsoleReportCollector();

  if (reporter) {

    reporter->AddConsoleReport(nsIScriptError::errorFlag,

                               NS_LITERAL_CSTRING("Service Worker Interception"),

                               nsContentUtils::eDOM_PROPERTIES,

                               aRespondWithScriptSpec,

                               aRespondWithLineNumber,

                               aRespondWithColumnNumber,

                               aMessageName, aParams);

  }

}

template<typename... Params>

void

AsyncLog(nsIInterceptedChannel* aInterceptedChannel,

         const nsACString& aRespondWithScriptSpec,

         uint32_t aRespondWithLineNumber, uint32_t aRespondWithColumnNumber,

         // We have to list one explicit string so that calls with an

         // nsTArray of params won't end up in here.

         const nsACString& aMessageName, const nsAString& aFirstParam,

         Params&&... aParams)

{

  nsTArray<nsString> paramsList(sizeof...(Params) + 1);

  StringArrayAppender::Append(paramsList, sizeof...(Params) + 1,

                              aFirstParam, std::forward<Params>(aParams)...);

  AsyncLog(aInterceptedChannel, aRespondWithScriptSpec, aRespondWithLineNumber,

           aRespondWithColumnNumber, aMessageName, paramsList);

}

Unexecuted instantiation: Unified_cpp_dom_serviceworkers0.cpp:void (anonymous namespace)::AsyncLog<nsTString<char16_t>&>(nsIInterceptedChannel*, nsTSubstring<char> const&, unsigned int, unsigned int, nsTSubstring<char> const&, nsTSubstring<char16_t> const&, nsTString<char16_t>&)

Unexecuted instantiation: Unified_cpp_dom_serviceworkers0.cpp:void (anonymous namespace)::AsyncLog<>(nsIInterceptedChannel*, nsTSubstring<char> const&, unsigned int, unsigned int, nsTSubstring<char> const&, nsTSubstring<char16_t> const&)

} // anonymous namespace

namespace mozilla {

namespace dom {

CancelChannelRunnable::CancelChannelRunnable(

  nsMainThreadPtrHandle<nsIInterceptedChannel>& aChannel,

  nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo>& aRegistration,

  nsresult aStatus)

  : Runnable("dom::CancelChannelRunnable")

  , mChannel(aChannel)

  , mRegistration(aRegistration)

  , mStatus(aStatus)

{

}

NS_IMETHODIMP

CancelChannelRunnable::Run()

{

  MOZ_ASSERT(NS_IsMainThread());

  // TODO: When bug 1204254 is implemented, this time marker should be moved to

  // the point where the body of the network request is complete.

  mChannel->SetHandleFetchEventEnd(TimeStamp::Now());

  mChannel->SaveTimeStamps();

  mChannel->CancelInterception(mStatus);

  mRegistration->MaybeScheduleUpdate();

  return NS_OK;

}

FetchEvent::FetchEvent(EventTarget* aOwner)

  : ExtendableEvent(aOwner)

  , mPreventDefaultLineNumber(0)

  , mPreventDefaultColumnNumber(0)

  , mIsReload(false)

  , mWaitToRespond(false)

{

}

FetchEvent::~FetchEvent()

{

}

void

FetchEvent::PostInit(nsMainThreadPtrHandle<nsIInterceptedChannel>& aChannel,

                     nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo>& aRegistration,

                     const nsACString& aScriptSpec)

{

  mChannel = aChannel;

  mRegistration = aRegistration;

  mScriptSpec.Assign(aScriptSpec);

}

/*static*/ already_AddRefed<FetchEvent>

FetchEvent::Constructor(const GlobalObject& aGlobal,

                        const nsAString& aType,

                        const FetchEventInit& aOptions,

                        ErrorResult& aRv)

{

  RefPtr<EventTarget> owner = do_QueryObject(aGlobal.GetAsSupports());

  MOZ_ASSERT(owner);

  RefPtr<FetchEvent> e = new FetchEvent(owner);

  bool trusted = e->Init(owner);

  e->InitEvent(aType, aOptions.mBubbles, aOptions.mCancelable);

  e->SetTrusted(trusted);

  e->SetComposed(aOptions.mComposed);

  e->mRequest = aOptions.mRequest;

  e->mClientId = aOptions.mClientId;

  e->mIsReload = aOptions.mIsReload;

  return e.forget();

}

namespace {

struct RespondWithClosure

{

  nsMainThreadPtrHandle<nsIInterceptedChannel> mInterceptedChannel;

  nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo> mRegistration;

  const nsString mRequestURL;

  const nsCString mRespondWithScriptSpec;

  const uint32_t mRespondWithLineNumber;

  const uint32_t mRespondWithColumnNumber;

  RespondWithClosure(nsMainThreadPtrHandle<nsIInterceptedChannel>& aChannel,

                     nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo>& aRegistration,

                     const nsAString& aRequestURL,

                     const nsACString& aRespondWithScriptSpec,

                     uint32_t aRespondWithLineNumber,

                     uint32_t aRespondWithColumnNumber)

    : mInterceptedChannel(aChannel)

    , mRegistration(aRegistration)

    , mRequestURL(aRequestURL)

    , mRespondWithScriptSpec(aRespondWithScriptSpec)

    , mRespondWithLineNumber(aRespondWithLineNumber)

    , mRespondWithColumnNumber(aRespondWithColumnNumber)

  {

  }

};

class FinishResponse final : public Runnable

{

  nsMainThreadPtrHandle<nsIInterceptedChannel> mChannel;

public:

  explicit FinishResponse(nsMainThreadPtrHandle<nsIInterceptedChannel>& aChannel)

    : Runnable("dom::FinishResponse")

    , mChannel(aChannel)

  {

  }

  NS_IMETHOD

  Run() override

  {

    MOZ_ASSERT(NS_IsMainThread());

    nsresult rv = mChannel->FinishSynthesizedResponse();

    if (NS_WARN_IF(NS_FAILED(rv))) {

      mChannel->CancelInterception(NS_ERROR_INTERCEPTION_FAILED);

      return NS_OK;

    }

    TimeStamp timeStamp = TimeStamp::Now();

    mChannel->SetHandleFetchEventEnd(timeStamp);

    mChannel->SetFinishSynthesizedResponseEnd(timeStamp);

    mChannel->SaveTimeStamps();

    return rv;

  }

};

class BodyCopyHandle final : public nsIInterceptedBodyCallback

{

  UniquePtr<RespondWithClosure> mClosure;

  ~BodyCopyHandle()

  {

  }

public:

  NS_DECL_THREADSAFE_ISUPPORTS

  explicit BodyCopyHandle(UniquePtr<RespondWithClosure>&& aClosure)

    : mClosure(std::move(aClosure))

  {

  }

  NS_IMETHOD

  BodyComplete(nsresult aRv) override

  {

    MOZ_ASSERT(NS_IsMainThread());

    nsCOMPtr<nsIRunnable> event;

    if (NS_WARN_IF(NS_FAILED(aRv))) {

      AsyncLog(mClosure->mInterceptedChannel, mClosure->mRespondWithScriptSpec,

               mClosure->mRespondWithLineNumber,

               mClosure->mRespondWithColumnNumber,

               NS_LITERAL_CSTRING("InterceptionFailedWithURL"),

               mClosure->mRequestURL);

      event = new CancelChannelRunnable(mClosure->mInterceptedChannel,

                                        mClosure->mRegistration,

                                        NS_ERROR_INTERCEPTION_FAILED);

    } else {

      event = new FinishResponse(mClosure->mInterceptedChannel);

    }

    mClosure.reset();

    event->Run();

    return NS_OK;

  }

};

NS_IMPL_ISUPPORTS(BodyCopyHandle, nsIInterceptedBodyCallback)

class StartResponse final : public Runnable

{

  nsMainThreadPtrHandle<nsIInterceptedChannel> mChannel;

  RefPtr<InternalResponse> mInternalResponse;

  ChannelInfo mWorkerChannelInfo;

  const nsCString mScriptSpec;

  const nsCString mResponseURLSpec;

  UniquePtr<RespondWithClosure> mClosure;

public:

  StartResponse(nsMainThreadPtrHandle<nsIInterceptedChannel>& aChannel,

                InternalResponse* aInternalResponse,

                const ChannelInfo& aWorkerChannelInfo,

                const nsACString& aScriptSpec,

                const nsACString& aResponseURLSpec,

                UniquePtr<RespondWithClosure>&& aClosure)

    : Runnable("dom::StartResponse")

    , mChannel(aChannel)

    , mInternalResponse(aInternalResponse)

    , mWorkerChannelInfo(aWorkerChannelInfo)

    , mScriptSpec(aScriptSpec)

    , mResponseURLSpec(aResponseURLSpec)

    , mClosure(std::move(aClosure))

  {

  }

  NS_IMETHOD

  Run() override

  {

    MOZ_ASSERT(NS_IsMainThread());

    nsCOMPtr<nsIChannel> underlyingChannel;

    nsresult rv = mChannel->GetChannel(getter_AddRefs(underlyingChannel));

    NS_ENSURE_SUCCESS(rv, rv);

    NS_ENSURE_TRUE(underlyingChannel, NS_ERROR_UNEXPECTED);

    nsCOMPtr<nsILoadInfo> loadInfo = underlyingChannel->GetLoadInfo();

    if (!loadInfo || !CSPPermitsResponse(loadInfo)) {

      mChannel->CancelInterception(NS_ERROR_CONTENT_BLOCKED);

      return NS_OK;

    }

    ChannelInfo channelInfo;

    if (mInternalResponse->GetChannelInfo().IsInitialized()) {

      channelInfo = mInternalResponse->GetChannelInfo();

    } else {

      // We are dealing with a synthesized response here, so fall back to the

      // channel info for the worker script.

      channelInfo = mWorkerChannelInfo;

    }

    rv = mChannel->SetChannelInfo(&channelInfo);

    if (NS_WARN_IF(NS_FAILED(rv))) {

      mChannel->CancelInterception(NS_ERROR_INTERCEPTION_FAILED);

      return NS_OK;

    }

    rv = mChannel->SynthesizeStatus(mInternalResponse->GetUnfilteredStatus(),

                                    mInternalResponse->GetUnfilteredStatusText());

    if (NS_WARN_IF(NS_FAILED(rv))) {

      mChannel->CancelInterception(NS_ERROR_INTERCEPTION_FAILED);

      return NS_OK;

    }

    AutoTArray<InternalHeaders::Entry, 5> entries;

    mInternalResponse->UnfilteredHeaders()->GetEntries(entries);

    for (uint32_t i = 0; i < entries.Length(); ++i) {

       mChannel->SynthesizeHeader(entries[i].mName, entries[i].mValue);

    }

    auto castLoadInfo = static_cast<mozilla::net::LoadInfo*>(loadInfo.get());

    castLoadInfo->SynthesizeServiceWorkerTainting(mInternalResponse->GetTainting());

    // Get the preferred alternative data type of outter channel

    nsAutoCString preferredAltDataType(EmptyCString());

    nsCOMPtr<nsICacheInfoChannel> outerChannel = do_QueryInterface(underlyingChannel);

    if (outerChannel) {

      outerChannel->GetPreferredAlternativeDataType(preferredAltDataType);

    }

    // Get the alternative data type saved in the InternalResponse

    nsAutoCString altDataType;

    nsCOMPtr<nsICacheInfoChannel> cacheInfoChannel =

      mInternalResponse->TakeCacheInfoChannel().get();

    if (cacheInfoChannel) {

      cacheInfoChannel->GetAlternativeDataType(altDataType);

    }

     nsCOMPtr<nsIInputStream> body;

    if (preferredAltDataType.Equals(altDataType)) {

      body = mInternalResponse->TakeAlternativeBody();

    }

    if (!body) {

      mInternalResponse->GetUnfilteredBody(getter_AddRefs(body));

    } else {

      Telemetry::ScalarAdd(Telemetry::ScalarID::SW_ALTERNATIVE_BODY_USED_COUNT, 1);

    }

    RefPtr<BodyCopyHandle> copyHandle;

    copyHandle = new BodyCopyHandle(std::move(mClosure));

    rv = mChannel->StartSynthesizedResponse(body, copyHandle, cacheInfoChannel,

                                            mResponseURLSpec,

                                            mInternalResponse->IsRedirected());

    if (NS_WARN_IF(NS_FAILED(rv))) {

      mChannel->CancelInterception(NS_ERROR_INTERCEPTION_FAILED);

      return NS_OK;

    }

    nsCOMPtr<nsIObserverService> obsService = services::GetObserverService();

    if (obsService) {

      obsService->NotifyObservers(underlyingChannel, "service-worker-synthesized-response", nullptr);

    }

    return rv;

  }

  bool CSPPermitsResponse(nsILoadInfo* aLoadInfo)

  {

    MOZ_ASSERT(NS_IsMainThread());

    MOZ_ASSERT(aLoadInfo);

    nsresult rv;

    nsCOMPtr<nsIURI> uri;

    nsCString url = mInternalResponse->GetUnfilteredURL();

    if (url.IsEmpty()) {

      // Synthetic response. The buck stops at the worker script.

      url = mScriptSpec;

    }

    rv = NS_NewURI(getter_AddRefs(uri), url, nullptr, nullptr);

    NS_ENSURE_SUCCESS(rv, false);

    int16_t decision = nsIContentPolicy::ACCEPT;

    rv = NS_CheckContentLoadPolicy(uri, aLoadInfo, EmptyCString(), &decision);

    NS_ENSURE_SUCCESS(rv, false);

    return decision == nsIContentPolicy::ACCEPT;

  }

};

class RespondWithHandler final : public PromiseNativeHandler

{

  nsMainThreadPtrHandle<nsIInterceptedChannel> mInterceptedChannel;

  nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo> mRegistration;

  const RequestMode mRequestMode;

  const RequestRedirect mRequestRedirectMode;

#ifdef DEBUG

  const bool mIsClientRequest;

#endif

  const nsCString mScriptSpec;

  const nsString mRequestURL;

  const nsCString mRequestFragment;

  const nsCString mRespondWithScriptSpec;

  const uint32_t mRespondWithLineNumber;

  const uint32_t mRespondWithColumnNumber;

  bool mRequestWasHandled;

public:

  NS_DECL_ISUPPORTS

  RespondWithHandler(nsMainThreadPtrHandle<nsIInterceptedChannel>& aChannel,

                     nsMainThreadPtrHandle<ServiceWorkerRegistrationInfo>& aRegistration,

                     RequestMode aRequestMode, bool aIsClientRequest,

                     RequestRedirect aRedirectMode,

                     const nsACString& aScriptSpec,

                     const nsAString& aRequestURL,

                     const nsACString& aRequestFragment,

                     const nsACString& aRespondWithScriptSpec,

                     uint32_t aRespondWithLineNumber,

                     uint32_t aRespondWithColumnNumber)

    : mInterceptedChannel(aChannel)

    , mRegistration(aRegistration)

    , mRequestMode(aRequestMode)

    , mRequestRedirectMode(aRedirectMode)

#ifdef DEBUG

    , mIsClientRequest(aIsClientRequest)

#endif

    , mScriptSpec(aScriptSpec)

    , mRequestURL(aRequestURL)

    , mRequestFragment(aRequestFragment)

    , mRespondWithScriptSpec(aRespondWithScriptSpec)

    , mRespondWithLineNumber(aRespondWithLineNumber)

    , mRespondWithColumnNumber(aRespondWithColumnNumber)

    , mRequestWasHandled(false)

  {

  }

  void ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override;

  void RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override;

  void CancelRequest(nsresult aStatus);

  void AsyncLog(const nsACString& aMessageName, const nsTArray<nsString>& aParams)

  {

    ::AsyncLog(mInterceptedChannel, mRespondWithScriptSpec, mRespondWithLineNumber,

               mRespondWithColumnNumber, aMessageName, aParams);

  }

  void AsyncLog(const nsACString& aSourceSpec, uint32_t aLine, uint32_t aColumn,

                const nsACString& aMessageName, const nsTArray<nsString>& aParams)

  {

    ::AsyncLog(mInterceptedChannel, aSourceSpec, aLine, aColumn, aMessageName,

               aParams);

  }

private:

  ~RespondWithHandler()

  {

    if (!mRequestWasHandled) {

      ::AsyncLog(mInterceptedChannel, mRespondWithScriptSpec,

                 mRespondWithLineNumber, mRespondWithColumnNumber,

                 NS_LITERAL_CSTRING("InterceptionFailedWithURL"), mRequestURL);

      CancelRequest(NS_ERROR_INTERCEPTION_FAILED);

    }

  }

};

class MOZ_STACK_CLASS AutoCancel

{

  RefPtr<RespondWithHandler> mOwner;

  nsCString mSourceSpec;

  uint32_t mLine;

  uint32_t mColumn;

  nsCString mMessageName;

  nsTArray<nsString> mParams;

public:

  AutoCancel(RespondWithHandler* aOwner, const nsString& aRequestURL)

    : mOwner(aOwner)

    , mLine(0)

    , mColumn(0)

    , mMessageName(NS_LITERAL_CSTRING("InterceptionFailedWithURL"))

  {

    mParams.AppendElement(aRequestURL);

  }

  ~AutoCancel()

  {

    if (mOwner) {

      if (mSourceSpec.IsEmpty()) {

        mOwner->AsyncLog(mMessageName, mParams);

      } else {

        mOwner->AsyncLog(mSourceSpec, mLine, mColumn, mMessageName, mParams);

      }

      mOwner->CancelRequest(NS_ERROR_INTERCEPTION_FAILED);

    }

  }

  // This function steals the error message from a ErrorResult.

  void

  SetCancelErrorResult(JSContext* aCx, ErrorResult& aRv)

  {

    MOZ_DIAGNOSTIC_ASSERT(aRv.Failed());

    MOZ_DIAGNOSTIC_ASSERT(!JS_IsExceptionPending(aCx));

    // Storing the error as exception in the JSContext.

    if (!aRv.MaybeSetPendingException(aCx)) {

      return;

    }

    MOZ_ASSERT(!aRv.Failed());

    // Let's take the pending exception.

    JS::Rooted<JS::Value> exn(aCx);

    if (!JS_GetPendingException(aCx, &exn)) {

      return;

    }

    JS_ClearPendingException(aCx);

    // Converting the exception in a js::ErrorReport.

    js::ErrorReport report(aCx);

    if (!report.init(aCx, exn, js::ErrorReport::WithSideEffects)) {

      JS_ClearPendingException(aCx);

      return;

    }

    MOZ_ASSERT(mOwner);

    MOZ_ASSERT(mMessageName.EqualsLiteral("InterceptionFailedWithURL"));

    MOZ_ASSERT(mParams.Length() == 1);

    // Let's store the error message here.

    mMessageName.Assign(report.toStringResult().c_str());

    mParams.Clear();

  }

  template<typename... Params>

  void SetCancelMessage(const nsACString& aMessageName, Params&&... aParams)

  {

    MOZ_ASSERT(mOwner);

    MOZ_ASSERT(mMessageName.EqualsLiteral("InterceptionFailedWithURL"));

    MOZ_ASSERT(mParams.Length() == 1);

    mMessageName = aMessageName;

    mParams.Clear();

    StringArrayAppender::Append(mParams, sizeof...(Params),

                                std::forward<Params>(aParams)...);

  }

Unexecuted instantiation: Unified_cpp_dom_serviceworkers0.cpp:void mozilla::dom::(anonymous namespace)::AutoCancel::SetCancelMessage<nsTString<char16_t> const&>(nsTSubstring<char> const&, nsTString<char16_t> const&)

Unexecuted instantiation: Unified_cpp_dom_serviceworkers0.cpp:void mozilla::dom::(anonymous namespace)::AutoCancel::SetCancelMessage<nsTString<char16_t> const&, NS_ConvertASCIItoUTF16&>(nsTSubstring<char> const&, nsTString<char16_t> const&, NS_ConvertASCIItoUTF16&)

Unexecuted instantiation: Unified_cpp_dom_serviceworkers0.cpp:void mozilla::dom::(anonymous namespace)::AutoCancel::SetCancelMessage<nsTString<char16_t> const&, NS_ConvertUTF8toUTF16&>(nsTSubstring<char> const&, nsTString<char16_t> const&, NS_ConvertUTF8toUTF16&)

  template<typename... Params>

  void SetCancelMessageAndLocation(const nsACString& aSourceSpec,

                                   uint32_t aLine, uint32_t aColumn,

                                   const nsACString& aMessageName,

                                   Params&&... aParams)

  {

    MOZ_ASSERT(mOwner);

    MOZ_ASSERT(mMessageName.EqualsLiteral("InterceptionFailedWithURL"));

    MOZ_ASSERT(mParams.Length() == 1);

    mSourceSpec = aSourceSpec;

    mLine = aLine;

    mColumn = aColumn;

    mMessageName = aMessageName;

    mParams.Clear();

    StringArrayAppender::Append(mParams, sizeof...(Params),

                                std::forward<Params>(aParams)...);

  }

  void Reset()

  {

    mOwner = nullptr;

  }

};

NS_IMPL_ISUPPORTS0(RespondWithHandler)

void

RespondWithHandler::ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue)

{

  AutoCancel autoCancel(this, mRequestURL);

  mInterceptedChannel->SetFinishResponseStart(TimeStamp::Now());

  if (!aValue.isObject()) {

    NS_WARNING("FetchEvent::RespondWith was passed a promise resolved to a non-Object value");

    nsCString sourceSpec;

    uint32_t line = 0;

    uint32_t column = 0;

    nsString valueString;

    nsContentUtils::ExtractErrorValues(aCx, aValue, sourceSpec, &line, &column,

                                       valueString);

    autoCancel.SetCancelMessageAndLocation(sourceSpec, line, column,

                                           NS_LITERAL_CSTRING("InterceptedNonResponseWithURL"),

                                           mRequestURL, valueString);

    return;

  }

  RefPtr<Response> response;

  nsresult rv = UNWRAP_OBJECT(Response, &aValue.toObject(), response);

  if (NS_FAILED(rv)) {

    nsCString sourceSpec;

    uint32_t line = 0;

    uint32_t column = 0;

    nsString valueString;

    nsContentUtils::ExtractErrorValues(aCx, aValue, sourceSpec, &line, &column,

                                       valueString);

    autoCancel.SetCancelMessageAndLocation(sourceSpec, line, column,

                                           NS_LITERAL_CSTRING("InterceptedNonResponseWithURL"),

                                           mRequestURL, valueString);

    return;

  }

  WorkerPrivate* worker = GetCurrentThreadWorkerPrivate();

  MOZ_ASSERT(worker);

  worker->AssertIsOnWorkerThread();

  // Section "HTTP Fetch", step 3.3:

  //  If one of the following conditions is true, return a network error:

  //    * response's type is "error".

  //    * request's mode is not "no-cors" and response's type is "opaque".

  //    * request's redirect mode is not "manual" and response's type is

  //      "opaqueredirect".

  //    * request's redirect mode is not "follow" and response's url list

  //      has more than one item.

  if (response->Type() == ResponseType::Error) {

    autoCancel.SetCancelMessage(

      NS_LITERAL_CSTRING("InterceptedErrorResponseWithURL"), mRequestURL);

    return;

  }

  MOZ_ASSERT_IF(mIsClientRequest, mRequestMode == RequestMode::Same_origin ||

                                  mRequestMode == RequestMode::Navigate);

  if (response->Type() == ResponseType::Opaque && mRequestMode != RequestMode::No_cors) {

    uint32_t mode = static_cast<uint32_t>(mRequestMode);

    NS_ConvertASCIItoUTF16 modeString(RequestModeValues::strings[mode].value,

                                      RequestModeValues::strings[mode].length);

    autoCancel.SetCancelMessage(

      NS_LITERAL_CSTRING("BadOpaqueInterceptionRequestModeWithURL"),

      mRequestURL, modeString);

    return;

  }

  if (mRequestRedirectMode != RequestRedirect::Manual &&

      response->Type() == ResponseType::Opaqueredirect) {

    autoCancel.SetCancelMessage(

      NS_LITERAL_CSTRING("BadOpaqueRedirectInterceptionWithURL"), mRequestURL);

    return;

  }

  if (mRequestRedirectMode != RequestRedirect::Follow && response->Redirected()) {

    autoCancel.SetCancelMessage(

      NS_LITERAL_CSTRING("BadRedirectModeInterceptionWithURL"), mRequestURL);

    return;

  }

  if (NS_WARN_IF(response->BodyUsed())) {

    autoCancel.SetCancelMessage(

      NS_LITERAL_CSTRING("InterceptedUsedResponseWithURL"), mRequestURL);

    return;

  }

  RefPtr<InternalResponse> ir = response->GetInternalResponse();

  if (NS_WARN_IF(!ir)) {

    return;

  }

  // An extra safety check to make sure our invariant that opaque and cors

  // responses always have a URL does not break.

  if (NS_WARN_IF((response->Type() == ResponseType::Opaque ||

                  response->Type() == ResponseType::Cors) &&

                 ir->GetUnfilteredURL().IsEmpty())) {

    MOZ_DIAGNOSTIC_ASSERT(false, "Cors or opaque Response without a URL");

    return;

  }

  Telemetry::ScalarAdd(Telemetry::ScalarID::SW_SYNTHESIZED_RES_COUNT, 1);

  if (mRequestMode == RequestMode::Same_origin &&

      response->Type() == ResponseType::Cors) {

    Telemetry::ScalarAdd(Telemetry::ScalarID::SW_CORS_RES_FOR_SO_REQ_COUNT, 1);

    // XXXtt: Will have a pref to enable the quirk response in bug 1419684.

    // The variadic template provided by StringArrayAppender requires exactly

    // an nsString.

    NS_ConvertUTF8toUTF16 responseURL(ir->GetUnfilteredURL());

    autoCancel.SetCancelMessage(

      NS_LITERAL_CSTRING("CorsResponseForSameOriginRequest"), mRequestURL,

      responseURL);

    return;

  }

  // Propagate the URL to the content if the request mode is not "navigate".

  // Note that, we only reflect the final URL if the response.redirected is

  // false. We propagate all the URLs if the response.redirected is true.

  nsCString responseURL;

  if (mRequestMode != RequestMode::Navigate) {

    responseURL = ir->GetUnfilteredURL();

    // Similar to how we apply the request fragment to redirects automatically

    // we also want to apply it automatically when propagating the response

    // URL from a service worker interception.  Currently response.url strips

    // the fragment, so this will never conflict with an existing fragment

    // on the response.  In the future we will have to check for a response

    // fragment and avoid overriding in that case.

    if (!mRequestFragment.IsEmpty() && !responseURL.IsEmpty()) {

      MOZ_ASSERT(!responseURL.Contains('#'));

      responseURL.Append(NS_LITERAL_CSTRING("#"));

      responseURL.Append(mRequestFragment);

    }

  }

  UniquePtr<RespondWithClosure> closure(new RespondWithClosure(mInterceptedChannel,

                                                               mRegistration,

                                                               mRequestURL,

                                                               mRespondWithScriptSpec,

                                                               mRespondWithLineNumber,

                                                               mRespondWithColumnNumber));

  nsCOMPtr<nsIRunnable> startRunnable = new StartResponse(mInterceptedChannel,

                                                          ir,

                                                          worker->GetChannelInfo(),

                                                          mScriptSpec,

                                                          responseURL,

                                                          std::move(closure));

  nsCOMPtr<nsIInputStream> body;

  ir->GetUnfilteredBody(getter_AddRefs(body));

  // Errors and redirects may not have a body.

  if (body) {

    ErrorResult error;

    response->SetBodyUsed(aCx, error);

    if (NS_WARN_IF(error.Failed())) {

      autoCancel.SetCancelErrorResult(aCx, error);

      return;

    }

  }

  MOZ_ALWAYS_SUCCEEDS(worker->DispatchToMainThread(startRunnable.forget()));

  MOZ_ASSERT(!closure);

  autoCancel.Reset();

  mRequestWasHandled = true;

}

void

RespondWithHandler::RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue)

{

  nsCString sourceSpec = mRespondWithScriptSpec;

  uint32_t line = mRespondWithLineNumber;

  uint32_t column = mRespondWithColumnNumber;

  nsString valueString;

  mInterceptedChannel->SetFinishResponseStart(TimeStamp::Now());

  nsContentUtils::ExtractErrorValues(aCx, aValue, sourceSpec, &line, &column,

                                     valueString);

  ::AsyncLog(mInterceptedChannel, sourceSpec, line, column,

             NS_LITERAL_CSTRING("InterceptionRejectedResponseWithURL"),

             mRequestURL, valueString);

  CancelRequest(NS_ERROR_INTERCEPTION_FAILED);

}

void

RespondWithHandler::CancelRequest(nsresult aStatus)

{

  nsCOMPtr<nsIRunnable> runnable =

    new CancelChannelRunnable(mInterceptedChannel, mRegistration, aStatus);

  // Note, this may run off the worker thread during worker termination.

  WorkerPrivate* worker = GetCurrentThreadWorkerPrivate();

  if (worker) {

    MOZ_ALWAYS_SUCCEEDS(worker->DispatchToMainThread(runnable.forget()));

  } else {

    MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable.forget()));

  }

  mRequestWasHandled = true;

}

} // namespace

void

FetchEvent::RespondWith(JSContext* aCx, Promise& aArg, ErrorResult& aRv)

{

  if (EventPhase() == Event_Binding::NONE || mWaitToRespond) {

    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);

    return;

  }

  // Record where respondWith() was called in the script so we can include the

  // information in any error reporting.  We should be guaranteed not to get

  // a file:// string here because service workers require http/https.

  nsCString spec;

  uint32_t line = 0;

  uint32_t column = 0;

  nsJSUtils::GetCallingLocation(aCx, spec, &line, &column);

  RefPtr<InternalRequest> ir = mRequest->GetInternalRequest();

  nsAutoCString requestURL;

  ir->GetURL(requestURL);

  StopImmediatePropagation();

  mWaitToRespond = true;

  RefPtr<RespondWithHandler> handler =

    new RespondWithHandler(mChannel, mRegistration, mRequest->Mode(),

                           ir->IsClientRequest(), mRequest->Redirect(),

                           mScriptSpec, NS_ConvertUTF8toUTF16(requestURL),

                           ir->GetFragment(), spec, line, column);

  aArg.AppendNativeHandler(handler);

  if (!WaitOnPromise(aArg)) {

    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);

  }

}

void

FetchEvent::PreventDefault(JSContext* aCx, CallerType aCallerType)

{

  MOZ_ASSERT(aCx);

  MOZ_ASSERT(aCallerType != CallerType::System,

             "Since when do we support system-principal service workers?");

  if (mPreventDefaultScriptSpec.IsEmpty()) {

    // Note when the FetchEvent might have been canceled by script, but don't

    // actually log the location until we are sure it matters.  This is

    // determined in ServiceWorkerPrivate.cpp.  We only remember the first

    // call to preventDefault() as its the most likely to have actually canceled

    // the event.

    nsJSUtils::GetCallingLocation(aCx, mPreventDefaultScriptSpec,

                                  &mPreventDefaultLineNumber,

                                  &mPreventDefaultColumnNumber);

  }

  Event::PreventDefault(aCx, aCallerType);

}

void

FetchEvent::ReportCanceled()

{

  MOZ_ASSERT(!mPreventDefaultScriptSpec.IsEmpty());

  RefPtr<InternalRequest> ir = mRequest->GetInternalRequest();

  nsAutoCString url;

  ir->GetURL(url);

  // The variadic template provided by StringArrayAppender requires exactly

  // an nsString.

  NS_ConvertUTF8toUTF16 requestURL(url);

  //nsString requestURL;

  //CopyUTF8toUTF16(url, requestURL);

  ::AsyncLog(mChannel.get(), mPreventDefaultScriptSpec,

             mPreventDefaultLineNumber, mPreventDefaultColumnNumber,

             NS_LITERAL_CSTRING("InterceptionCanceledWithURL"), requestURL);

}

namespace {

class WaitUntilHandler final : public PromiseNativeHandler

{

  WorkerPrivate* mWorkerPrivate;

  const nsCString mScope;

  nsCString mSourceSpec;

  uint32_t mLine;

  uint32_t mColumn;

  nsString mRejectValue;

  ~WaitUntilHandler()

  {

  }

public:

  NS_DECL_THREADSAFE_ISUPPORTS

  WaitUntilHandler(WorkerPrivate* aWorkerPrivate, JSContext* aCx)

    : mWorkerPrivate(aWorkerPrivate)

    , mScope(mWorkerPrivate->ServiceWorkerScope())

    , mLine(0)

    , mColumn(0)

  {

    mWorkerPrivate->AssertIsOnWorkerThread();

    // Save the location of the waitUntil() call itself as a fallback

    // in case the rejection value does not contain any location info.

    nsJSUtils::GetCallingLocation(aCx, mSourceSpec, &mLine, &mColumn);

  }

  void ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override

  {

    // do nothing, we are only here to report errors

  }

  void RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override

  {

    mWorkerPrivate->AssertIsOnWorkerThread();

    nsCString spec;

    uint32_t line = 0;

    uint32_t column = 0;

    nsContentUtils::ExtractErrorValues(aCx, aValue, spec, &line, &column,

                                       mRejectValue);

    // only use the extracted location if we found one

    if (!spec.IsEmpty()) {

      mSourceSpec = spec;

      mLine = line;

      mColumn = column;

    }