/* -*- 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/. */

#include "mozilla/net/NeckoChild.h"

#include "mozilla/net/ChannelDiverterChild.h"

#include "mozilla/net/FTPChannelChild.h"

#include "mozilla/dom/ContentChild.h"

#include "mozilla/dom/DocGroup.h"

#include "mozilla/dom/TabChild.h"

#include "nsContentUtils.h"

#include "nsFtpProtocolHandler.h"

#include "nsITabChild.h"

#include "nsStringStream.h"

#include "nsNetUtil.h"

#include "base/compiler_specific.h"

#include "mozilla/ipc/IPCStreamUtils.h"

#include "mozilla/ipc/URIUtils.h"

#include "SerializedLoadContext.h"

#include "mozilla/ipc/BackgroundUtils.h"

#include "nsIPrompt.h"

#include "nsIURIMutator.h"

using mozilla::dom::ContentChild;

using namespace mozilla::ipc;

#undef LOG

#define LOG(args) MOZ_LOG(gFTPLog, mozilla::LogLevel::Debug, args)

namespace mozilla {

namespace net {

FTPChannelChild::FTPChannelChild(nsIURI* uri)

: mIPCOpen(false)

, mUnknownDecoderInvolved(false)

, mCanceled(false)

, mSuspendCount(0)

, mIsPending(false)

, mLastModifiedTime(0)

, mStartPos(0)

, mDivertingToParent(false)

, mFlushedForDiversion(false)

, mSuspendSent(false)

{

  LOG(("Creating FTPChannelChild @%p\n", this));

  // grab a reference to the handler to ensure that it doesn't go away.

  NS_ADDREF(gFtpHandler);

  SetURI(uri);

  mEventQ = new ChannelEventQueue(static_cast<nsIFTPChannel*>(this));

  // We could support thread retargeting, but as long as we're being driven by

  // IPDL on the main thread it doesn't buy us anything.

  DisallowThreadRetargeting();

}

FTPChannelChild::~FTPChannelChild()

{

  LOG(("Destroying FTPChannelChild @%p\n", this));

  gFtpHandler->Release();

}

void

FTPChannelChild::AddIPDLReference()

{

  MOZ_ASSERT(!mIPCOpen, "Attempt to retain more than one IPDL reference");

  mIPCOpen = true;

  AddRef();

}

void

FTPChannelChild::ReleaseIPDLReference()

{

  MOZ_ASSERT(mIPCOpen, "Attempt to release nonexistent IPDL reference");

  mIPCOpen = false;

  Release();

}

//-----------------------------------------------------------------------------

// FTPChannelChild::nsISupports

//-----------------------------------------------------------------------------

NS_IMPL_ISUPPORTS_INHERITED(FTPChannelChild,

                            nsBaseChannel,

                            nsIFTPChannel,

                            nsIUploadChannel,

                            nsIResumableChannel,

                            nsIProxiedChannel,

                            nsIChildChannel,

                            nsIDivertableChannel)

//-----------------------------------------------------------------------------

NS_IMETHODIMP

FTPChannelChild::GetLastModifiedTime(PRTime* lastModifiedTime)

{

  *lastModifiedTime = mLastModifiedTime;

  return NS_OK;

}

NS_IMETHODIMP

FTPChannelChild::SetLastModifiedTime(PRTime lastModifiedTime)

{

  return NS_ERROR_NOT_AVAILABLE;

}

NS_IMETHODIMP

FTPChannelChild::ResumeAt(uint64_t aStartPos, const nsACString& aEntityID)

{

  NS_ENSURE_TRUE(!mIsPending, NS_ERROR_IN_PROGRESS);

  mStartPos = aStartPos;

  mEntityID = aEntityID;

  return NS_OK;

}

NS_IMETHODIMP

FTPChannelChild::GetEntityID(nsACString& entityID)

{

  entityID = mEntityID;

  return NS_OK;

}

NS_IMETHODIMP

FTPChannelChild::GetProxyInfo(nsIProxyInfo** aProxyInfo)

{

  DROP_DEAD();

}

NS_IMETHODIMP

FTPChannelChild::SetUploadStream(nsIInputStream* stream,

                                 const nsACString& contentType,

                                 int64_t contentLength)

{

  NS_ENSURE_TRUE(!mIsPending, NS_ERROR_IN_PROGRESS);

  mUploadStream = stream;

  // NOTE: contentLength is intentionally ignored here.

  return NS_OK;

}

NS_IMETHODIMP

FTPChannelChild::GetUploadStream(nsIInputStream** stream)

{

  NS_ENSURE_ARG_POINTER(stream);

  *stream = mUploadStream;

  NS_IF_ADDREF(*stream);

  return NS_OK;

}

NS_IMETHODIMP

FTPChannelChild::AsyncOpen(::nsIStreamListener* listener, nsISupports* aContext)

{

  LOG(("FTPChannelChild::AsyncOpen [this=%p]\n", this));

  NS_ENSURE_TRUE((gNeckoChild), NS_ERROR_FAILURE);

  NS_ENSURE_TRUE(!static_cast<ContentChild*>(gNeckoChild->Manager())->

                   IsShuttingDown(), NS_ERROR_FAILURE);

  NS_ENSURE_ARG_POINTER(listener);

  NS_ENSURE_TRUE(!mIsPending, NS_ERROR_IN_PROGRESS);

  NS_ENSURE_TRUE(!mWasOpened, NS_ERROR_ALREADY_OPENED);

  // Port checked in parent, but duplicate here so we can return with error

  // immediately, as we've done since before e10s.

  nsresult rv;

  rv = NS_CheckPortSafety(nsBaseChannel::URI()); // Need to disambiguate,

                                                 // because in the child ipdl,

                                                 // a typedef URI is defined...

  if (NS_FAILED(rv))

    return rv;

  mozilla::dom::TabChild* tabChild = nullptr;

  nsCOMPtr<nsITabChild> iTabChild;

  NS_QueryNotificationCallbacks(mCallbacks, mLoadGroup,

                                NS_GET_IID(nsITabChild),

                                getter_AddRefs(iTabChild));

  GetCallback(iTabChild);

  if (iTabChild) {

    tabChild = static_cast<mozilla::dom::TabChild*>(iTabChild.get());

  }

  if (MissingRequiredTabChild(tabChild, "ftp")) {

    return NS_ERROR_ILLEGAL_VALUE;

  }

  mListener = listener;

  mListenerContext = aContext;

  // add ourselves to the load group.

  if (mLoadGroup)

    mLoadGroup->AddRequest(this, nullptr);

  mozilla::ipc::AutoIPCStream autoStream;

  autoStream.Serialize(mUploadStream,

                       static_cast<ContentChild*>(gNeckoChild->Manager()));

  uint32_t loadFlags = 0;

  GetLoadFlags(&loadFlags);

  FTPChannelOpenArgs openArgs;

  SerializeURI(nsBaseChannel::URI(), openArgs.uri());

  openArgs.startPos() = mStartPos;

  openArgs.entityID() = mEntityID;

  openArgs.uploadStream() = autoStream.TakeOptionalValue();

  openArgs.loadFlags() = loadFlags;

  nsCOMPtr<nsILoadInfo> loadInfo;

  GetLoadInfo(getter_AddRefs(loadInfo));

  rv = mozilla::ipc::LoadInfoToLoadInfoArgs(loadInfo, &openArgs.loadInfo());

  NS_ENSURE_SUCCESS(rv, rv);

  // This must happen before the constructor message is sent.

  SetupNeckoTarget();

  gNeckoChild->

    SendPFTPChannelConstructor(this, tabChild, IPC::SerializedLoadContext(this),

                               openArgs);

  // The socket transport layer in the chrome process now has a logical ref to

  // us until OnStopRequest is called.

  AddIPDLReference();

  mIsPending = true;

  mWasOpened = true;

  return rv;

}

NS_IMETHODIMP

FTPChannelChild::IsPending(bool* result)

{

  *result = mIsPending;

  return NS_OK;

}

nsresult

FTPChannelChild::OpenContentStream(bool async,

                                   nsIInputStream** stream,

                                   nsIChannel** channel)

{

  MOZ_CRASH("FTPChannel*Child* should never have OpenContentStream called!");

  return NS_OK;

}

//-----------------------------------------------------------------------------

// FTPChannelChild::PFTPChannelChild

//-----------------------------------------------------------------------------

class FTPStartRequestEvent : public NeckoTargetChannelEvent<FTPChannelChild>

{

public:

