/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* vim: set sw=2 ts=8 et 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/. */

// HttpLog.h should generally be included first

#include "HttpLog.h"

#include "HttpBackgroundChannelParent.h"

#include "HttpChannelParent.h"

#include "mozilla/ipc/BackgroundParent.h"

#include "mozilla/IntegerPrintfMacros.h"

#include "mozilla/Unused.h"

#include "nsIBackgroundChannelRegistrar.h"

#include "nsNetCID.h"

#include "nsQueryObject.h"

#include "nsThreadUtils.h"

using mozilla::dom::ContentParent;

using mozilla::ipc::AssertIsInMainProcess;

using mozilla::ipc::AssertIsOnBackgroundThread;

using mozilla::ipc::BackgroundParent;

using mozilla::ipc::IPCResult;

using mozilla::ipc::IsOnBackgroundThread;

namespace mozilla {

namespace net {

/*

 * Helper class for continuing the AsyncOpen procedure on main thread.

 */

class ContinueAsyncOpenRunnable final : public Runnable

{

public:

  ContinueAsyncOpenRunnable(HttpBackgroundChannelParent* aActor,

                            const uint64_t& aChannelId)

    : Runnable("net::ContinueAsyncOpenRunnable")

    , mActor(aActor)

    , mChannelId(aChannelId)

  {

    AssertIsInMainProcess();

    AssertIsOnBackgroundThread();

    MOZ_ASSERT(mActor);

  }

  NS_IMETHOD Run() override

  {

    LOG(("HttpBackgroundChannelParent::ContinueAsyncOpen [this=%p channelId=%"

         PRIu64 "]\n", mActor.get(), mChannelId));

    AssertIsInMainProcess();

    MOZ_ASSERT(NS_IsMainThread());

    nsCOMPtr<nsIBackgroundChannelRegistrar> registrar =

      do_GetService(NS_BACKGROUNDCHANNELREGISTRAR_CONTRACTID);

    MOZ_ASSERT(registrar);

    registrar->LinkBackgroundChannel(mChannelId, mActor);

    return NS_OK;

  }

private:

  RefPtr<HttpBackgroundChannelParent> mActor;

  const uint64_t mChannelId;

};

HttpBackgroundChannelParent::HttpBackgroundChannelParent()

  : mIPCOpened(true)

