mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
gecko-dev/netwerk/protocol/ftp/FTPChannelChild.cpp

867 строки
26 KiB
C++
Исходник Ответственный История

/* -*- 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;
}
NS_IMETHODIMP
FTPChannelChild::UnknownDecoderInvolvedKeepData() {
mUnknownDecoderInvolved = true;
return NS_OK;
}
NS_IMETHODIMP
FTPChannelChild::UnknownDecoderInvolvedOnStartRequestCalled() {
mUnknownDecoderInvolved = false;
nsresult rv = NS_OK;
if (mDivertingToParent) {
rv = mEventQ->PrependEvents(mUnknownDecoderEventQ);
}
mUnknownDecoderEventQ.Clear();
return rv;
}
NS_IMETHODIMP
FTPChannelChild::GetDivertingToParent(bool* aDiverting) {
NS_ENSURE_ARG_POINTER(aDiverting);
*aDiverting = mDivertingToParent;
return NS_OK;
}
void FTPChannelChild::SetupNeckoTarget() {
if (mNeckoTarget) {
return;
}
nsCOMPtr<nsILoadInfo> loadInfo;
GetLoadInfo(getter_AddRefs(loadInfo));
mNeckoTarget =
nsContentUtils::GetEventTargetByLoadInfo(loadInfo, TaskCategory::Network);
if (!mNeckoTarget) {
return;
}
gNeckoChild->SetEventTargetForActor(this, mNeckoTarget);
}
} // namespace net
} // namespace mozilla
Ссылка в новой задаче Показать git blame Копировать постоянную ссылку