  FTPStartRequestEvent(FTPChannelChild* aChild,

                       const nsresult& aChannelStatus,

                       const int64_t& aContentLength,

                       const nsCString& aContentType,

                       const PRTime& aLastModified,

                       const nsCString& aEntityID,

                       const URIParams& aURI)

    : NeckoTargetChannelEvent<FTPChannelChild>(aChild)

    , mChannelStatus(aChannelStatus)

    , mContentLength(aContentLength)

    , mContentType(aContentType)

    , mLastModified(aLastModified)

    , mEntityID(aEntityID)

    , mURI(aURI)

  {

  }

  void Run() override

  {

    mChild->DoOnStartRequest(mChannelStatus, mContentLength, mContentType,

                             mLastModified, mEntityID, mURI);

  }

private:

  nsresult mChannelStatus;

  int64_t mContentLength;

  nsCString mContentType;

  PRTime mLastModified;

  nsCString mEntityID;

  URIParams mURI;

};

mozilla::ipc::IPCResult

FTPChannelChild::RecvOnStartRequest(const nsresult& aChannelStatus,

                                    const int64_t& aContentLength,

                                    const nsCString& aContentType,

                                    const PRTime& aLastModified,

                                    const nsCString& aEntityID,

                                    const URIParams& aURI)

{

  // mFlushedForDiversion and mDivertingToParent should NEVER be set at this

  // stage, as they are set in the listener's OnStartRequest.

  MOZ_RELEASE_ASSERT(!mFlushedForDiversion,

    "mFlushedForDiversion should be unset before OnStartRequest!");

  MOZ_RELEASE_ASSERT(!mDivertingToParent,

    "mDivertingToParent should be unset before OnStartRequest!");

  LOG(("FTPChannelChild::RecvOnStartRequest [this=%p]\n", this));

  mEventQ->RunOrEnqueue(new FTPStartRequestEvent(this, aChannelStatus,

                                                 aContentLength, aContentType,

                                                 aLastModified, aEntityID,

                                                 aURI));

  return IPC_OK();

}

void

FTPChannelChild::DoOnStartRequest(const nsresult& aChannelStatus,

                                  const int64_t& aContentLength,

                                  const nsCString& aContentType,

                                  const PRTime& aLastModified,

                                  const nsCString& aEntityID,

                                  const URIParams& aURI)

{

  mDuringOnStart = true;

  RefPtr<FTPChannelChild> self = this;

  auto clearDuringFlag = mozilla::MakeScopeExit([self] {

    self->mDuringOnStart = false;

  });

  LOG(("FTPChannelChild::DoOnStartRequest [this=%p]\n", this));

  // mFlushedForDiversion and mDivertingToParent should NEVER be set at this

  // stage, as they are set in the listener's OnStartRequest.

  MOZ_RELEASE_ASSERT(!mFlushedForDiversion,

    "mFlushedForDiversion should be unset before OnStartRequest!");

  MOZ_RELEASE_ASSERT(!mDivertingToParent,

    "mDivertingToParent should be unset before OnStartRequest!");

  if (!mCanceled && NS_SUCCEEDED(mStatus)) {

    mStatus = aChannelStatus;

  }

  mContentLength = aContentLength;

  SetContentType(aContentType);

  mLastModifiedTime = aLastModified;

  mEntityID = aEntityID;

  nsCString spec;

  nsCOMPtr<nsIURI> uri = DeserializeURI(aURI);

  nsresult rv = uri->GetSpec(spec);

  if (NS_SUCCEEDED(rv)) {

    // Changes nsBaseChannel::URI()

    rv = NS_MutateURI(mURI)

           .SetSpec(spec)

           .Finalize(mURI);

    if (NS_FAILED(rv)) {

      Cancel(rv);

    }

  } else {

    Cancel(rv);

  }

  AutoEventEnqueuer ensureSerialDispatch(mEventQ);

  rv = mListener->OnStartRequest(this, mListenerContext);

  if (NS_FAILED(rv))

    Cancel(rv);

  if (mDivertingToParent) {

    mListener = nullptr;

    mListenerContext = nullptr;

    if (mLoadGroup) {

      mLoadGroup->RemoveRequest(this, nullptr, mStatus);

    }

  }

}

class FTPDataAvailableEvent : public NeckoTargetChannelEvent<FTPChannelChild>

{

public:

  FTPDataAvailableEvent(FTPChannelChild* aChild,

                        const nsresult& aChannelStatus,

                        const nsCString& aData,

                        const uint64_t& aOffset,

                        const uint32_t& aCount)

    : NeckoTargetChannelEvent<FTPChannelChild>(aChild)

    , mChannelStatus(aChannelStatus)

    , mData(aData)

    , mOffset(aOffset)

    , mCount(aCount)

  {

  }

  void Run() override

  {

    mChild->DoOnDataAvailable(mChannelStatus, mData, mOffset, mCount);

  }

private:

  nsresult mChannelStatus;

  nsCString mData;

  uint64_t mOffset;

  uint32_t mCount;

};

mozilla::ipc::IPCResult

FTPChannelChild::RecvOnDataAvailable(const nsresult& channelStatus,

                                     const nsCString& data,

                                     const uint64_t& offset,

                                     const uint32_t& count)

{

  MOZ_RELEASE_ASSERT(!mFlushedForDiversion,

                     "Should not be receiving any more callbacks from parent!");

  LOG(("FTPChannelChild::RecvOnDataAvailable [this=%p]\n", this));

  mEventQ->RunOrEnqueue(new FTPDataAvailableEvent(this, channelStatus, data,

                                                  offset, count),

                        mDivertingToParent);

  return IPC_OK();

}

class MaybeDivertOnDataFTPEvent : public NeckoTargetChannelEvent<FTPChannelChild>

{