  , mBgThreadMutex("HttpBackgroundChannelParent::BgThreadMutex")

{

  AssertIsInMainProcess();

  AssertIsOnBackgroundThread();

  {

    MutexAutoLock lock(mBgThreadMutex);

    mBackgroundThread = NS_GetCurrentThread();

  }

}

HttpBackgroundChannelParent::~HttpBackgroundChannelParent()

{

  MOZ_ASSERT(NS_IsMainThread() || IsOnBackgroundThread());

  MOZ_ASSERT(!mIPCOpened);

}

nsresult

HttpBackgroundChannelParent::Init(const uint64_t& aChannelId)

{

  LOG(("HttpBackgroundChannelParent::Init [this=%p channelId=%" PRIu64 "]\n",

       this, aChannelId));

  AssertIsInMainProcess();

  AssertIsOnBackgroundThread();

  RefPtr<ContinueAsyncOpenRunnable> runnable =

    new ContinueAsyncOpenRunnable(this, aChannelId);

  return NS_DispatchToMainThread(runnable);

}

void

HttpBackgroundChannelParent::LinkToChannel(HttpChannelParent* aChannelParent)

{

  LOG(("HttpBackgroundChannelParent::LinkToChannel [this=%p channel=%p]\n",

       this, aChannelParent));

  AssertIsInMainProcess();

  MOZ_ASSERT(NS_IsMainThread());

  if (!mIPCOpened) {

    return;

  }

  mChannelParent = aChannelParent;

}

void

HttpBackgroundChannelParent::OnChannelClosed()

{

  LOG(("HttpBackgroundChannelParent::OnChannelClosed [this=%p]\n", this));

  AssertIsInMainProcess();

  MOZ_ASSERT(NS_IsMainThread());

  if (!mIPCOpened) {

    return;

  }

  nsresult rv;

  {

    MutexAutoLock lock(mBgThreadMutex);

    RefPtr<HttpBackgroundChannelParent> self = this;

    rv = mBackgroundThread->Dispatch(

      NS_NewRunnableFunction(

        "net::HttpBackgroundChannelParent::OnChannelClosed",

        [self]() {

          LOG(("HttpBackgroundChannelParent::DeleteRunnable [this=%p]\n",

               self.get()));

          AssertIsOnBackgroundThread();

          if (!self->mIPCOpened.compareExchange(true, false)) {

            return;

          }

          Unused << self->Send__delete__(self);

        }),

      NS_DISPATCH_NORMAL);

  }

  Unused << NS_WARN_IF(NS_FAILED(rv));

}

bool

HttpBackgroundChannelParent::OnStartRequestSent()

{

  LOG(("HttpBackgroundChannelParent::OnStartRequestSent [this=%p]\n", this));

  AssertIsInMainProcess();

  if (NS_WARN_IF(!mIPCOpened)) {

    return false;

  }

  if (!IsOnBackgroundThread()) {

    MutexAutoLock lock(mBgThreadMutex);

    nsresult rv = mBackgroundThread->Dispatch(

      NewRunnableMethod("net::HttpBackgroundChannelParent::OnStartRequestSent",

                        this,

                        &HttpBackgroundChannelParent::OnStartRequestSent),

      NS_DISPATCH_NORMAL);

    MOZ_DIAGNOSTIC_ASSERT(NS_SUCCEEDED(rv));

    return NS_SUCCEEDED(rv);

  }

  return SendOnStartRequestSent();

}

bool

HttpBackgroundChannelParent::OnTransportAndData(

                                               const nsresult& aChannelStatus,

                                               const nsresult& aTransportStatus,

                                               const uint64_t& aOffset,

                                               const uint32_t& aCount,

                                               const nsCString& aData)

{

  LOG(("HttpBackgroundChannelParent::OnTransportAndData [this=%p]\n", this));

  AssertIsInMainProcess();

  if (NS_WARN_IF(!mIPCOpened)) {

    return false;

  }

  if (!IsOnBackgroundThread()) {

    MutexAutoLock lock(mBgThreadMutex);

    nsresult rv = mBackgroundThread->Dispatch(

      NewRunnableMethod<const nsresult,

                        const nsresult,

                        const uint64_t,

                        const uint32_t,

                        const nsCString>(

        "net::HttpBackgroundChannelParent::OnTransportAndData",

        this,

        &HttpBackgroundChannelParent::OnTransportAndData,

        aChannelStatus,

        aTransportStatus,

        aOffset,

        aCount,

        aData),

      NS_DISPATCH_NORMAL);

    MOZ_DIAGNOSTIC_ASSERT(NS_SUCCEEDED(rv));

    return NS_SUCCEEDED(rv);

  }

  return SendOnTransportAndData(aChannelStatus, aTransportStatus,

                                aOffset, aCount, aData);

}

bool

HttpBackgroundChannelParent::OnStopRequest(const nsresult& aChannelStatus,

                                           const ResourceTimingStruct& aTiming,

                                           const nsHttpHeaderArray& aResponseTrailers)

{

  LOG(("HttpBackgroundChannelParent::OnStopRequest [this=%p "

        "status=%" PRIx32 "]\n", this, static_cast<uint32_t>(aChannelStatus)));

  AssertIsInMainProcess();

  if (NS_WARN_IF(!mIPCOpened)) {

    return false;

  }

  if (!IsOnBackgroundThread()) {

    MutexAutoLock lock(mBgThreadMutex);

    nsresult rv = mBackgroundThread->Dispatch(

      NewRunnableMethod<const nsresult,

                        const ResourceTimingStruct,

                        const nsHttpHeaderArray>(

        "net::HttpBackgroundChannelParent::OnStopRequest",

        this,

        &HttpBackgroundChannelParent::OnStopRequest,

        aChannelStatus,

        aTiming,

        aResponseTrailers),

      NS_DISPATCH_NORMAL);

    MOZ_DIAGNOSTIC_ASSERT(NS_SUCCEEDED(rv));

    return NS_SUCCEEDED(rv);

  }

  // See the child code for why we do this.

  TimeStamp lastActTabOpt = nsHttp::GetLastActiveTabLoadOptimizationHit();

  return SendOnStopRequest(aChannelStatus, aTiming, lastActTabOpt, aResponseTrailers);

}

bool

HttpBackgroundChannelParent::OnProgress(const int64_t& aProgress,

                                        const int64_t& aProgressMax)

{

  LOG(("HttpBackgroundChannelParent::OnProgress [this=%p progress=%" PRId64

       " max=%" PRId64 "]\n", this, aProgress, aProgressMax));

  AssertIsInMainProcess();

  if (NS_WARN_IF(!mIPCOpened)) {

    return false;

  }

  if (!IsOnBackgroundThread()) {

    MutexAutoLock lock(mBgThreadMutex);

    nsresult rv = mBackgroundThread->Dispatch(

      NewRunnableMethod<const int64_t, const int64_t>(

        "net::HttpBackgroundChannelParent::OnProgress",

        this,

        &HttpBackgroundChannelParent::OnProgress,

        aProgress,

        aProgressMax),

      NS_DISPATCH_NORMAL);

    MOZ_DIAGNOSTIC_ASSERT(NS_SUCCEEDED(rv));

    return NS_SUCCEEDED(rv);

  }

  return SendOnProgress(aProgress, aProgressMax);

}

bool

HttpBackgroundChannelParent::OnStatus(const nsresult& aStatus)

{

  LOG(("HttpBackgroundChannelParent::OnStatus [this=%p stauts=%" PRIx32

       "]\n", this, static_cast<uint32_t>(aStatus)));

  AssertIsInMainProcess();

  if (NS_WARN_IF(!mIPCOpened)) {

    return false;

  }

  if (!IsOnBackgroundThread()) {

    MutexAutoLock lock(mBgThreadMutex);

    nsresult rv = mBackgroundThread->Dispatch(

      NewRunnableMethod<const nsresult>(

        "net::HttpBackgroundChannelParent::OnStatus",

        this,

        &HttpBackgroundChannelParent::OnStatus,

        aStatus),

      NS_DISPATCH_NORMAL);

    MOZ_DIAGNOSTIC_ASSERT(NS_SUCCEEDED(rv));

    return NS_SUCCEEDED(rv);

  }

  return SendOnStatus(aStatus);

}

bool

HttpBackgroundChannelParent::OnDiversion()

{

  LOG(("HttpBackgroundChannelParent::OnDiversion [this=%p]\n", this));

  AssertIsInMainProcess();

  if (NS_WARN_IF(!mIPCOpened)) {

    return false;

  }

  if (!IsOnBackgroundThread()) {

    MutexAutoLock lock(mBgThreadMutex);

    nsresult rv = mBackgroundThread->Dispatch(

      NewRunnableMethod("net::HttpBackgroundChannelParent::OnDiversion",

                        this,

                        &HttpBackgroundChannelParent::OnDiversion),

      NS_DISPATCH_NORMAL);

    MOZ_DIAGNOSTIC_ASSERT(NS_SUCCEEDED(rv));

    return NS_SUCCEEDED(rv);

  }

  if (!SendFlushedForDiversion()) {

    return false;

  }

  // The listener chain should now be setup; tell HttpChannelChild to divert

  // the OnDataAvailables and OnStopRequest to associated HttpChannelParent.

  if (!SendDivertMessages()) {

    return false;

  }

  return true;

}

bool

HttpBackgroundChannelParent::OnNotifyTrackingProtectionDisabled()

{

  LOG(("HttpBackgroundChannelParent::OnNotifyTrackingProtectionDisabled [this=%p]\n", this));

  AssertIsInMainProcess();

  if (NS_WARN_IF(!mIPCOpened)) {

    return false;

  }

  if (!IsOnBackgroundThread()) {

    MutexAutoLock lock(mBgThreadMutex);

    nsresult rv = mBackgroundThread->Dispatch(

      NewRunnableMethod(

        "net::HttpBackgroundChannelParent::OnNotifyTrackingProtectionDisabled",

        this,

        &HttpBackgroundChannelParent::OnNotifyTrackingProtectionDisabled),

      NS_DISPATCH_NORMAL);

    MOZ_DIAGNOSTIC_ASSERT(NS_SUCCEEDED(rv));

    return NS_SUCCEEDED(rv);

  }

  return SendNotifyTrackingProtectionDisabled();

}

bool

HttpBackgroundChannelParent::OnNotifyTrackingCookieBlocked(uint32_t aRejectedReason)

{

  LOG(("HttpBackgroundChannelParent::OnNotifyTrackingCookieBlocked [this=%p]\n", this));

  AssertIsInMainProcess();

  if (NS_WARN_IF(!mIPCOpened)) {

    return false;

  }

  if (!IsOnBackgroundThread()) {

    MutexAutoLock lock(mBgThreadMutex);

    RefPtr<HttpBackgroundChannelParent> self = this;

    nsresult rv = mBackgroundThread->Dispatch(

      NS_NewRunnableFunction(

        "net::HttpBackgroundChannelParent::OnNotifyTrackingCookieBlocked",

        [self, aRejectedReason]() {

          self->OnNotifyTrackingCookieBlocked(aRejectedReason);

        }),

      NS_DISPATCH_NORMAL);

    MOZ_DIAGNOSTIC_ASSERT(NS_SUCCEEDED(rv));

    return NS_SUCCEEDED(rv);

  }

  return SendNotifyTrackingCookieBlocked(aRejectedReason);

}

bool

HttpBackgroundChannelParent::OnNotifyTrackingResource(bool aIsThirdParty)

{

  LOG(("HttpBackgroundChannelParent::OnNotifyTrackingResource thirdparty=%d "

       "[this=%p]\n", static_cast<int>(aIsThirdParty), this));

  AssertIsInMainProcess();

  if (NS_WARN_IF(!mIPCOpened)) {

    return false;

  }

  if (!IsOnBackgroundThread()) {

    MutexAutoLock lock(mBgThreadMutex);

    nsresult rv = mBackgroundThread->Dispatch(

      NewRunnableMethod<bool>(

        "net::HttpBackgroundChannelParent::OnNotifyTrackingResource",

        this,

        &HttpBackgroundChannelParent::OnNotifyTrackingResource,

        aIsThirdParty),

      NS_DISPATCH_NORMAL);

    MOZ_DIAGNOSTIC_ASSERT(NS_SUCCEEDED(rv));

    return NS_SUCCEEDED(rv);

  }

  return SendNotifyTrackingResource(aIsThirdParty);

}

bool

HttpBackgroundChannelParent::OnSetClassifierMatchedInfo(const nsACString& aList,

                                                        const nsACString& aProvider,

                                                        const nsACString& aFullHash)

{

  LOG(("HttpBackgroundChannelParent::OnSetClassifierMatchedInfo [this=%p]\n", this));

  AssertIsInMainProcess();

  if (NS_WARN_IF(!mIPCOpened)) {

    return false;

  }

  if (!IsOnBackgroundThread()) {

    MutexAutoLock lock(mBgThreadMutex);

    nsresult rv = mBackgroundThread->Dispatch(

      NewRunnableMethod<const nsCString, const nsCString, const nsCString>(

        "net::HttpBackgroundChannelParent::OnSetClassifierMatchedInfo",

        this,

        &HttpBackgroundChannelParent::OnSetClassifierMatchedInfo,

        aList,

        aProvider,

        aFullHash),

      NS_DISPATCH_NORMAL);

    MOZ_DIAGNOSTIC_ASSERT(NS_SUCCEEDED(rv));

    return NS_SUCCEEDED(rv);

  }

  ClassifierInfo info;

  info.list() = aList;

  info.fullhash() = aFullHash;

  info.provider() = aProvider;

  return SendSetClassifierMatchedInfo(info);

}

void

HttpBackgroundChannelParent::ActorDestroy(ActorDestroyReason aWhy)

{

  LOG(("HttpBackgroundChannelParent::ActorDestroy [this=%p]\n", this));

  AssertIsInMainProcess();

  AssertIsOnBackgroundThread();

  mIPCOpened = false;

  RefPtr<HttpBackgroundChannelParent> self = this;

  DebugOnly<nsresult> rv = NS_DispatchToMainThread(NS_NewRunnableFunction(

    "net::HttpBackgroundChannelParent::ActorDestroy", [self]() {

      MOZ_ASSERT(NS_IsMainThread());

      RefPtr<HttpChannelParent> channelParent =

        self->mChannelParent.forget();

      if (channelParent) {

        channelParent->OnBackgroundParentDestroyed();

      }

    }));

  MOZ_ASSERT(NS_SUCCEEDED(rv));

}

} // namespace net

} // namespace mozilla