--- a/netwerk/base/ThrottlingService.cpp
+++ b/netwerk/base/ThrottlingService.cpp
@@ -126,25 +126,20 @@ ThrottlingService::AddChannel(nsIHttpCha
// We don't check mEnabled, because we always want to put channels in the hash
// to avoid potential inconsistencies in the case where the user changes the
// enabled pref at run-time.
if (IsNeckoChild()) {
return NS_ERROR_NOT_AVAILABLE;
}
- nsAutoCString strKey;
- nsresult rv = channel->GetChannelId(strKey);
+ uint64_t key;
+ nsresult rv = channel->GetChannelId(&key);
NS_ENSURE_SUCCESS(rv, rv);
- nsID key;
- if (!key.Parse(strKey.get())) {
- return NS_ERROR_UNEXPECTED;
- }
-
if (mChannelHash.Get(key, nullptr)) {
// We already have this channel under our control, not adding it again.
MOZ_ASSERT(false, "Trying to throttle an already-throttled channel");
return NS_ERROR_ILLEGAL_VALUE;
}
if (!mIteratingHash) {
// This should be the common case, and as such is easy to handle
@@ -173,25 +168,20 @@ ThrottlingService::RemoveChannel(nsIHttp
// Just like above, don't worry about mEnabled to avoid inconsistencies when
// the pref changes at run-time
if (IsNeckoChild()) {
return NS_ERROR_NOT_AVAILABLE;
}
- nsAutoCString strKey;
- nsresult rv = channel->GetChannelId(strKey);
+ uint64_t key;
+ nsresult rv = channel->GetChannelId(&key);
NS_ENSURE_SUCCESS(rv, rv);
- nsID key;
- if (!key.Parse(strKey.get())) {
- return NS_ERROR_UNEXPECTED;
- }
-
if (!mChannelHash.Get(key, nullptr)) {
// TODO - warn?
return NS_ERROR_ILLEGAL_VALUE;
}
if (!mIteratingHash) {
// This should be the common case, and easy to handle.
mChannelHash.Remove(key);
--- a/netwerk/base/ThrottlingService.h
+++ b/netwerk/base/ThrottlingService.h
@@ -45,17 +45,17 @@ private:
bool mEnabled;
bool mInitCalled;
bool mSuspended;
uint32_t mPressureCount;
uint32_t mSuspendPeriod; // How long we should Suspend() channels for
uint32_t mResumePeriod; // How long we should Resume() channels for
nsCOMPtr<nsITimer> mTimer;
- typedef nsInterfaceHashtable<nsIDHashKey, nsIHttpChannel> ChannelHash;
+ typedef nsInterfaceHashtable<nsUint64HashKey, nsIHttpChannel> ChannelHash;
ChannelHash mChannelHash;
// Used to avoid inconsistencies in the hash and the suspend/resume count of
// channels. See comments in AddChannel and RemoveChannel for details.
void IterateHash(void (* callback)(ChannelHash::Iterator &iter));
bool mIteratingHash;
nsCOMArray<nsIHttpChannel> mChannelsToAddRemove;
nsTArray<bool> mChannelIsAdd;
--- a/netwerk/ipc/NeckoChannelParams.ipdlh
+++ b/netwerk/ipc/NeckoChannelParams.ipdlh
@@ -123,17 +123,17 @@ struct HttpChannelOpenArgs
uint32_t cacheKey;
uint64_t requestContextID;
OptionalCorsPreflightArgs preflightArgs;
uint32_t initialRwin;
bool blockAuthPrompt;
bool suspendAfterSynthesizeResponse;
bool allowStaleCacheContent;
nsCString contentTypeHint;
- nsCString channelId;
+ uint64_t channelId;
uint64_t contentWindowId;
nsCString preferredAlternativeType;
uint64_t topLevelOuterContentWindowId;
};
struct HttpChannelConnectArgs
{
uint32_t registrarId;
--- a/netwerk/protocol/http/AlternateServices.cpp
+++ b/netwerk/protocol/http/AlternateServices.cpp
@@ -665,19 +665,19 @@ public:
LOG(("WellKnownChecker dtor %p\n", this));
}
private:
nsresult
MakeChannel(nsHttpChannel *chan, TransactionObserver *obs, nsHttpConnectionInfo *ci,
nsIURI *uri, uint32_t caps, nsILoadInfo *loadInfo)
{
- nsID channelId;
+ uint64_t channelId;
nsLoadFlags flags;
- if (NS_FAILED(gHttpHandler->NewChannelId(&channelId)) ||
+ if (NS_FAILED(gHttpHandler->NewChannelId(channelId)) ||
NS_FAILED(chan->Init(uri, caps, nullptr, 0, nullptr, channelId)) ||
NS_FAILED(chan->SetAllowAltSvc(false)) ||
NS_FAILED(chan->SetRedirectMode(nsIHttpChannelInternal::REDIRECT_MODE_ERROR)) ||
NS_FAILED(chan->SetLoadInfo(loadInfo)) ||
NS_FAILED(chan->GetLoadFlags(&flags))) {
return NS_ERROR_FAILURE;
}
flags |= HttpBaseChannel::LOAD_BYPASS_CACHE;
--- a/netwerk/protocol/http/HttpBaseChannel.cpp
+++ b/netwerk/protocol/http/HttpBaseChannel.cpp
@@ -259,17 +259,17 @@ HttpBaseChannel::ReleaseMainThreadOnlyRe
}
nsresult
HttpBaseChannel::Init(nsIURI *aURI,
uint32_t aCaps,
nsProxyInfo *aProxyInfo,
uint32_t aProxyResolveFlags,
nsIURI *aProxyURI,
- const nsID& aChannelId)
+ uint64_t aChannelId)
{
LOG(("HttpBaseChannel::Init [this=%p]\n", this));
NS_PRECONDITION(aURI, "null uri");
mURI = aURI;
mOriginalURI = aURI;
mDocumentURI = nullptr;
@@ -1328,35 +1328,28 @@ HttpBaseChannel::nsContentEncodings::Pre
}
//-----------------------------------------------------------------------------
// HttpBaseChannel::nsIHttpChannel
//-----------------------------------------------------------------------------
NS_IMETHODIMP
-HttpBaseChannel::GetChannelId(nsACString& aChannelId)
+HttpBaseChannel::GetChannelId(uint64_t *aChannelId)
{
- char id[NSID_LENGTH];
- mChannelId.ToProvidedString(id);
- aChannelId.AssignASCII(id);
+ NS_ENSURE_ARG_POINTER(aChannelId);
+ *aChannelId = mChannelId;
return NS_OK;
}
NS_IMETHODIMP
-HttpBaseChannel::SetChannelId(const nsACString& aChannelId)
+HttpBaseChannel::SetChannelId(uint64_t aChannelId)
{
- nsID newId;
- nsAutoCString idStr(aChannelId);
- if (newId.Parse(idStr.get())) {
- mChannelId = newId;
- return NS_OK;
- }
-
- return NS_ERROR_FAILURE;
+ mChannelId = aChannelId;
+ return NS_OK;
}
NS_IMETHODIMP HttpBaseChannel::GetTopLevelContentWindowId(uint64_t *aWindowId)
{
if (!mContentWindowId) {
nsCOMPtr<nsILoadContext> loadContext;
GetCallback(loadContext);
if (loadContext) {
--- a/netwerk/protocol/http/HttpBaseChannel.h
+++ b/netwerk/protocol/http/HttpBaseChannel.h
@@ -109,17 +109,17 @@ public:
NS_DECLARE_STATIC_IID_ACCESSOR(HTTP_BASE_CHANNEL_IID)
HttpBaseChannel();
virtual MOZ_MUST_USE nsresult Init(nsIURI *aURI, uint32_t aCaps,
nsProxyInfo *aProxyInfo,
uint32_t aProxyResolveFlags,
nsIURI *aProxyURI,
- const nsID& aChannelId);
+ uint64_t aChannelId);
// nsIRequest
NS_IMETHOD GetName(nsACString& aName) override;
NS_IMETHOD IsPending(bool *aIsPending) override;
NS_IMETHOD GetStatus(nsresult *aStatus) override;
NS_IMETHOD GetLoadGroup(nsILoadGroup **aLoadGroup) override;
NS_IMETHOD SetLoadGroup(nsILoadGroup *aLoadGroup) override;
NS_IMETHOD GetLoadFlags(nsLoadFlags *aLoadFlags) override;
@@ -196,18 +196,18 @@ public:
NS_IMETHOD GetRequestContextID(uint64_t *aRCID) override;
NS_IMETHOD GetTransferSize(uint64_t *aTransferSize) override;
NS_IMETHOD GetDecodedBodySize(uint64_t *aDecodedBodySize) override;
NS_IMETHOD GetEncodedBodySize(uint64_t *aEncodedBodySize) override;
NS_IMETHOD SetRequestContextID(uint64_t aRCID) override;
NS_IMETHOD GetIsMainDocumentChannel(bool* aValue) override;
NS_IMETHOD SetIsMainDocumentChannel(bool aValue) override;
NS_IMETHOD GetProtocolVersion(nsACString & aProtocolVersion) override;
- NS_IMETHOD GetChannelId(nsACString& aChannelId) override;
- NS_IMETHOD SetChannelId(const nsACString& aChannelId) override;
+ NS_IMETHOD GetChannelId(uint64_t *aChannelId) override;
+ NS_IMETHOD SetChannelId(uint64_t aChannelId) override;
NS_IMETHOD GetTopLevelContentWindowId(uint64_t *aContentWindowId) override;
NS_IMETHOD SetTopLevelContentWindowId(uint64_t aContentWindowId) override;
NS_IMETHOD GetIsTrackingResource(bool* aIsTrackingResource) override;
// nsIHttpChannelInternal
NS_IMETHOD GetDocumentURI(nsIURI **aDocumentURI) override;
NS_IMETHOD SetDocumentURI(nsIURI *aDocumentURI) override;
NS_IMETHOD GetRequestVersion(uint32_t *major, uint32_t *minor) override;
@@ -605,17 +605,17 @@ protected:
nsCString mPreferredCachedAltDataType;
// Holds the name of the alternative data type the channel returned.
nsCString mAvailableCachedAltDataType;
int64_t mAltDataLength;
bool mForceMainDocumentChannel;
bool mIsTrackingResource;
- nsID mChannelId;
+ uint64_t mChannelId;
nsString mIntegrityMetadata;
// Classified channel's matched information
nsCString mMatchedList;
nsCString mMatchedProvider;
nsCString mMatchedPrefix;
};
--- a/netwerk/protocol/http/HttpChannelChild.cpp
+++ b/netwerk/protocol/http/HttpChannelChild.cpp
@@ -1281,17 +1281,17 @@ class Redirect1Event : public ChannelEve
{
public:
Redirect1Event(HttpChannelChild* child,
const uint32_t& registrarId,
const URIParams& newURI,
const uint32_t& redirectFlags,
const nsHttpResponseHead& responseHead,
const nsACString& securityInfoSerialization,
- const nsACString& channelId)
+ const uint64_t& channelId)
: mChild(child)
, mRegistrarId(registrarId)
, mNewURI(newURI)
, mRedirectFlags(redirectFlags)
, mResponseHead(responseHead)
, mSecurityInfoSerialization(securityInfoSerialization)
, mChannelId(channelId) {}
@@ -1303,26 +1303,26 @@ class Redirect1Event : public ChannelEve
}
private:
HttpChannelChild* mChild;
uint32_t mRegistrarId;
URIParams mNewURI;
uint32_t mRedirectFlags;
nsHttpResponseHead mResponseHead;
nsCString mSecurityInfoSerialization;
- nsCString mChannelId;
+ uint64_t mChannelId;
};
mozilla::ipc::IPCResult
HttpChannelChild::RecvRedirect1Begin(const uint32_t& registrarId,
const URIParams& newUri,
const uint32_t& redirectFlags,
const nsHttpResponseHead& responseHead,
const nsCString& securityInfoSerialization,
- const nsCString& channelId)
+ const uint64_t& channelId)
{
// TODO: handle security info
LOG(("HttpChannelChild::RecvRedirect1Begin [this=%p]\n", this));
mEventQ->RunOrEnqueue(new Redirect1Event(this, registrarId, newUri,
redirectFlags, responseHead,
securityInfoSerialization,
channelId));
return IPC_OK();
@@ -1390,17 +1390,17 @@ HttpChannelChild::SetupRedirect(nsIURI*
}
void
HttpChannelChild::Redirect1Begin(const uint32_t& registrarId,
const URIParams& newUri,
const uint32_t& redirectFlags,
const nsHttpResponseHead& responseHead,
const nsACString& securityInfoSerialization,
- const nsACString& channelId)
+ const uint64_t& channelId)
{
LOG(("HttpChannelChild::Redirect1Begin [this=%p]\n", this));
nsCOMPtr<nsIURI> uri = DeserializeURI(newUri);
if (!securityInfoSerialization.IsEmpty()) {
NS_DeserializeObject(securityInfoSerialization,
getter_AddRefs(mSecurityInfo));
@@ -2240,19 +2240,17 @@ HttpChannelChild::ContinueAsyncOpen()
openArgs.contentTypeHint() = mContentTypeHint;
nsresult rv = mozilla::ipc::LoadInfoToLoadInfoArgs(mLoadInfo, &openArgs.loadInfo());
NS_ENSURE_SUCCESS(rv, rv);
EnsureRequestContextID();
openArgs.requestContextID() = mRequestContextID;
- char chid[NSID_LENGTH];
- mChannelId.ToProvidedString(chid);
- openArgs.channelId().AssignASCII(chid);
+ openArgs.channelId() = mChannelId;
openArgs.contentWindowId() = contentWindowId;
openArgs.topLevelOuterContentWindowId() = mTopLevelOuterContentWindowId;
if (tabChild && !tabChild->IPCOpen()) {
return NS_ERROR_FAILURE;
}
--- a/netwerk/protocol/http/HttpChannelChild.h
+++ b/netwerk/protocol/http/HttpChannelChild.h
@@ -135,17 +135,17 @@ protected:
mozilla::ipc::IPCResult RecvOnProgress(const int64_t& progress, const int64_t& progressMax) override;
mozilla::ipc::IPCResult RecvOnStatus(const nsresult& status) override;
mozilla::ipc::IPCResult RecvFailedAsyncOpen(const nsresult& status) override;
mozilla::ipc::IPCResult RecvRedirect1Begin(const uint32_t& registrarId,
const URIParams& newURI,
const uint32_t& redirectFlags,
const nsHttpResponseHead& responseHead,
const nsCString& securityInfoSerialization,
- const nsCString& channelId) override;
+ const uint64_t& channelId) override;
mozilla::ipc::IPCResult RecvRedirect3Complete() override;
mozilla::ipc::IPCResult RecvAssociateApplicationCache(const nsCString& groupID,
const nsCString& clientID) override;
mozilla::ipc::IPCResult RecvFlushedForDiversion() override;
mozilla::ipc::IPCResult RecvDivertMessages() override;
mozilla::ipc::IPCResult RecvDeleteSelf() override;
mozilla::ipc::IPCResult RecvFinishInterceptedRedirect() override;
@@ -320,17 +320,17 @@ private:
void OnStatus(const nsresult& status);
void FailedAsyncOpen(const nsresult& status);
void HandleAsyncAbort();
void Redirect1Begin(const uint32_t& registrarId,
const URIParams& newUri,
const uint32_t& redirectFlags,
const nsHttpResponseHead& responseHead,
const nsACString& securityInfoSerialization,
- const nsACString& channelId);
+ const uint64_t& channelId);
bool Redirect3Complete(OverrideRunnable* aRunnable);
void DeleteSelf();
// Create a a new channel to be used in a redirection, based on the provided
// response headers.
MOZ_MUST_USE nsresult SetupRedirect(nsIURI* uri,
const nsHttpResponseHead* responseHead,
const uint32_t& redirectFlags,
--- a/netwerk/protocol/http/HttpChannelParent.cpp
+++ b/netwerk/protocol/http/HttpChannelParent.cpp
@@ -323,17 +323,17 @@ HttpChannelParent::DoAsyncOpen( const U
const uint32_t& aCacheKey,
const uint64_t& aRequestContextID,
const OptionalCorsPreflightArgs& aCorsPreflightArgs,
const uint32_t& aInitialRwin,
const bool& aBlockAuthPrompt,
const bool& aSuspendAfterSynthesizeResponse,
const bool& aAllowStaleCacheContent,
const nsCString& aContentTypeHint,
- const nsCString& aChannelId,
+ const uint64_t& aChannelId,
const uint64_t& aContentWindowId,
const nsCString& aPreferredAlternativeType,
const uint64_t& aTopLevelOuterContentWindowId)
{
nsCOMPtr<nsIURI> uri = DeserializeURI(aURI);
if (!uri) {
// URIParams does MOZ_ASSERT if null, but we need to protect opt builds from
// null deref here.
@@ -1438,20 +1438,20 @@ HttpChannelParent::StartRedirect(uint32_
SerializeURI(newURI, uriParams);
nsCString secInfoSerialization;
UpdateAndSerializeSecurityInfo(secInfoSerialization);
// If the channel is a HTTP channel, we also want to inform the child
// about the parent's channelId attribute, so that both parent and child
// share the same ID. Useful for monitoring channel activity in devtools.
- nsAutoCString channelId;
+ uint64_t channelId;
nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(newChannel);
if (httpChannel) {
- nsresult rv = httpChannel->GetChannelId(channelId);
+ nsresult rv = httpChannel->GetChannelId(&channelId);
NS_ENSURE_SUCCESS(rv, NS_BINDING_ABORTED);
}
nsHttpResponseHead *responseHead = mChannel->GetResponseHead();
bool result = false;
if (!mIPCClosed) {
result = SendRedirect1Begin(registrarId, uriParams, redirectFlags,
responseHead ? *responseHead
--- a/netwerk/protocol/http/HttpChannelParent.h
+++ b/netwerk/protocol/http/HttpChannelParent.h
@@ -141,17 +141,17 @@ protected:
const uint32_t& aCacheKey,
const uint64_t& aRequestContextID,
const OptionalCorsPreflightArgs& aCorsPreflightArgs,
const uint32_t& aInitialRwin,
const bool& aBlockAuthPrompt,
const bool& aSuspendAfterSynthesizeResponse,
const bool& aAllowStaleCacheContent,
const nsCString& aContentTypeHint,
- const nsCString& aChannelId,
+ const uint64_t& aChannelId,
const uint64_t& aContentWindowId,
const nsCString& aPreferredAlternativeType,
const uint64_t& aTopLevelOuterContentWindowId);
virtual mozilla::ipc::IPCResult RecvSetPriority(const int16_t& priority) override;
virtual mozilla::ipc::IPCResult RecvSetClassOfService(const uint32_t& cos) override;
virtual mozilla::ipc::IPCResult RecvSetCacheTokenCachedCharset(const nsCString& charset) override;
virtual mozilla::ipc::IPCResult RecvSuspend() override;
--- a/netwerk/protocol/http/NullHttpChannel.cpp
+++ b/netwerk/protocol/http/NullHttpChannel.cpp
@@ -53,23 +53,23 @@ NullHttpChannel::Init(nsIURI *aURI,
return NS_OK;
}
//-----------------------------------------------------------------------------
// NullHttpChannel::nsIHttpChannel
//-----------------------------------------------------------------------------
NS_IMETHODIMP
-NullHttpChannel::GetChannelId(nsACString& aChannelId)
+NullHttpChannel::GetChannelId(uint64_t *aChannelId)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
-NullHttpChannel::SetChannelId(const nsACString& aChannelId)
+NullHttpChannel::SetChannelId(uint64_t aChannelId)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
NullHttpChannel::GetTopLevelContentWindowId(uint64_t *aWindowId)
{
return NS_ERROR_NOT_IMPLEMENTED;
--- a/netwerk/protocol/http/PHttpChannel.ipdl
+++ b/netwerk/protocol/http/PHttpChannel.ipdl
@@ -131,17 +131,17 @@ child:
// Called to initiate content channel redirect, starts talking to sinks
// on the content process and reports result via Redirect2Verify above
async Redirect1Begin(uint32_t registrarId,
URIParams newUri,
uint32_t redirectFlags,
nsHttpResponseHead responseHead,
nsCString securityInfoSerialization,
- nsCString channelId);
+ uint64_t channelId);
// Called if redirect successful so that child can complete setup.
async Redirect3Complete();
// Associate the child with an application ids
async AssociateApplicationCache(nsCString groupID,
nsCString clientID);
--- a/netwerk/protocol/http/nsHttpChannel.cpp
+++ b/netwerk/protocol/http/nsHttpChannel.cpp
@@ -329,17 +329,17 @@ nsHttpChannel::ReleaseMainThreadOnlyRefe
}
nsresult
nsHttpChannel::Init(nsIURI *uri,
uint32_t caps,
nsProxyInfo *proxyInfo,
uint32_t proxyResolveFlags,
nsIURI *proxyURI,
- const nsID& channelId)
+ uint64_t channelId)
{
nsresult rv = HttpBaseChannel::Init(uri, caps, proxyInfo,
proxyResolveFlags, proxyURI, channelId);
if (NS_FAILED(rv))
return rv;
LOG(("nsHttpChannel::Init [this=%p]\n", this));
--- a/netwerk/protocol/http/nsHttpChannel.h
+++ b/netwerk/protocol/http/nsHttpChannel.h
@@ -127,17 +127,17 @@ public:
NS_IMETHOD GetRequestMethod(nsACString& aMethod) override;
nsHttpChannel();
virtual MOZ_MUST_USE nsresult Init(nsIURI *aURI, uint32_t aCaps,
nsProxyInfo *aProxyInfo,
uint32_t aProxyResolveFlags,
nsIURI *aProxyURI,
- const nsID& aChannelId) override;
+ uint64_t aChannelId) override;
MOZ_MUST_USE nsresult OnPush(const nsACString &uri,
Http2PushedStream *pushedStream);
static bool IsRedirectStatus(uint32_t status);
// Methods HttpBaseChannel didn't implement for us or that we override.
--- a/netwerk/protocol/http/nsHttpHandler.cpp
+++ b/netwerk/protocol/http/nsHttpHandler.cpp
@@ -46,19 +46,19 @@
#include "nsIParentalControlsService.h"
#include "nsPIDOMWindow.h"
#include "nsINetworkLinkService.h"
#include "nsHttpChannelAuthProvider.h"
#include "nsServiceManagerUtils.h"
#include "nsComponentManagerUtils.h"
#include "nsSocketTransportService2.h"
#include "nsIOService.h"
-#include "nsIUUIDGenerator.h"
#include "nsIThrottlingService.h"
#include "nsISupportsPrimitives.h"
+#include "nsIXULRuntime.h"
#include "mozilla/net/NeckoChild.h"
#include "mozilla/net/NeckoParent.h"
#include "mozilla/ipc/URIUtils.h"
#include "mozilla/Telemetry.h"
#include "mozilla/Unused.h"
#include "mozilla/BasePrincipal.h"
@@ -233,21 +233,27 @@ nsHttpHandler::nsHttpHandler()
, mTCPKeepaliveShortLivedTimeS(60)
, mTCPKeepaliveShortLivedIdleTimeS(10)
, mTCPKeepaliveLongLivedEnabled(false)
, mTCPKeepaliveLongLivedIdleTimeS(600)
, mEnforceH1Framing(FRAMECHECK_BARELY)
, mKeepEmptyResponseHeadersAsEmtpyString(false)
, mDefaultHpackBuffer(4096)
, mMaxHttpResponseHeaderSize(393216)
+ , mProcessId(0)
+ , mNextChannelId(1)
{
LOG(("Creating nsHttpHandler [this=%p].\n", this));
MOZ_ASSERT(!gHttpHandler, "HTTP handler already created!");
gHttpHandler = this;
+ nsCOMPtr<nsIXULRuntime> runtime = do_GetService("@mozilla.org/xre/runtime;1");
+ if (runtime) {
+ runtime->GetProcessID(&mProcessId);
+ }
}
nsHttpHandler::~nsHttpHandler()
{
LOG(("Deleting nsHttpHandler [this=%p]\n", this));
// make sure the connection manager is shutdown
if (mConnMgr) {
@@ -1949,18 +1955,18 @@ nsHttpHandler::NewProxiedChannel2(nsIURI
uint32_t caps = mCapabilities;
if (!IsNeckoChild()) {
// HACK: make sure PSM gets initialized on the main thread.
net_EnsurePSMInit();
}
- nsID channelId;
- rv = NewChannelId(&channelId);
+ uint64_t channelId;
+ rv = NewChannelId(channelId);
NS_ENSURE_SUCCESS(rv, rv);
rv = httpChannel->Init(uri, caps, proxyInfo, proxyResolveFlags, proxyURI, channelId);
if (NS_FAILED(rv))
return rv;
// set the loadInfo on the new channel
rv = httpChannel->SetLoadInfo(aLoadInfo);
@@ -2444,22 +2450,17 @@ nsHttpHandler::ShutdownConnectionManager
if (NS_FAILED(rv)) {
LOG(("nsHttpHandler::ShutdownConnectionManager\n"
" failed to shutdown connection manager\n"));
}
}
}
nsresult
-nsHttpHandler::NewChannelId(nsID *channelId)
+nsHttpHandler::NewChannelId(uint64_t& channelId)
{
MOZ_ASSERT(NS_IsMainThread());
- if (!mUUIDGen) {
- nsresult rv;
- mUUIDGen = do_GetService("@mozilla.org/uuid-generator;1", &rv);
- NS_ENSURE_SUCCESS(rv, rv);
- }
-
- return mUUIDGen->GenerateUUIDInPlace(channelId);
+ channelId = ((static_cast<uint64_t>(mProcessId) << 32) & 0xFFFFFFFF00000000LL) | mNextChannelId++;
+ return NS_OK;
}
} // namespace net
} // namespace mozilla
--- a/netwerk/protocol/http/nsHttpHandler.h
+++ b/netwerk/protocol/http/nsHttpHandler.h
@@ -23,17 +23,16 @@ class nsIHttpChannel;
class nsIPrefBranch;
class nsICancelable;
class nsICookieService;
class nsIIOService;
class nsIRequestContextService;
class nsISiteSecurityService;
class nsIStreamConverterService;
class nsIThrottlingService;
-class nsIUUIDGenerator;
namespace mozilla {
namespace net {
extern Atomic<PRThread*, Relaxed> gSocketThread;
class ATokenBucketEvent;
@@ -606,21 +605,22 @@ private:
private:
MOZ_MUST_USE nsresult
SpeculativeConnectInternal(nsIURI *aURI,
nsIPrincipal *aPrincipal,
nsIInterfaceRequestor *aCallbacks,
bool anonymous);
- // UUID generator for channelIds
- nsCOMPtr<nsIUUIDGenerator> mUUIDGen;
+ // State for generating channelIds
+ uint32_t mProcessId;
+ uint32_t mNextChannelId;
public:
- MOZ_MUST_USE nsresult NewChannelId(nsID *channelId);
+ MOZ_MUST_USE nsresult NewChannelId(uint64_t& channelId);
};
extern nsHttpHandler *gHttpHandler;
//-----------------------------------------------------------------------------
// nsHttpsHandler - thin wrapper to distinguish the HTTP handler from the
// HTTPS handler (even though they share the same impl).
//-----------------------------------------------------------------------------
--- a/netwerk/protocol/http/nsIHttpChannel.idl
+++ b/netwerk/protocol/http/nsIHttpChannel.idl
@@ -449,17 +449,17 @@ interface nsIHttpChannel : nsIChannel
*/
[noscript, must_use] attribute uint64_t requestContextID;
/**
* Unique ID of the channel, shared between parent and child. Needed if
* the channel activity needs to be monitored across process boundaries,
* like in devtools net monitor. See bug 1274556.
*/
- [must_use] attribute ACString channelId;
+ [must_use] attribute uint64_t channelId;
/**
* ID of the top-level document's inner window. Identifies the content
* this channels is being load in.
*/
[must_use] attribute uint64_t topLevelContentWindowId;
/**
--- a/netwerk/protocol/viewsource/nsViewSourceChannel.cpp
+++ b/netwerk/protocol/viewsource/nsViewSourceChannel.cpp
@@ -707,24 +707,25 @@ nsViewSourceChannel::OnDataAvailable(nsI
// nsIHttpChannel methods
// We want to forward most of nsIHttpChannel over to mHttpChannel, but we want
// to override GetRequestHeader and VisitHeaders. The reason is that we don't
// want various headers like Link: and Refresh: applying to view-source.
NS_IMETHODIMP
-nsViewSourceChannel::GetChannelId(nsACString& aChannelId)
+nsViewSourceChannel::GetChannelId(uint64_t *aChannelId)
{
+ NS_ENSURE_ARG_POINTER(aChannelId);
return !mHttpChannel ? NS_ERROR_NULL_POINTER :
mHttpChannel->GetChannelId(aChannelId);
}
NS_IMETHODIMP
-nsViewSourceChannel::SetChannelId(const nsACString& aChannelId)
+nsViewSourceChannel::SetChannelId(uint64_t aChannelId)
{
return !mHttpChannel ? NS_ERROR_NULL_POINTER :
mHttpChannel->SetChannelId(aChannelId);
}
NS_IMETHODIMP
nsViewSourceChannel::GetTopLevelContentWindowId(uint64_t *aWindowId)
{