 public:

  MaybeDivertOnDataFTPEvent(FTPChannelChild* child,

                            const nsCString& data,

                            const uint64_t& offset,

                            const uint32_t& count)

  : NeckoTargetChannelEvent<FTPChannelChild>(child)

  , mData(data)

  , mOffset(offset)

  , mCount(count) {}

  void Run() override

  {

    mChild->MaybeDivertOnData(mData, mOffset, mCount);

  }

 private:

  nsCString mData;

  uint64_t mOffset;

  uint32_t mCount;

};

void

FTPChannelChild::MaybeDivertOnData(const nsCString& data,

                                   const uint64_t& offset,

                                   const uint32_t& count)

{

  if (mDivertingToParent) {

    SendDivertOnDataAvailable(data, offset, count);

  }

}

void

FTPChannelChild::DoOnDataAvailable(const nsresult& channelStatus,

                                   const nsCString& data,

                                   const uint64_t& offset,

                                   const uint32_t& count)

{

  LOG(("FTPChannelChild::DoOnDataAvailable [this=%p]\n", this));

  if (!mCanceled && NS_SUCCEEDED(mStatus)) {

    mStatus = channelStatus;

  }

  if (mDivertingToParent) {

    MOZ_RELEASE_ASSERT(!mFlushedForDiversion,

      "Should not be processing any more callbacks from parent!");

    SendDivertOnDataAvailable(data, offset, count);

    return;

  }

  if (mCanceled)

    return;

  if (mUnknownDecoderInvolved) {

    mUnknownDecoderEventQ.AppendElement(

      MakeUnique<MaybeDivertOnDataFTPEvent>(this, data, offset, count));

  }

  // NOTE: the OnDataAvailable contract requires the client to read all the data

  // in the inputstream.  This code relies on that ('data' will go away after

  // this function).  Apparently the previous, non-e10s behavior was to actually

  // support only reading part of the data, allowing later calls to read the

  // rest.

  nsCOMPtr<nsIInputStream> stringStream;

  nsresult rv = NS_NewByteInputStream(getter_AddRefs(stringStream),

                                      data.get(),

                                      count,

                                      NS_ASSIGNMENT_DEPEND);

  if (NS_FAILED(rv)) {

    Cancel(rv);

    return;

  }

  AutoEventEnqueuer ensureSerialDispatch(mEventQ);

  rv = mListener->OnDataAvailable(this, mListenerContext,

                                  stringStream, offset, count);

  if (NS_FAILED(rv))

    Cancel(rv);

  stringStream->Close();

}

class FTPStopRequestEvent : public NeckoTargetChannelEvent<FTPChannelChild>

{

public:

