Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-21 09:15:35 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
a6095ebaf4
gecko-dev/netwerk/base/nsLoadGroup.cpp
Bogdan Tara 80377e90ee Backed out 6 changesets (bug 1552176) for causing Hazard bustages CLOSED TREE 
Backed out changeset c79b90bae420 (bug 1552176)
Backed out changeset 4b970cc771ca (bug 1552176)
Backed out changeset de7aa0eaf4c8 (bug 1552176)
Backed out changeset c8e692a40cd3 (bug 1552176)
Backed out changeset 68882d1eccac (bug 1552176)
Backed out changeset 692e5e51e19e (bug 1552176)
2019-11-11 12:11:36 +02:00

961 lines
30 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set sw=2 ts=4 sts=2 et cin: */
/* 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/DebugOnly.h"
#include "nsLoadGroup.h"
#include "nsArrayEnumerator.h"
#include "nsCOMArray.h"
#include "nsCOMPtr.h"
#include "mozilla/Logging.h"
#include "nsString.h"
#include "nsTArray.h"
#include "mozilla/Telemetry.h"
#include "nsITimedChannel.h"
#include "nsIInterfaceRequestor.h"
#include "nsIRequestObserver.h"
#include "nsIRequestContext.h"
#include "CacheObserver.h"
#include "MainThreadUtils.h"
#include "RequestContextService.h"
#include "mozilla/Unused.h"
namespace mozilla {
namespace net {
//
// Log module for nsILoadGroup logging...
//
// To enable logging (see prlog.h for full details):
//
// set MOZ_LOG=LoadGroup:5
// set MOZ_LOG_FILE=network.log
//
// This enables LogLevel::Debug level information and places all output in
// the file network.log.
//
static LazyLogModule gLoadGroupLog("LoadGroup");
#undef LOG
#define LOG(args) MOZ_LOG(gLoadGroupLog, mozilla::LogLevel::Debug, args)
////////////////////////////////////////////////////////////////////////////////
class RequestMapEntry : public PLDHashEntryHdr {
public:
explicit RequestMapEntry(nsIRequest* aRequest) : mKey(aRequest) {}
nsCOMPtr<nsIRequest> mKey;
};
static bool RequestHashMatchEntry(const PLDHashEntryHdr* entry,
const void* key) {
const RequestMapEntry* e = static_cast<const RequestMapEntry*>(entry);
const nsIRequest* request = static_cast<const nsIRequest*>(key);
return e->mKey == request;
}
static void RequestHashClearEntry(PLDHashTable* table, PLDHashEntryHdr* entry) {
RequestMapEntry* e = static_cast<RequestMapEntry*>(entry);
// An entry is being cleared, let the entry do its own cleanup.
e->~RequestMapEntry();
}
static void RequestHashInitEntry(PLDHashEntryHdr* entry, const void* key) {
const nsIRequest* const_request = static_cast<const nsIRequest*>(key);
nsIRequest* request = const_cast<nsIRequest*>(const_request);
// Initialize the entry with placement new
new (entry) RequestMapEntry(request);
}
static const PLDHashTableOps sRequestHashOps = {
PLDHashTable::HashVoidPtrKeyStub, RequestHashMatchEntry,
PLDHashTable::MoveEntryStub, RequestHashClearEntry, RequestHashInitEntry};
static void RescheduleRequest(nsIRequest* aRequest, int32_t delta) {
nsCOMPtr<nsISupportsPriority> p = do_QueryInterface(aRequest);
if (p) p->AdjustPriority(delta);
}
nsLoadGroup::nsLoadGroup()
: mForegroundCount(0),
mLoadFlags(LOAD_NORMAL),
mDefaultLoadFlags(0),
mPriority(PRIORITY_NORMAL),
mRequests(&sRequestHashOps, sizeof(RequestMapEntry)),
mStatus(NS_OK),
mIsCanceling(false),
mDefaultLoadIsTimed(false),
mTimedRequests(0),
mCachedRequests(0) {
LOG(("LOADGROUP [%p]: Created.\n", this));
}
nsLoadGroup::~nsLoadGroup() {
DebugOnly<nsresult> rv = Cancel(NS_BINDING_ABORTED);
NS_ASSERTION(NS_SUCCEEDED(rv), "Cancel failed");
mDefaultLoadRequest = nullptr;
if (mRequestContext) {
mRequestContextService->RemoveRequestContext(mRequestContext->GetID());
}
LOG(("LOADGROUP [%p]: Destroyed.\n", this));
}
////////////////////////////////////////////////////////////////////////////////
// nsISupports methods:
NS_IMPL_ISUPPORTS(nsLoadGroup, nsILoadGroup, nsILoadGroupChild, nsIRequest,
nsISupportsPriority, nsISupportsWeakReference)
////////////////////////////////////////////////////////////////////////////////
// nsIRequest methods:
NS_IMETHODIMP
nsLoadGroup::GetName(nsACString& result) {
// XXX is this the right "name" for a load group?
if (!mDefaultLoadRequest) {
result.Truncate();
return NS_OK;
}
return mDefaultLoadRequest->GetName(result);
}
NS_IMETHODIMP
nsLoadGroup::IsPending(bool* aResult) {
*aResult = (mForegroundCount > 0) ? true : false;
return NS_OK;
}
NS_IMETHODIMP
nsLoadGroup::GetStatus(nsresult* status) {
if (NS_SUCCEEDED(mStatus) && mDefaultLoadRequest)
return mDefaultLoadRequest->GetStatus(status);
*status = mStatus;
return NS_OK;
}
static bool AppendRequestsToArray(PLDHashTable* aTable,
nsTArray<nsIRequest*>* aArray) {
for (auto iter = aTable->Iter(); !iter.Done(); iter.Next()) {
auto e = static_cast<RequestMapEntry*>(iter.Get());
nsIRequest* request = e->mKey;
NS_ASSERTION(request, "What? Null key in PLDHashTable entry?");
bool ok = !!aArray->AppendElement(request);
if (!ok) {
break;
}
NS_ADDREF(request);
}
if (aArray->Length() != aTable->EntryCount()) {
for (uint32_t i = 0, len = aArray->Length(); i < len; ++i) {
NS_RELEASE((*aArray)[i]);
}
return false;
}
return true;
}
NS_IMETHODIMP
nsLoadGroup::Cancel(nsresult status) {
MOZ_ASSERT(NS_IsMainThread());
NS_ASSERTION(NS_FAILED(status), "shouldn't cancel with a success code");
nsresult rv;
uint32_t count = mRequests.EntryCount();
AutoTArray<nsIRequest*, 8> requests;
if (!AppendRequestsToArray(&mRequests, &requests)) {
return NS_ERROR_OUT_OF_MEMORY;
}
// set the load group status to our cancel status while we cancel
// all our requests...once the cancel is done, we'll reset it...
//
mStatus = status;
// Set the flag indicating that the loadgroup is being canceled... This
// prevents any new channels from being added during the operation.
//
mIsCanceling = true;
nsresult firstError = NS_OK;
while (count > 0) {
nsCOMPtr<nsIRequest> request = requests.ElementAt(--count);
NS_ASSERTION(request, "NULL request found in list.");
if (!mRequests.Search(request)) {
// |request| was removed already
// We need to null out the entry in the request array so we don't try
// to notify the observers for this request.
nsCOMPtr<nsIRequest> request = dont_AddRef(requests.ElementAt(count));
requests.ElementAt(count) = nullptr;
continue;
}
if (MOZ_LOG_TEST(gLoadGroupLog, LogLevel::Debug)) {
nsAutoCString nameStr;
request->GetName(nameStr);
LOG(("LOADGROUP [%p]: Canceling request %p %s.\n", this, request.get(),
nameStr.get()));
}
// Cancel the request...
rv = request->Cancel(status);
// Remember the first failure and return it...
if (NS_FAILED(rv) && NS_SUCCEEDED(firstError)) firstError = rv;
if (NS_FAILED(RemoveRequestFromHashtable(request, status))) {
// It's possible that request->Cancel causes the request to be removed
// from the loadgroup causing RemoveRequestFromHashtable to fail.
// In that case we shouldn't call NotifyRemovalObservers or decrement
// mForegroundCount since that has already happened.
nsCOMPtr<nsIRequest> request = dont_AddRef(requests.ElementAt(count));
requests.ElementAt(count) = nullptr;
continue;
}
}
for (count = requests.Length(); count > 0;) {
nsCOMPtr<nsIRequest> request = dont_AddRef(requests.ElementAt(--count));
(void)NotifyRemovalObservers(request, status);
}
if (mRequestContext) {
Unused << mRequestContext->CancelTailPendingRequests(status);
}
#if defined(DEBUG)
NS_ASSERTION(mRequests.EntryCount() == 0, "Request list is not empty.");
NS_ASSERTION(mForegroundCount == 0, "Foreground URLs are active.");
#endif
mStatus = NS_OK;
mIsCanceling = false;
return firstError;
}
NS_IMETHODIMP
nsLoadGroup::Suspend() {
nsresult rv, firstError;
uint32_t count = mRequests.EntryCount();
AutoTArray<nsIRequest*, 8> requests;
if (!AppendRequestsToArray(&mRequests, &requests)) {
return NS_ERROR_OUT_OF_MEMORY;
}
firstError = NS_OK;
//
// Operate the elements from back to front so that if items get
// get removed from the list it won't affect our iteration
//
while (count > 0) {
nsCOMPtr<nsIRequest> request = dont_AddRef(requests.ElementAt(--count));
NS_ASSERTION(request, "NULL request found in list.");
if (!request) continue;
if (MOZ_LOG_TEST(gLoadGroupLog, LogLevel::Debug)) {
nsAutoCString nameStr;
request->GetName(nameStr);
LOG(("LOADGROUP [%p]: Suspending request %p %s.\n", this, request.get(),
nameStr.get()));
}
// Suspend the request...
rv = request->Suspend();
// Remember the first failure and return it...
if (NS_FAILED(rv) && NS_SUCCEEDED(firstError)) firstError = rv;
}
return firstError;
}
NS_IMETHODIMP
nsLoadGroup::Resume() {
nsresult rv, firstError;
uint32_t count = mRequests.EntryCount();
AutoTArray<nsIRequest*, 8> requests;
if (!AppendRequestsToArray(&mRequests, &requests)) {
return NS_ERROR_OUT_OF_MEMORY;
}
firstError = NS_OK;
//
// Operate the elements from back to front so that if items get
// get removed from the list it won't affect our iteration
//
while (count > 0) {
nsCOMPtr<nsIRequest> request = dont_AddRef(requests.ElementAt(--count));
NS_ASSERTION(request, "NULL request found in list.");
if (!request) continue;
if (MOZ_LOG_TEST(gLoadGroupLog, LogLevel::Debug)) {
nsAutoCString nameStr;
request->GetName(nameStr);
LOG(("LOADGROUP [%p]: Resuming request %p %s.\n", this, request.get(),
nameStr.get()));
}
// Resume the request...
rv = request->Resume();
// Remember the first failure and return it...
if (NS_FAILED(rv) && NS_SUCCEEDED(firstError)) firstError = rv;
}
return firstError;
}
NS_IMETHODIMP
nsLoadGroup::GetLoadFlags(uint32_t* aLoadFlags) {
*aLoadFlags = mLoadFlags;
return NS_OK;
}
NS_IMETHODIMP
nsLoadGroup::SetLoadFlags(uint32_t aLoadFlags) {
mLoadFlags = aLoadFlags;
return NS_OK;
}
NS_IMETHODIMP
nsLoadGroup::GetLoadGroup(nsILoadGroup** loadGroup) {
nsCOMPtr<nsILoadGroup> result = mLoadGroup;
result.forget(loadGroup);
return NS_OK;
}
NS_IMETHODIMP
nsLoadGroup::SetLoadGroup(nsILoadGroup* loadGroup) {
mLoadGroup = loadGroup;
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
// nsILoadGroup methods:
NS_IMETHODIMP
nsLoadGroup::GetDefaultLoadRequest(nsIRequest** aRequest) {
nsCOMPtr<nsIRequest> result = mDefaultLoadRequest;
result.forget(aRequest);
return NS_OK;
}
NS_IMETHODIMP
nsLoadGroup::SetDefaultLoadRequest(nsIRequest* aRequest) {
LOG(("nsLoadGroup::SetDefaultLoadRequest this=%p default-request=%p", this,
aRequest));
mDefaultLoadRequest = aRequest;
// Inherit the group load flags from the default load request
if (mDefaultLoadRequest) {
mDefaultLoadRequest->GetLoadFlags(&mLoadFlags);
//
// Mask off any bits that are not part of the nsIRequest flags.
// in particular, nsIChannel::LOAD_DOCUMENT_URI...
//
mLoadFlags &= nsIRequest::LOAD_REQUESTMASK;
nsCOMPtr<nsITimedChannel> timedChannel = do_QueryInterface(aRequest);
mDefaultLoadIsTimed = timedChannel != nullptr;
if (mDefaultLoadIsTimed) {
timedChannel->GetChannelCreation(&mDefaultRequestCreationTime);
timedChannel->SetTimingEnabled(true);
}
}
// Else, do not change the group's load flags (see bug 95981)
return NS_OK;
}
NS_IMETHODIMP
nsLoadGroup::AddRequest(nsIRequest* request, nsISupports* ctxt) {
nsresult rv;
if (MOZ_LOG_TEST(gLoadGroupLog, LogLevel::Debug)) {
nsAutoCString nameStr;
request->GetName(nameStr);
LOG(("LOADGROUP [%p]: Adding request %p %s (count=%d).\n", this, request,
nameStr.get(), mRequests.EntryCount()));
}
NS_ASSERTION(!mRequests.Search(request),
"Entry added to loadgroup twice, don't do that");
//
// Do not add the channel, if the loadgroup is being canceled...
//
if (mIsCanceling) {
LOG(
("LOADGROUP [%p]: AddChannel() ABORTED because LoadGroup is"
" being canceled!!\n",
this));
return NS_BINDING_ABORTED;
}
nsLoadFlags flags;
// if the request is the default load request or if the default load
// request is null, then the load group should inherit its load flags from
// the request, but also we need to enforce defaultLoadFlags.
if (mDefaultLoadRequest == request || !mDefaultLoadRequest) {
rv = MergeDefaultLoadFlags(request, flags);
} else {
rv = MergeLoadFlags(request, flags);
}
if (NS_FAILED(rv)) return rv;
//
// Add the request to the list of active requests...
//
auto entry = static_cast<RequestMapEntry*>(mRequests.Add(request, fallible));
if (!entry) {
return NS_ERROR_OUT_OF_MEMORY;
}
if (mPriority != 0) RescheduleRequest(request, mPriority);
nsCOMPtr<nsITimedChannel> timedChannel = do_QueryInterface(request);
if (timedChannel) timedChannel->SetTimingEnabled(true);
if (!(flags & nsIRequest::LOAD_BACKGROUND)) {
// Update the count of foreground URIs..
mForegroundCount += 1;
//
// Fire the OnStartRequest notification out to the observer...
//
// If the notification fails then DO NOT add the request to
// the load group.
//
nsCOMPtr<nsIRequestObserver> observer = do_QueryReferent(mObserver);
if (observer) {
LOG(
("LOADGROUP [%p]: Firing OnStartRequest for request %p."
"(foreground count=%d).\n",
this, request, mForegroundCount));
rv = observer->OnStartRequest(request);
if (NS_FAILED(rv)) {
LOG(("LOADGROUP [%p]: OnStartRequest for request %p FAILED.\n", this,
request));
//
// The URI load has been canceled by the observer. Clean up
// the damage...
//
mRequests.Remove(request);
rv = NS_OK;
mForegroundCount -= 1;
}
}
// Ensure that we're part of our loadgroup while pending
if (mForegroundCount == 1 && mLoadGroup) {
mLoadGroup->AddRequest(this, nullptr);
}
}
return rv;
}
NS_IMETHODIMP
nsLoadGroup::RemoveRequest(nsIRequest* request, nsISupports* ctxt,
nsresult aStatus) {
// Make sure we have a owning reference to the request we're about
// to remove.
nsCOMPtr<nsIRequest> kungFuDeathGrip(request);
nsresult rv = RemoveRequestFromHashtable(request, aStatus);
if (NS_FAILED(rv)) {
return rv;
}
return NotifyRemovalObservers(request, aStatus);
}
nsresult nsLoadGroup::RemoveRequestFromHashtable(nsIRequest* request,
nsresult aStatus) {
NS_ENSURE_ARG_POINTER(request);
nsresult rv;
if (MOZ_LOG_TEST(gLoadGroupLog, LogLevel::Debug)) {
nsAutoCString nameStr;
request->GetName(nameStr);
LOG(("LOADGROUP [%p]: Removing request %p %s status %" PRIx32
" (count=%d).\n",
this, request, nameStr.get(), static_cast<uint32_t>(aStatus),
mRequests.EntryCount() - 1));
}
//
// Remove the request from the group. If this fails, it means that
// the request was *not* in the group so do not update the foreground
// count or it will get messed up...
//
auto entry = static_cast<RequestMapEntry*>(mRequests.Search(request));
if (!entry) {
LOG(("LOADGROUP [%p]: Unable to remove request %p. Not in group!\n", this,
request));
return NS_ERROR_FAILURE;
}
mRequests.RemoveEntry(entry);
// Collect telemetry stats only when default request is a timed channel.
// Don't include failed requests in the timing statistics.
if (mDefaultLoadIsTimed && NS_SUCCEEDED(aStatus)) {
nsCOMPtr<nsITimedChannel> timedChannel = do_QueryInterface(request);
if (timedChannel) {
// Figure out if this request was served from the cache
++mTimedRequests;
TimeStamp timeStamp;
rv = timedChannel->GetCacheReadStart(&timeStamp);
if (NS_SUCCEEDED(rv) && !timeStamp.IsNull()) {
++mCachedRequests;
}
rv = timedChannel->GetAsyncOpen(&timeStamp);
if (NS_SUCCEEDED(rv) && !timeStamp.IsNull()) {
Telemetry::AccumulateTimeDelta(
Telemetry::HTTP_SUBITEM_OPEN_LATENCY_TIME,
mDefaultRequestCreationTime, timeStamp);
}
rv = timedChannel->GetResponseStart(&timeStamp);
if (NS_SUCCEEDED(rv) && !timeStamp.IsNull()) {
Telemetry::AccumulateTimeDelta(
Telemetry::HTTP_SUBITEM_FIRST_BYTE_LATENCY_TIME,
mDefaultRequestCreationTime, timeStamp);
}
TelemetryReportChannel(timedChannel, false);
}
}
if (mRequests.EntryCount() == 0) {
TelemetryReport();
}
return NS_OK;
}
nsresult nsLoadGroup::NotifyRemovalObservers(nsIRequest* request,
nsresult aStatus) {
NS_ENSURE_ARG_POINTER(request);
// Undo any group priority delta...
if (mPriority != 0) RescheduleRequest(request, -mPriority);
nsLoadFlags flags;
nsresult rv = request->GetLoadFlags(&flags);
if (NS_FAILED(rv)) return rv;
if (!(flags & nsIRequest::LOAD_BACKGROUND)) {
NS_ASSERTION(mForegroundCount > 0, "ForegroundCount messed up");
mForegroundCount -= 1;
// Fire the OnStopRequest out to the observer...
nsCOMPtr<nsIRequestObserver> observer = do_QueryReferent(mObserver);
if (observer) {
LOG(
("LOADGROUP [%p]: Firing OnStopRequest for request %p."
"(foreground count=%d).\n",
this, request, mForegroundCount));
rv = observer->OnStopRequest(request, aStatus);
if (NS_FAILED(rv)) {
LOG(("LOADGROUP [%p]: OnStopRequest for request %p FAILED.\n", this,
request));
}
}
// If that was the last request -> remove ourselves from loadgroup
if (mForegroundCount == 0 && mLoadGroup) {
mLoadGroup->RemoveRequest(this, nullptr, aStatus);
}
}
return rv;
}
NS_IMETHODIMP
nsLoadGroup::GetRequests(nsISimpleEnumerator** aRequests) {
nsCOMArray<nsIRequest> requests;
requests.SetCapacity(mRequests.EntryCount());
for (auto iter = mRequests.Iter(); !iter.Done(); iter.Next()) {
auto e = static_cast<RequestMapEntry*>(iter.Get());
requests.AppendObject(e->mKey);
}
return NS_NewArrayEnumerator(aRequests, requests, NS_GET_IID(nsIRequest));
}
NS_IMETHODIMP
nsLoadGroup::SetGroupObserver(nsIRequestObserver* aObserver) {
mObserver = do_GetWeakReference(aObserver);
return NS_OK;
}
NS_IMETHODIMP
nsLoadGroup::GetGroupObserver(nsIRequestObserver** aResult) {
nsCOMPtr<nsIRequestObserver> observer = do_QueryReferent(mObserver);
observer.forget(aResult);
return NS_OK;
}
NS_IMETHODIMP
nsLoadGroup::GetActiveCount(uint32_t* aResult) {
*aResult = mForegroundCount;
return NS_OK;
}
NS_IMETHODIMP
nsLoadGroup::GetNotificationCallbacks(nsIInterfaceRequestor** aCallbacks) {
NS_ENSURE_ARG_POINTER(aCallbacks);
nsCOMPtr<nsIInterfaceRequestor> callbacks = mCallbacks;
callbacks.forget(aCallbacks);
return NS_OK;
}
NS_IMETHODIMP
nsLoadGroup::SetNotificationCallbacks(nsIInterfaceRequestor* aCallbacks) {
mCallbacks = aCallbacks;
return NS_OK;
}
NS_IMETHODIMP
nsLoadGroup::GetRequestContextID(uint64_t* aRCID) {
if (!mRequestContext) {
return NS_ERROR_NOT_AVAILABLE;
}
*aRCID = mRequestContext->GetID();
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
// nsILoadGroupChild methods:
NS_IMETHODIMP
nsLoadGroup::GetParentLoadGroup(nsILoadGroup** aParentLoadGroup) {
*aParentLoadGroup = nullptr;
nsCOMPtr<nsILoadGroup> parent = do_QueryReferent(mParentLoadGroup);
if (!parent) return NS_OK;
parent.forget(aParentLoadGroup);
return NS_OK;
}
NS_IMETHODIMP
nsLoadGroup::SetParentLoadGroup(nsILoadGroup* aParentLoadGroup) {
mParentLoadGroup = do_GetWeakReference(aParentLoadGroup);
return NS_OK;
}
NS_IMETHODIMP
nsLoadGroup::GetChildLoadGroup(nsILoadGroup** aChildLoadGroup) {
NS_ADDREF(*aChildLoadGroup = this);
return NS_OK;
}
NS_IMETHODIMP
nsLoadGroup::GetRootLoadGroup(nsILoadGroup** aRootLoadGroup) {
// first recursively try the root load group of our parent
nsCOMPtr<nsILoadGroupChild> ancestor = do_QueryReferent(mParentLoadGroup);
if (ancestor) return ancestor->GetRootLoadGroup(aRootLoadGroup);
// next recursively try the root load group of our own load grop
ancestor = do_QueryInterface(mLoadGroup);
if (ancestor) return ancestor->GetRootLoadGroup(aRootLoadGroup);
// finally just return this
NS_ADDREF(*aRootLoadGroup = this);
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
// nsISupportsPriority methods:
NS_IMETHODIMP
nsLoadGroup::GetPriority(int32_t* aValue) {
*aValue = mPriority;
return NS_OK;
}
NS_IMETHODIMP
nsLoadGroup::SetPriority(int32_t aValue) {
return AdjustPriority(aValue - mPriority);
}
NS_IMETHODIMP
nsLoadGroup::AdjustPriority(int32_t aDelta) {
// Update the priority for each request that supports nsISupportsPriority
if (aDelta != 0) {
mPriority += aDelta;
for (auto iter = mRequests.Iter(); !iter.Done(); iter.Next()) {
auto e = static_cast<RequestMapEntry*>(iter.Get());
RescheduleRequest(e->mKey, aDelta);
}
}
return NS_OK;
}
NS_IMETHODIMP
nsLoadGroup::GetDefaultLoadFlags(uint32_t* aFlags) {
*aFlags = mDefaultLoadFlags;
return NS_OK;
}
NS_IMETHODIMP
nsLoadGroup::SetDefaultLoadFlags(uint32_t aFlags) {
mDefaultLoadFlags = aFlags;
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
void nsLoadGroup::TelemetryReport() {
nsresult defaultStatus = NS_ERROR_INVALID_ARG;
// We should only report HTTP_PAGE_* telemetry if the defaultRequest was
// actually successful.
if (mDefaultLoadRequest) {
mDefaultLoadRequest->GetStatus(&defaultStatus);
}
if (mDefaultLoadIsTimed && NS_SUCCEEDED(defaultStatus)) {
Telemetry::Accumulate(Telemetry::HTTP_REQUEST_PER_PAGE, mTimedRequests);
if (mTimedRequests) {
Telemetry::Accumulate(Telemetry::HTTP_REQUEST_PER_PAGE_FROM_CACHE,
mCachedRequests * 100 / mTimedRequests);
}
nsCOMPtr<nsITimedChannel> timedChannel =
do_QueryInterface(mDefaultLoadRequest);
if (timedChannel) TelemetryReportChannel(timedChannel, true);
}
mTimedRequests = 0;
mCachedRequests = 0;
mDefaultLoadIsTimed = false;
}
void nsLoadGroup::TelemetryReportChannel(nsITimedChannel* aTimedChannel,
bool aDefaultRequest) {
nsresult rv;
bool timingEnabled;
rv = aTimedChannel->GetTimingEnabled(&timingEnabled);
if (NS_FAILED(rv) || !timingEnabled) return;
TimeStamp asyncOpen;
rv = aTimedChannel->GetAsyncOpen(&asyncOpen);
// We do not check !asyncOpen.IsNull() bellow, prevent ASSERTIONs this way
if (NS_FAILED(rv) || asyncOpen.IsNull()) return;
TimeStamp cacheReadStart;
rv = aTimedChannel->GetCacheReadStart(&cacheReadStart);
if (NS_FAILED(rv)) return;
TimeStamp cacheReadEnd;
rv = aTimedChannel->GetCacheReadEnd(&cacheReadEnd);
if (NS_FAILED(rv)) return;
TimeStamp domainLookupStart;
rv = aTimedChannel->GetDomainLookupStart(&domainLookupStart);
if (NS_FAILED(rv)) return;
TimeStamp domainLookupEnd;
rv = aTimedChannel->GetDomainLookupEnd(&domainLookupEnd);
if (NS_FAILED(rv)) return;
TimeStamp connectStart;
rv = aTimedChannel->GetConnectStart(&connectStart);
if (NS_FAILED(rv)) return;
TimeStamp secureConnectionStart;
rv = aTimedChannel->GetSecureConnectionStart(&secureConnectionStart);
if (NS_FAILED(rv)) return;
TimeStamp connectEnd;
rv = aTimedChannel->GetConnectEnd(&connectEnd);
if (NS_FAILED(rv)) return;
TimeStamp requestStart;
rv = aTimedChannel->GetRequestStart(&requestStart);
if (NS_FAILED(rv)) return;
TimeStamp responseStart;
rv = aTimedChannel->GetResponseStart(&responseStart);
if (NS_FAILED(rv)) return;
TimeStamp responseEnd;
rv = aTimedChannel->GetResponseEnd(&responseEnd);
if (NS_FAILED(rv)) return;
#define HTTP_REQUEST_HISTOGRAMS(prefix) \
if (!domainLookupStart.IsNull()) { \
Telemetry::AccumulateTimeDelta(Telemetry::HTTP_##prefix##_DNS_ISSUE_TIME, \
asyncOpen, domainLookupStart); \
} \
\
if (!domainLookupStart.IsNull() && !domainLookupEnd.IsNull()) { \
Telemetry::AccumulateTimeDelta(Telemetry::HTTP_##prefix##_DNS_LOOKUP_TIME, \
domainLookupStart, domainLookupEnd); \
} \
\
if (!secureConnectionStart.IsNull() && !connectEnd.IsNull()) { \
Telemetry::AccumulateTimeDelta(Telemetry::HTTP_##prefix##_TLS_HANDSHAKE, \
secureConnectionStart, connectEnd); \
} \
\
if (!connectStart.IsNull() && !connectEnd.IsNull()) { \
Telemetry::AccumulateTimeDelta( \
Telemetry::HTTP_##prefix##_TCP_CONNECTION_2, connectStart, \
connectEnd); \
} \
\
if (!requestStart.IsNull() && !responseEnd.IsNull()) { \
Telemetry::AccumulateTimeDelta( \
Telemetry::HTTP_##prefix##_OPEN_TO_FIRST_SENT, asyncOpen, \
requestStart); \
\
Telemetry::AccumulateTimeDelta( \
Telemetry::HTTP_##prefix##_FIRST_SENT_TO_LAST_RECEIVED, requestStart, \
responseEnd); \
\
if (cacheReadStart.IsNull() && !responseStart.IsNull()) { \
Telemetry::AccumulateTimeDelta( \
Telemetry::HTTP_##prefix##_OPEN_TO_FIRST_RECEIVED, asyncOpen, \
responseStart); \
} \
} \
\
if (!cacheReadStart.IsNull() && !cacheReadEnd.IsNull()) { \
Telemetry::AccumulateTimeDelta( \
Telemetry::HTTP_##prefix##_OPEN_TO_FIRST_FROM_CACHE_V2, asyncOpen, \
cacheReadStart); \
\
Telemetry::AccumulateTimeDelta( \
Telemetry::HTTP_##prefix##_CACHE_READ_TIME_V2, cacheReadStart, \
cacheReadEnd); \
\
if (!requestStart.IsNull() && !responseEnd.IsNull()) { \
Telemetry::AccumulateTimeDelta(Telemetry::HTTP_##prefix##_REVALIDATION, \
requestStart, responseEnd); \
} \
} \
\
if (!cacheReadEnd.IsNull()) { \
Telemetry::AccumulateTimeDelta( \
Telemetry::HTTP_##prefix##_COMPLETE_LOAD_V2, asyncOpen, cacheReadEnd); \
Telemetry::AccumulateTimeDelta( \
Telemetry::HTTP_##prefix##_COMPLETE_LOAD_CACHED_V2, asyncOpen, \
cacheReadEnd); \
} else if (!responseEnd.IsNull()) { \
Telemetry::AccumulateTimeDelta( \
Telemetry::HTTP_##prefix##_COMPLETE_LOAD_V2, asyncOpen, responseEnd); \
Telemetry::AccumulateTimeDelta( \
Telemetry::HTTP_##prefix##_COMPLETE_LOAD_NET_V2, asyncOpen, \
responseEnd); \
}
if (aDefaultRequest) {
HTTP_REQUEST_HISTOGRAMS(PAGE)
} else {
HTTP_REQUEST_HISTOGRAMS(SUB)
}
#undef HTTP_REQUEST_HISTOGRAMS
}
nsresult nsLoadGroup::MergeLoadFlags(nsIRequest* aRequest,
nsLoadFlags& outFlags) {
nsresult rv;
nsLoadFlags flags, oldFlags;
rv = aRequest->GetLoadFlags(&flags);
if (NS_FAILED(rv)) {
return rv;
}
oldFlags = flags;
// Inherit the following bits...
flags |= (mLoadFlags &
(LOAD_BACKGROUND | LOAD_BYPASS_CACHE | LOAD_FROM_CACHE |
VALIDATE_ALWAYS | VALIDATE_ONCE_PER_SESSION | VALIDATE_NEVER));
// ... and force the default flags.
flags |= mDefaultLoadFlags;
if (flags != oldFlags) {
rv = aRequest->SetLoadFlags(flags);
}
outFlags = flags;
return rv;
}
nsresult nsLoadGroup::MergeDefaultLoadFlags(nsIRequest* aRequest,
nsLoadFlags& outFlags) {
nsresult rv;
nsLoadFlags flags, oldFlags;
rv = aRequest->GetLoadFlags(&flags);
if (NS_FAILED(rv)) {
return rv;
}
oldFlags = flags;
// ... and force the default flags.
flags |= mDefaultLoadFlags;
if (flags != oldFlags) {
rv = aRequest->SetLoadFlags(flags);
}
outFlags = flags;
return rv;
}
nsresult nsLoadGroup::Init() {
mRequestContextService = RequestContextService::GetOrCreate();
if (mRequestContextService) {
Unused << mRequestContextService->NewRequestContext(
getter_AddRefs(mRequestContext));
}
return NS_OK;
}
} // namespace net
} // namespace mozilla
#undef LOG
Reference in New Issue View Git Blame Copy Permalink