Bug 1320744 - Part 3, implement nsIThreadRetargetableRequest in HttpChannelChild. r=mayhemer
MozReview-Commit-ID: FyLXlkQde3h
--- a/netwerk/protocol/http/HttpBaseChannel.cpp
+++ b/netwerk/protocol/http/HttpBaseChannel.cpp
@@ -145,25 +145,25 @@ private:
}
nsCOMPtr<nsIHttpChannel> mChannel;
};
NS_IMPL_ISUPPORTS(AddHeadersToChannelVisitor, nsIHttpHeaderVisitor)
HttpBaseChannel::HttpBaseChannel()
- : mStartPos(UINT64_MAX)
+ : mCanceled(false)
+ , mStartPos(UINT64_MAX)
, mStatus(NS_OK)
, mLoadFlags(LOAD_NORMAL)
, mCaps(0)
, mClassOfService(0)
, mPriority(PRIORITY_NORMAL)
, mRedirectionLimit(gHttpHandler->RedirectionLimit())
, mApplyConversion(true)
- , mCanceled(false)
, mIsPending(false)
, mWasOpened(false)
, mRequestObserversCalled(false)
, mResponseHeadersModified(false)
, mAllowSTS(true)
, mThirdPartyFlags(0)
, mUploadStreamHasHeaders(false)
, mInheritApplicationCache(true)
--- a/netwerk/protocol/http/HttpBaseChannel.h
+++ b/netwerk/protocol/http/HttpBaseChannel.h
@@ -3,16 +3,17 @@
/* 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/. */
#ifndef mozilla_net_HttpBaseChannel_h
#define mozilla_net_HttpBaseChannel_h
+#include "mozilla/Atomics.h"
#include "nsHttp.h"
#include "nsAutoPtr.h"
#include "nsHashPropertyBag.h"
#include "nsProxyInfo.h"
#include "nsHttpRequestHead.h"
#include "nsHttpResponseHead.h"
#include "nsHttpConnectionInfo.h"
#include "nsIConsoleReportCollector.h"
@@ -440,16 +441,20 @@ protected:
nsCOMPtr<nsIPrincipal> mPrincipal;
nsCOMPtr<nsIURI> mTopWindowURI;
private:
// Proxy release all members above on main thread.
void ReleaseMainThreadOnlyReferences();
protected:
+ // Use Release-Acquire ordering to ensure the OMT ODA is ignored while channel
+ // is canceled on main thread.
+ Atomic<bool, ReleaseAcquire> mCanceled;
+
nsTArray<Pair<nsString, nsString>> mSecurityConsoleMessages;
nsCOMPtr<nsIStreamListener> mListener;
nsCOMPtr<nsISupports> mListenerContext;
nsCOMPtr<nsISupports> mOwner;
// An instance of nsHTTPCompressConv
nsCOMPtr<nsIStreamListener> mCompressListener;
@@ -483,17 +488,16 @@ protected:
nsresult mStatus;
uint32_t mLoadFlags;
uint32_t mCaps;
uint32_t mClassOfService;
int16_t mPriority;
uint8_t mRedirectionLimit;
uint32_t mApplyConversion : 1;
- uint32_t mCanceled : 1;
uint32_t mIsPending : 1;
uint32_t mWasOpened : 1;
// if 1 all "http-on-{opening|modify|etc}-request" observers have been called
uint32_t mRequestObserversCalled : 1;
uint32_t mResponseHeadersModified : 1;
uint32_t mAllowSTS : 1;
uint32_t mThirdPartyFlags : 3;
uint32_t mUploadStreamHasHeaders : 1;
--- a/netwerk/protocol/http/HttpChannelChild.cpp
+++ b/netwerk/protocol/http/HttpChannelChild.cpp
@@ -15,16 +15,17 @@
#include "mozilla/dom/DocGroup.h"
#include "mozilla/dom/TabChild.h"
#include "mozilla/dom/TabGroup.h"
#include "mozilla/ipc/FileDescriptorSetChild.h"
#include "mozilla/ipc/IPCStreamUtils.h"
#include "mozilla/net/NeckoChild.h"
#include "mozilla/net/HttpChannelChild.h"
+#include "nsCOMPtr.h"
#include "nsISupportsPrimitives.h"
#include "nsChannelClassifier.h"
#include "nsGlobalWindow.h"
#include "nsStringStream.h"
#include "nsHttpHandler.h"
#include "nsNetUtil.h"
#include "nsSerializationHelper.h"
#include "mozilla/Attributes.h"
@@ -37,18 +38,21 @@
#include "SerializedLoadContext.h"
#include "nsInputStreamPump.h"
#include "InterceptedChannel.h"
#include "mozIThirdPartyUtil.h"
#include "nsContentSecurityManager.h"
#include "nsIDeprecationWarner.h"
#include "nsICompressConvStats.h"
#include "nsIDocument.h"
+#include "nsIDOMDocument.h"
#include "nsIDOMWindowUtils.h"
+#include "nsIEventTarget.h"
#include "nsStreamUtils.h"
+#include "nsThreadUtils.h"
#ifdef OS_POSIX
#include "chrome/common/file_descriptor_set_posix.h"
#endif
#ifdef MOZ_TASK_TRACER
#include "GeckoTaskTracer.h"
#endif
@@ -256,16 +260,17 @@ NS_INTERFACE_MAP_BEGIN(HttpChannelChild)
NS_INTERFACE_MAP_ENTRY(nsITraceableChannel)
NS_INTERFACE_MAP_ENTRY(nsIApplicationCacheContainer)
NS_INTERFACE_MAP_ENTRY(nsIApplicationCacheChannel)
NS_INTERFACE_MAP_ENTRY(nsIAsyncVerifyRedirectCallback)
NS_INTERFACE_MAP_ENTRY(nsIChildChannel)
NS_INTERFACE_MAP_ENTRY(nsIHttpChannelChild)
NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAssociatedContentSecurity, GetAssociatedContentSecurity())
NS_INTERFACE_MAP_ENTRY(nsIDivertableChannel)
+ NS_INTERFACE_MAP_ENTRY(nsIThreadRetargetableRequest)
NS_INTERFACE_MAP_END_INHERITING(HttpBaseChannel)
//-----------------------------------------------------------------------------
// HttpChannelChild::PHttpChannelChild
//-----------------------------------------------------------------------------
void
HttpChannelChild::AddIPDLReference()
@@ -640,17 +645,17 @@ class TransportAndDataEvent : public Cha
{
mChild->OnTransportAndData(mChannelStatus, mTransportStatus,
mOffset, mCount, mData);
}
already_AddRefed<nsIEventTarget> GetEventTarget()
{
MOZ_ASSERT(mChild);
- nsCOMPtr<nsIEventTarget> target = mChild->GetNeckoTarget();
+ nsCOMPtr<nsIEventTarget> target = mChild->GetODATarget();
return target.forget();
}
private:
HttpChannelChild* mChild;
nsresult mChannelStatus;
nsresult mTransportStatus;
nsCString mData;
uint64_t mOffset;
@@ -748,21 +753,37 @@ HttpChannelChild::OnTransportAndData(con
mUnknownDecoderEventQ.AppendElement(
MakeUnique<MaybeDivertOnDataHttpEvent>(this, data, offset, count));
}
// Hold queue lock throughout all three calls, else we might process a later
// necko msg in between them.
AutoEventEnqueuer ensureSerialDispatch(mEventQ);
- DoOnStatus(this, transportStatus);
-
const int64_t progressMax = mResponseHead->ContentLength();
const int64_t progress = offset + count;
- DoOnProgress(this, progress, progressMax);
+
+ // OnTransportAndData will be run on retargeted thread if applicable, however
+ // OnStatus/OnProgress event can only be fired on main thread. We need to
+ // dispatch the status/progress event handling back to main thread with the
+ // appropriate event target for networking.
+ if (NS_IsMainThread()) {
+ DoOnStatus(this, transportStatus);
+ DoOnProgress(this, progress, progressMax);
+ } else {
+ RefPtr<HttpChannelChild> self = this;
+ nsCOMPtr<nsIEventTarget> neckoTarget = GetNeckoTarget();
+ DebugOnly<nsresult> rv =
+ neckoTarget->Dispatch(
+ NS_NewRunnableFunction([self, transportStatus, progress, progressMax]() {
+ self->DoOnStatus(self, transportStatus);
+ self->DoOnProgress(self, progress, progressMax);
+ }), NS_DISPATCH_NORMAL);
+ MOZ_ASSERT(NS_SUCCEEDED(rv));
+ }
// OnDataAvailable
//
// 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.
@@ -777,16 +798,18 @@ HttpChannelChild::OnTransportAndData(con
DoOnDataAvailable(this, mListenerContext, stringStream, offset, count);
stringStream->Close();
}
void
HttpChannelChild::DoOnStatus(nsIRequest* aRequest, nsresult status)
{
LOG(("HttpChannelChild::DoOnStatus [this=%p]\n", this));
+ MOZ_ASSERT(NS_IsMainThread());
+
if (mCanceled)
return;
// cache the progress sink so we don't have to query for it each time.
if (!mProgressSink)
GetCallback(mProgressSink);
// Temporary fix for bug 1116124
@@ -810,16 +833,18 @@ HttpChannelChild::DoOnStatus(nsIRequest*
NS_ConvertUTF8toUTF16(host).get());
}
}
void
HttpChannelChild::DoOnProgress(nsIRequest* aRequest, int64_t progress, int64_t progressMax)
{
LOG(("HttpChannelChild::DoOnProgress [this=%p]\n", this));
+ MOZ_ASSERT(NS_IsMainThread());
+
if (mCanceled)
return;
// cache the progress sink so we don't have to query for it each time.
if (!mProgressSink)
GetCallback(mProgressSink);
// block status/progress after Cancel or OnStopRequest has been called,
@@ -841,17 +866,17 @@ HttpChannelChild::DoOnDataAvailable(nsIR
uint64_t offset, uint32_t count)
{
LOG(("HttpChannelChild::DoOnDataAvailable [this=%p]\n", this));
if (mCanceled)
return;
nsresult rv = mListener->OnDataAvailable(aRequest, aContext, aStream, offset, count);
if (NS_FAILED(rv)) {
- Cancel(rv);
+ CancelOnMainThread(rv);
}
}
class StopRequestEvent : public ChannelEvent
{
public:
StopRequestEvent(HttpChannelChild* child,
const nsresult& channelStatus,
@@ -924,25 +949,50 @@ HttpChannelChild::MaybeDivertOnStop(cons
}
void
HttpChannelChild::OnStopRequest(const nsresult& channelStatus,
const ResourceTimingStruct& timing)
{
LOG(("HttpChannelChild::OnStopRequest [this=%p status=%" PRIx32 "]\n",
this, static_cast<uint32_t>(channelStatus)));
+ MOZ_ASSERT(NS_IsMainThread());
if (mDivertingToParent) {
MOZ_RELEASE_ASSERT(!mFlushedForDiversion,
"Should not be processing any more callbacks from parent!");
SendDivertOnStopRequest(channelStatus);
return;
}
+ // In thread retargeting is enabled, there might be Runnable for
+ // DoOnStatus/DoOnProgress sit in the main thread event target. We need to
+ // ensure OnStopRequest is fired after that by postponing the
+ // ChannelEventQueue processing to the end of main thread event target.
+ // This workaround can be removed after bug 1338493 is complete.
+ if (mODATarget) {
+ {
+ MutexAutoLock lock(mEventTargetMutex);
+ mODATarget = nullptr;
+ }
+ mEventQ->Suspend();
+ UniquePtr<ChannelEvent> stopEvent =
+ MakeUnique<StopRequestEvent>(this, channelStatus, timing);
+ mEventQ->PrependEvent(stopEvent);
+
+ nsCOMPtr<nsIEventTarget> neckoTarget = GetNeckoTarget();
+ MOZ_ASSERT(neckoTarget);
+
+ DebugOnly<nsresult> rv = neckoTarget->Dispatch(
+ NewRunnableMethod(mEventQ, &ChannelEventQueue::Resume), NS_DISPATCH_NORMAL);
+ MOZ_ASSERT(NS_SUCCEEDED(rv));
+ return;
+ }
+
if (mUnknownDecoderInvolved) {
LOG(("UnknownDecoder is involved queue OnStopRequest call. [this=%p]",
this));
mUnknownDecoderEventQ.AppendElement(
MakeUnique<MaybeDivertOnStopHttpEvent>(this, channelStatus));
}
nsCOMPtr<nsICompressConvStats> conv = do_QueryInterface(mCompressListener);
@@ -1020,16 +1070,17 @@ HttpChannelChild::DoPreOnStopRequest(nsr
mStatus = aStatus;
}
}
void
HttpChannelChild::DoOnStopRequest(nsIRequest* aRequest, nsresult aChannelStatus, nsISupports* aContext)
{
LOG(("HttpChannelChild::DoOnStopRequest [this=%p]\n", this));
+ MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(!mIsPending);
// NB: We use aChannelStatus here instead of mStatus because if there was an
// nsCORSListenerProxy on this request, it will override the tracking
// protection's return value.
if (aChannelStatus == NS_ERROR_TRACKING_URI ||
aChannelStatus == NS_ERROR_MALWARE_URI ||
aChannelStatus == NS_ERROR_UNWANTED_URI ||
@@ -2216,16 +2267,31 @@ HttpChannelChild::GetNeckoTarget()
}
if (!target) {
target = do_GetMainThread();
}
return target.forget();
}
+already_AddRefed<nsIEventTarget>
+HttpChannelChild::GetODATarget()
+{
+ nsCOMPtr<nsIEventTarget> target;
+ {
+ MutexAutoLock lock(mEventTargetMutex);
+ target = mODATarget ? mODATarget : mNeckoTarget;
+ }
+
+ if (!target) {
+ target = do_GetMainThread();
+ }
+ return target.forget();
+}
+
nsresult
HttpChannelChild::ContinueAsyncOpen()
{
nsCString appCacheClientId;
if (mInheritApplicationCache) {
// Pick up an application cache from the notification
// callbacks if available
nsCOMPtr<nsIApplicationCacheContainer> appCacheContainer;
@@ -2955,16 +3021,58 @@ HttpChannelChild::UnknownDecoderInvolved
NS_IMETHODIMP
HttpChannelChild::GetDivertingToParent(bool* aDiverting)
{
NS_ENSURE_ARG_POINTER(aDiverting);
*aDiverting = mDivertingToParent;
return NS_OK;
}
+//-----------------------------------------------------------------------------
+// HttpChannelChild::nsIThreadRetargetableRequest
+//-----------------------------------------------------------------------------
+
+NS_IMETHODIMP
+HttpChannelChild::RetargetDeliveryTo(nsIEventTarget* aNewTarget)
+{
+ LOG(("HttpChannelChild::RetargetDeliveryTo [this=%p, aNewTarget=%p]",
+ this, aNewTarget));
+
+ MOZ_ASSERT(NS_IsMainThread(), "Should be called on main thread only");
+ MOZ_ASSERT(!mODATarget);
+ MOZ_ASSERT(aNewTarget);
+
+ NS_ENSURE_ARG(aNewTarget);
+ if (aNewTarget == NS_GetCurrentThread()) {
+ NS_WARNING("Retargeting delivery to same thread");
+ return NS_OK;
+ }
+
+ // Ensure that |mListener| and any subsequent listeners can be retargeted
+ // to another thread.
+ nsresult rv = NS_OK;
+ nsCOMPtr<nsIThreadRetargetableStreamListener> retargetableListener =
+ do_QueryInterface(mListener, &rv);
+ if (!retargetableListener || NS_FAILED(rv)) {
+ NS_WARNING("Listener is not retargetable");
+ return NS_ERROR_NO_INTERFACE;
+ }
+
+ rv = retargetableListener->CheckListenerChain();
+ if (NS_FAILED(rv)) {
+ NS_WARNING("Subsequent listeners are not retargetable");
+ return rv;
+ }
+
+ {
+ MutexAutoLock lock(mEventTargetMutex);
+ mODATarget = aNewTarget;
+ }
+ return NS_OK;
+}
void
HttpChannelChild::ResetInterception()
{
NS_ENSURE_TRUE_VOID(gNeckoChild != nullptr);
if (mInterceptListener) {
mInterceptListener->Cleanup();
@@ -2999,16 +3107,63 @@ HttpChannelChild::TrySendDeletingChannel
}
DebugOnly<nsresult> rv =
NS_DispatchToMainThread(
NewNonOwningRunnableMethod(this, &HttpChannelChild::TrySendDeletingChannel));
MOZ_ASSERT(NS_SUCCEEDED(rv));
}
+class CancelEvent final : public ChannelEvent
+{
+public:
+ CancelEvent(HttpChannelChild* aChild, nsresult aRv)
+ : mChild(aChild)
+ , mRv(aRv)
+ {
+ MOZ_ASSERT(!NS_IsMainThread());
+ MOZ_ASSERT(aChild);
+ }
+
+ void Run() {
+ MOZ_ASSERT(NS_IsMainThread());
+ mChild->Cancel(mRv);
+ }
+
+ already_AddRefed<nsIEventTarget> GetEventTarget()
+ {
+ MOZ_ASSERT(mChild);
+ nsCOMPtr<nsIEventTarget> target = mChild->GetNeckoTarget();
+ return target.forget();
+ }
+
+private:
+ HttpChannelChild* mChild;
+ const nsresult mRv;
+};
+
+void
+HttpChannelChild::CancelOnMainThread(nsresult aRv)
+{
+ LOG(("HttpChannelChild::CancelOnMainThread [this=%p]", this));
+
+ if (NS_IsMainThread()) {
+ Cancel(aRv);
+ return;
+ }
+
+ mEventQ->Suspend();
+ // Cancel is expected to preempt any other channel events, thus we put this
+ // event in the front of mEventQ to make sure nsIStreamListener not receiving
+ // any ODA/OnStopRequest callbacks.
+ UniquePtr<ChannelEvent> cancelEvent = MakeUnique<CancelEvent>(this, aRv);
+ mEventQ->PrependEvent(cancelEvent);
+ mEventQ->Resume();
+}
+
void
HttpChannelChild::OverrideWithSynthesizedResponse(nsAutoPtr<nsHttpResponseHead>& aResponseHead,
nsIInputStream* aSynthesizedInput,
InterceptStreamListener* aStreamListener)
{
mInterceptListener = aStreamListener;
// Intercepted responses should already be decoded. If its a redirect,
--- a/netwerk/protocol/http/HttpChannelChild.h
+++ b/netwerk/protocol/http/HttpChannelChild.h
@@ -25,18 +25,20 @@
#include "nsIUploadChannel2.h"
#include "nsIResumableChannel.h"
#include "nsIProxiedChannel.h"
#include "nsIAsyncVerifyRedirectCallback.h"
#include "nsIAssociatedContentSecurity.h"
#include "nsIChildChannel.h"
#include "nsIHttpChannelChild.h"
#include "nsIDivertableChannel.h"
+#include "nsIThreadRetargetableRequest.h"
#include "mozilla/net/DNS.h"
+class nsIEventTarget;
class nsInputStreamPump;
namespace mozilla {
namespace net {
class InterceptedChannelContent;
class InterceptStreamListener;
@@ -46,29 +48,31 @@ class HttpChannelChild final : public PH
, public nsICacheInfoChannel
, public nsIProxiedChannel
, public nsIApplicationCacheChannel
, public nsIAsyncVerifyRedirectCallback
, public nsIAssociatedContentSecurity
, public nsIChildChannel
, public nsIHttpChannelChild
, public nsIDivertableChannel
+ , public nsIThreadRetargetableRequest
{
virtual ~HttpChannelChild();
public:
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_NSICACHEINFOCHANNEL
NS_DECL_NSIPROXIEDCHANNEL
NS_DECL_NSIAPPLICATIONCACHECONTAINER
NS_DECL_NSIAPPLICATIONCACHECHANNEL
NS_DECL_NSIASYNCVERIFYREDIRECTCALLBACK
NS_DECL_NSIASSOCIATEDCONTENTSECURITY
NS_DECL_NSICHILDCHANNEL
NS_DECL_NSIHTTPCHANNELCHILD
NS_DECL_NSIDIVERTABLECHANNEL
+ NS_DECL_NSITHREADRETARGETABLEREQUEST
HttpChannelChild();
// Methods HttpBaseChannel didn't implement for us or that we override.
//
// nsIRequest
NS_IMETHOD Cancel(nsresult status) override;
NS_IMETHOD Suspend() override;
@@ -196,16 +200,19 @@ private:
// directed to the TabGroup or DocGroup, depending on the LoadInfo associated
// with the channel. Should be called when a new channel is being set up,
// before the constructor message is sent to the parent.
void SetEventTarget();
// Get event target for processing network events.
already_AddRefed<nsIEventTarget> GetNeckoTarget();
+ // Get event target for ODA.
+ already_AddRefed<nsIEventTarget> GetODATarget();
+
MOZ_MUST_USE nsresult ContinueAsyncOpen();
void DoOnStartRequest(nsIRequest* aRequest, nsISupports* aContext);
void DoOnStatus(nsIRequest* aRequest, nsresult status);
void DoOnProgress(nsIRequest* aRequest, int64_t progress, int64_t progressMax);
void DoOnDataAvailable(nsIRequest* aRequest, nsISupports* aContext, nsIInputStream* aStream,
uint64_t offset, uint32_t count);
void DoPreOnStopRequest(nsresult aStatus);
@@ -223,16 +230,20 @@ private:
InterceptStreamListener* aStreamListener);
void ForceIntercepted(nsIInputStream* aSynthesizedInput);
// Try send DeletingChannel message to parent side. Dispatch an async task to
// main thread if invoking on non-main thread.
void TrySendDeletingChannel();
+ // Try invoke Cancel if on main thread, or prepend a CancelEvent in mEventQ to
+ // ensure Cacnel is processed before any other channel events.
+ void CancelOnMainThread(nsresult aRv);
+
RequestHeaderTuples mClientSetRequestHeaders;
nsCOMPtr<nsIChildChannel> mRedirectChannelChild;
RefPtr<InterceptStreamListener> mInterceptListener;
RefPtr<nsInputStreamPump> mSynthesizedResponsePump;
nsCOMPtr<nsIInputStream> mSynthesizedInput;
int64_t mSynthesizedStreamLength;
bool mIsFromCache;
@@ -296,17 +307,19 @@ private:
nsCOMPtr<nsISupports> mInterceptedRedirectContext;
// Needed to call CleanupRedirectingChannel in FinishInterceptedRedirect
RefPtr<HttpChannelChild> mInterceptingChannel;
// Used to call OverrideWithSynthesizedResponse in FinishInterceptedRedirect
RefPtr<OverrideRunnable> mOverrideRunnable;
// EventTarget for labeling networking events.
nsCOMPtr<nsIEventTarget> mNeckoTarget;
- // Used to ensure atomicity of mNeckoTarget;
+ // Target thread for delivering ODA.
+ nsCOMPtr<nsIEventTarget> mODATarget;
+ // Used to ensure atomicity of mNeckoTarget / mODATarget;
Mutex mEventTargetMutex;
void FinishInterceptedRedirect();
void CleanupRedirectingChannel(nsresult rv);
// true after successful AsyncOpen until OnStopRequest completes.
bool RemoteChannelExists() { return mIPCOpen && !mKeptAlive; }
@@ -371,16 +384,17 @@ private:
friend class MaybeDivertOnStopHttpEvent;
friend class ProgressEvent;
friend class StatusEvent;
friend class FailedAsyncOpenEvent;
friend class Redirect1Event;
friend class Redirect3Event;
friend class DeleteSelfEvent;
friend class HttpFlushedForDiversionEvent;
+ friend class CancelEvent;
friend class HttpAsyncAborter<HttpChannelChild>;
friend class InterceptStreamListener;
friend class InterceptedChannelContent;
};
// A stream listener interposed between the nsInputStreamPump used for intercepted channels
// and this channel's original listener. This is only used to ensure the original listener
// sees the channel as the request object, and to synthesize OnStatus and OnProgress notifications.
--- a/netwerk/protocol/http/nsHttpChannel.cpp
+++ b/netwerk/protocol/http/nsHttpChannel.cpp
@@ -6353,18 +6353,18 @@ nsHttpChannel::ContinueBeginConnectWithR
// We may have been cancelled already, by nsChannelClassifier in that
// case, we should not send the request to the server
rv = mStatus;
} else {
rv = Connect();
}
LOG(("nsHttpChannel::ContinueBeginConnectWithResult result [this=%p rv=%" PRIx32
- " mCanceled=%i]\n",
- this, static_cast<uint32_t>(rv), mCanceled));
+ " mCanceled=%u]\n",
+ this, static_cast<uint32_t>(rv), static_cast<bool>(mCanceled)));
return rv;
}
void
nsHttpChannel::ContinueBeginConnect()
{
nsresult rv = ContinueBeginConnectWithResult();
if (NS_FAILED(rv)) {
--- a/parser/html/nsHtml5StreamParser.cpp
+++ b/parser/html/nsHtml5StreamParser.cpp
@@ -977,21 +977,17 @@ nsHtml5StreamParser::OnStartRequest(nsIR
// thread, rather than through the main thread.
nsCOMPtr<nsIThreadRetargetableRequest> threadRetargetableRequest =
do_QueryInterface(mRequest, &rv);
if (threadRetargetableRequest) {
rv = threadRetargetableRequest->RetargetDeliveryTo(mThread);
}
if (NS_FAILED(rv)) {
- // for now skip warning if we're on child process, since we don't support
- // off-main thread delivery there yet. This will change with bug 1015466
- if (!XRE_IsContentProcess()) {
- NS_WARNING("Failed to retarget HTML data delivery to the parser thread.");
- }
+ NS_WARNING("Failed to retarget HTML data delivery to the parser thread.");
}
if (mCharsetSource == kCharsetFromParentFrame) {
// Remember this in case chardet overwrites mCharsetSource
mInitialEncodingWasFromParentFrame = true;
}
if (mCharsetSource >= kCharsetFromAutoDetection) {