  FTPStopRequestEvent(FTPChannelChild* aChild,

                      const nsresult& aChannelStatus,

                      const nsCString &aErrorMsg,

                      bool aUseUTF8)

    : NeckoTargetChannelEvent<FTPChannelChild>(aChild)

    , mChannelStatus(aChannelStatus)

    , mErrorMsg(aErrorMsg)

    , mUseUTF8(aUseUTF8)

  {

  }

  void Run() override

  {

    mChild->DoOnStopRequest(mChannelStatus, mErrorMsg, mUseUTF8);

  }

private:

  nsresult mChannelStatus;

  nsCString mErrorMsg;

  bool mUseUTF8;

};

mozilla::ipc::IPCResult

FTPChannelChild::RecvOnStopRequest(const nsresult& aChannelStatus,

                                   const nsCString &aErrorMsg,

                                   const bool &aUseUTF8)

{

  MOZ_RELEASE_ASSERT(!mFlushedForDiversion,

    "Should not be receiving any more callbacks from parent!");

  LOG(("FTPChannelChild::RecvOnStopRequest [this=%p status=%" PRIx32"]\n",

       this, static_cast<uint32_t>(aChannelStatus)));

  mEventQ->RunOrEnqueue(new FTPStopRequestEvent(this, aChannelStatus, aErrorMsg,

                                                aUseUTF8));

  return IPC_OK();

}

class nsFtpChildAsyncAlert : public Runnable

{

public:

  nsFtpChildAsyncAlert(nsIPrompt *aPrompter, nsString aResponseMsg)

    : Runnable("nsFtpChildAsyncAlert")

    , mPrompter(aPrompter)

    , mResponseMsg(std::move(aResponseMsg))

  {

  }

protected:

  virtual ~nsFtpChildAsyncAlert() = default;

public:

  NS_IMETHOD Run() override

  {

    if (mPrompter) {

      mPrompter->Alert(nullptr, mResponseMsg.get());

    }

    return NS_OK;

  }

private:

  nsCOMPtr<nsIPrompt> mPrompter;

  nsString mResponseMsg;

};

class MaybeDivertOnStopFTPEvent : public NeckoTargetChannelEvent<FTPChannelChild>

{

 public:

  MaybeDivertOnStopFTPEvent(FTPChannelChild* child,

                            const nsresult& aChannelStatus)

  : NeckoTargetChannelEvent<FTPChannelChild>(child)

  , mChannelStatus(aChannelStatus) {}

  void Run() override

  {

    mChild->MaybeDivertOnStop(mChannelStatus);

  }

 private:

  nsresult mChannelStatus;

};

void

FTPChannelChild::MaybeDivertOnStop(const nsresult& aChannelStatus)

{

  if (mDivertingToParent) {

    SendDivertOnStopRequest(aChannelStatus);

  }

}

void

FTPChannelChild::DoOnStopRequest(const nsresult& aChannelStatus,

                                 const nsCString &aErrorMsg,

                                 bool aUseUTF8)

{

  LOG(("FTPChannelChild::DoOnStopRequest [this=%p status=%" PRIx32 "]\n",

       this, static_cast<uint32_t>(aChannelStatus)));

  if (mDivertingToParent) {

    MOZ_RELEASE_ASSERT(!mFlushedForDiversion,

      "Should not be processing any more callbacks from parent!");

    SendDivertOnStopRequest(aChannelStatus);

    return;

  }

  if (!mCanceled)

    mStatus = aChannelStatus;

  if (mUnknownDecoderInvolved) {

    mUnknownDecoderEventQ.AppendElement(

      MakeUnique<MaybeDivertOnStopFTPEvent>(this, aChannelStatus));

  }

  { // Ensure that all queued ipdl events are dispatched before

    // we initiate protocol deletion below.

    mIsPending = false;

    AutoEventEnqueuer ensureSerialDispatch(mEventQ);

    (void)mListener->OnStopRequest(this, mListenerContext, aChannelStatus);

    if (NS_FAILED(aChannelStatus) && !aErrorMsg.IsEmpty()) {

      nsCOMPtr<nsIPrompt> prompter;

      GetCallback(prompter);

      if (prompter) {

        nsCOMPtr<nsIRunnable> alertEvent;

        if (aUseUTF8) {

          alertEvent = new nsFtpChildAsyncAlert(prompter,

                             NS_ConvertUTF8toUTF16(aErrorMsg));

        } else {

          alertEvent = new nsFtpChildAsyncAlert(prompter,

                             NS_ConvertASCIItoUTF16(aErrorMsg));

        }

        Dispatch(alertEvent.forget());

      }

    }

    mListener = nullptr;

    mListenerContext = nullptr;

    if (mLoadGroup)

      mLoadGroup->RemoveRequest(this, nullptr, aChannelStatus);

  }

  // This calls NeckoChild::DeallocPFTPChannelChild(), which deletes |this| if IPDL

  // holds the last reference.  Don't rely on |this| existing after here!

  Send__delete__(this);

}

class FTPFailedAsyncOpenEvent : public NeckoTargetChannelEvent<FTPChannelChild>

{

 public:

  FTPFailedAsyncOpenEvent(FTPChannelChild* aChild, nsresult aStatus)

  : NeckoTargetChannelEvent<FTPChannelChild>(aChild)

  , mStatus(aStatus) {}

  void Run() override { mChild->DoFailedAsyncOpen(mStatus); }

 private:

  nsresult mStatus;

};

mozilla::ipc::IPCResult

FTPChannelChild::RecvFailedAsyncOpen(const nsresult& statusCode)

{

  LOG(("FTPChannelChild::RecvFailedAsyncOpen [this=%p status=%" PRIx32 "]\n",

       this, static_cast<uint32_t>(statusCode)));

  mEventQ->RunOrEnqueue(new FTPFailedAsyncOpenEvent(this, statusCode));

  return IPC_OK();

}

void

FTPChannelChild::DoFailedAsyncOpen(const nsresult& statusCode)

{

  LOG(("FTPChannelChild::DoFailedAsyncOpen [this=%p status=%" PRIx32 "]\n",

       this, static_cast<uint32_t>(statusCode)));

  mStatus = statusCode;

  if (mLoadGroup)

    mLoadGroup->RemoveRequest(this, nullptr, statusCode);

  if (mListener) {

    mListener->OnStartRequest(this, mListenerContext);

    mIsPending = false;

    mListener->OnStopRequest(this, mListenerContext, statusCode);

  } else {

    mIsPending = false;

  }

  mListener = nullptr;

  mListenerContext = nullptr;

  if (mIPCOpen)

    Send__delete__(this);

}

class FTPFlushedForDiversionEvent : public NeckoTargetChannelEvent<FTPChannelChild>

{

 public:

  explicit FTPFlushedForDiversionEvent(FTPChannelChild* aChild)

  : NeckoTargetChannelEvent<FTPChannelChild>(aChild)

  {

    MOZ_RELEASE_ASSERT(aChild);

  }

  void Run() override

  {

    mChild->FlushedForDiversion();

  }

};

mozilla::ipc::IPCResult

FTPChannelChild::RecvFlushedForDiversion()

{

  LOG(("FTPChannelChild::RecvFlushedForDiversion [this=%p]\n", this));

  MOZ_ASSERT(mDivertingToParent);

  mEventQ->RunOrEnqueue(new FTPFlushedForDiversionEvent(this), true);

  return IPC_OK();

}

void

FTPChannelChild::FlushedForDiversion()

{

  LOG(("FTPChannelChild::FlushedForDiversion [this=%p]\n", this));

  MOZ_RELEASE_ASSERT(mDivertingToParent);

  // Once this is set, it should not be unset before FTPChannelChild is taken

  // down. After it is set, no OnStart/OnData/OnStop callbacks should be

  // received from the parent channel, nor dequeued from the ChannelEventQueue.

  mFlushedForDiversion = true;

  SendDivertComplete();

}

mozilla::ipc::IPCResult

FTPChannelChild::RecvDivertMessages()

{

  LOG(("FTPChannelChild::RecvDivertMessages [this=%p]\n", this));

  MOZ_RELEASE_ASSERT(mDivertingToParent);

  MOZ_RELEASE_ASSERT(mSuspendCount > 0);

  // DivertTo() has been called on parent, so we can now start sending queued

  // IPDL messages back to parent listener.

  if (NS_WARN_IF(NS_FAILED(Resume()))) {

    return IPC_FAIL_NO_REASON(this);

  }

  return IPC_OK();

}

class FTPDeleteSelfEvent : public NeckoTargetChannelEvent<FTPChannelChild>

{

 public:

  explicit FTPDeleteSelfEvent(FTPChannelChild* aChild)

  : NeckoTargetChannelEvent<FTPChannelChild>(aChild) {}

  void Run() override { mChild->DoDeleteSelf(); }

};

mozilla::ipc::IPCResult

FTPChannelChild::RecvDeleteSelf()

{

  mEventQ->RunOrEnqueue(new FTPDeleteSelfEvent(this));

  return IPC_OK();

}

void

FTPChannelChild::DoDeleteSelf()

{

  if (mIPCOpen)

    Send__delete__(this);

}

NS_IMETHODIMP

FTPChannelChild::Cancel(nsresult status)

{

  LOG(("FTPChannelChild::Cancel [this=%p]\n", this));

  if (mCanceled)

    return NS_OK;

  mCanceled = true;

  mStatus = status;

  if (mIPCOpen)

    SendCancel(status);

  return NS_OK;

}

NS_IMETHODIMP

FTPChannelChild::Suspend()

{

  NS_ENSURE_TRUE(mIPCOpen, NS_ERROR_NOT_AVAILABLE);

  LOG(("FTPChannelChild::Suspend [this=%p]\n", this));

  // SendSuspend only once, when suspend goes from 0 to 1.

  // Don't SendSuspend at all if we're diverting callbacks to the parent;

  // suspend will be called at the correct time in the parent itself.

  if (!mSuspendCount++ && !mDivertingToParent) {

    SendSuspend();

    mSuspendSent = true;

  }

  mEventQ->Suspend();

  return NS_OK;

}

NS_IMETHODIMP

FTPChannelChild::Resume()

{

  NS_ENSURE_TRUE(mIPCOpen, NS_ERROR_NOT_AVAILABLE);

  LOG(("FTPChannelChild::Resume [this=%p]\n", this));

  // SendResume only once, when suspend count drops to 0.

  // Don't SendResume at all if we're diverting callbacks to the parent (unless

  // suspend was sent earlier); otherwise, resume will be called at the correct

  // time in the parent itself.

  if (!--mSuspendCount && (!mDivertingToParent || mSuspendSent)) {

    SendResume();

  }

  mEventQ->Resume();

  return NS_OK;

}

//-----------------------------------------------------------------------------

// FTPChannelChild::nsIChildChannel

//-----------------------------------------------------------------------------

NS_IMETHODIMP

FTPChannelChild::ConnectParent(uint32_t id)

{

  NS_ENSURE_TRUE((gNeckoChild), NS_ERROR_FAILURE);

  NS_ENSURE_TRUE(!static_cast<ContentChild*>(gNeckoChild->Manager())->

                   IsShuttingDown(), NS_ERROR_FAILURE);

  LOG(("FTPChannelChild::ConnectParent [this=%p]\n", this));

  mozilla::dom::TabChild* tabChild = nullptr;

  nsCOMPtr<nsITabChild> iTabChild;

  NS_QueryNotificationCallbacks(mCallbacks, mLoadGroup,

                                NS_GET_IID(nsITabChild),

                                getter_AddRefs(iTabChild));

  GetCallback(iTabChild);

  if (iTabChild) {

    tabChild = static_cast<mozilla::dom::TabChild*>(iTabChild.get());

  }

  // This must happen before the constructor message is sent.

  SetupNeckoTarget();

  // The socket transport in the chrome process now holds a logical ref to us

  // until OnStopRequest, or we do a redirect, or we hit an IPDL error.

  AddIPDLReference();

  FTPChannelConnectArgs connectArgs(id);

  if (!gNeckoChild->SendPFTPChannelConstructor(this, tabChild,

                                               IPC::SerializedLoadContext(this),

                                               connectArgs)) {

    return NS_ERROR_FAILURE;

  }

  return NS_OK;

}

NS_IMETHODIMP

FTPChannelChild::CompleteRedirectSetup(nsIStreamListener *listener,

                                       nsISupports *aContext)

{

  LOG(("FTPChannelChild::CompleteRedirectSetup [this=%p]\n", this));

  NS_ENSURE_TRUE(!mIsPending, NS_ERROR_IN_PROGRESS);

  NS_ENSURE_TRUE(!mWasOpened, NS_ERROR_ALREADY_OPENED);

  mIsPending = true;

  mWasOpened = true;

  mListener = listener;

  mListenerContext = aContext;

  // add ourselves to the load group.

  if (mLoadGroup)

    mLoadGroup->AddRequest(this, nullptr);

  // We already have an open IPDL connection to the parent. If on-modify-request

  // listeners or load group observers canceled us, let the parent handle it

  // and send it back to us naturally.

  return NS_OK;

}

//-----------------------------------------------------------------------------

// FTPChannelChild::nsIDivertableChannel

//-----------------------------------------------------------------------------

NS_IMETHODIMP

FTPChannelChild::DivertToParent(ChannelDiverterChild **aChild)

{

  MOZ_RELEASE_ASSERT(aChild);

  MOZ_RELEASE_ASSERT(gNeckoChild);

  MOZ_RELEASE_ASSERT(!mDivertingToParent);

  NS_ENSURE_TRUE(!static_cast<ContentChild*>(gNeckoChild->Manager())->

                   IsShuttingDown(), NS_ERROR_FAILURE);

  LOG(("FTPChannelChild::DivertToParent [this=%p]\n", this));

  // This method should only be called during OnStartRequest.

  if (!mDuringOnStart) {

    return NS_ERROR_NOT_AVAILABLE;

  }

  // We must fail DivertToParent() if there's no parent end of the channel (and

  // won't be!) due to early failure.

  if (NS_FAILED(mStatus) && !mIPCOpen) {

    return mStatus;

  }

  nsresult rv = Suspend();

  if (NS_WARN_IF(NS_FAILED(rv))) {

    return rv;

  }

  // Once this is set, it should not be unset before the child is taken down.

  mDivertingToParent = true;

  PChannelDiverterChild* diverter =

    gNeckoChild->SendPChannelDiverterConstructor(this);

  MOZ_RELEASE_ASSERT(diverter);

  *aChild = static_cast<ChannelDiverterChild*>(diverter);

  return NS_OK;

}