gecko-dev/netwerk/base/nsIOService.h
Kris Maglione 152af93226 Bug 1473631: Part 3 - Replace pref observers with callbacks in IOService. r=njn
MozReview-Commit-ID: BBNUysmOuZV

--HG--
extra : rebase_source : 204d4444deed66a34e029e794b4721cf93b33d72
2018-07-05 13:25:03 -07:00

236 lines
9.7 KiB
C++

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* 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 nsIOService_h__
#define nsIOService_h__
#include "nsStringFwd.h"
#include "nsIIOService.h"
#include "nsTArray.h"
#include "nsCOMPtr.h"
#include "nsWeakPtr.h"
#include "nsIObserver.h"
#include "nsWeakReference.h"
#include "nsINetUtil.h"
#include "nsIChannelEventSink.h"
#include "nsCategoryCache.h"
#include "nsISpeculativeConnect.h"
#include "nsDataHashtable.h"
#include "mozilla/Atomics.h"
#include "mozilla/Attributes.h"
#include "prtime.h"
#include "nsICaptivePortalService.h"
#define NS_N(x) (sizeof(x)/sizeof(*x))
// We don't want to expose this observer topic.
// Intended internal use only for remoting offline/inline events.
// See Bug 552829
#define NS_IPC_IOSERVICE_SET_OFFLINE_TOPIC "ipc:network:set-offline"
#define NS_IPC_IOSERVICE_SET_CONNECTIVITY_TOPIC "ipc:network:set-connectivity"
static const char gScheme[][sizeof("moz-safe-about")] =
{"chrome", "file", "http", "https", "jar", "data", "about", "moz-safe-about", "resource",
"moz-extension", "page-icon", "blob"};
static const char gForcedExternalSchemes[][sizeof("moz-nullprincipal")] =
{"place", "fake-favicon-uri", "favicon", "moz-nullprincipal"};
class nsINetworkLinkService;
class nsIPrefBranch;
class nsIProtocolProxyService2;
class nsIProxyInfo;
class nsPISocketTransportService;
namespace mozilla {
namespace net {
class NeckoChild;
class nsAsyncRedirectVerifyHelper;
class nsIOService final : public nsIIOService
, public nsIObserver
, public nsINetUtil
, public nsISpeculativeConnect
, public nsSupportsWeakReference
, public nsIIOServiceInternal
{
public:
NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIIOSERVICE
NS_DECL_NSIOBSERVER
NS_DECL_NSINETUTIL
NS_DECL_NSISPECULATIVECONNECT
NS_DECL_NSIIOSERVICEINTERNAL
// Gets the singleton instance of the IO Service, creating it as needed
// Returns nullptr on out of memory or failure to initialize.
static already_AddRefed<nsIOService> GetInstance();
nsresult Init();
nsresult NewURI(const char* aSpec, nsIURI* aBaseURI,
nsIURI* *result,
nsIProtocolHandler* *hdlrResult);
// Called by channels before a redirect happens. This notifies the global
// redirect observers.
nsresult AsyncOnChannelRedirect(nsIChannel* oldChan, nsIChannel* newChan,
uint32_t flags,
nsAsyncRedirectVerifyHelper *helper);
bool IsOffline() { return mOffline; }
PRIntervalTime LastOfflineStateChange() { return mLastOfflineStateChange; }
PRIntervalTime LastConnectivityChange() { return mLastConnectivityChange; }
PRIntervalTime LastNetworkLinkChange() { return mLastNetworkLinkChange; }
bool IsNetTearingDown() { return mShutdown || mOfflineForProfileChange ||
mHttpHandlerAlreadyShutingDown; }
PRIntervalTime NetTearingDownStarted() { return mNetTearingDownStarted; }
// nsHttpHandler is going to call this function to inform nsIOService that network
// is in process of tearing down. Moving nsHttpConnectionMgr::Shutdown to nsIOService
// caused problems (bug 1242755) so we doing it in this way.
// As soon as nsIOService gets notification that it is shutdown it is going to
// reset mHttpHandlerAlreadyShutingDown.
void SetHttpHandlerAlreadyShutingDown();
bool IsLinkUp();
static bool IsDataURIUniqueOpaqueOrigin();
static bool BlockToplevelDataUriNavigations();
static bool BlockFTPSubresources();
// Used to count the total number of HTTP requests made
void IncrementRequestNumber() { mTotalRequests++; }
uint32_t GetTotalRequestNumber() { return mTotalRequests; }
// Used to keep "race cache with network" stats
void IncrementCacheWonRequestNumber() { mCacheWon++; }
uint32_t GetCacheWonRequestNumber() { return mCacheWon; }
void IncrementNetWonRequestNumber() { mNetWon++; }
uint32_t GetNetWonRequestNumber() { return mNetWon; }
// Used to trigger a recheck of the captive portal status
nsresult RecheckCaptivePortal();
private:
// These shouldn't be called directly:
// - construct using GetInstance
// - destroy using Release
nsIOService();
~nsIOService();
nsresult SetConnectivityInternal(bool aConnectivity);
nsresult OnNetworkLinkEvent(const char *data);
nsresult GetCachedProtocolHandler(const char *scheme,
nsIProtocolHandler* *hdlrResult,
uint32_t start=0,
uint32_t end=0);
nsresult CacheProtocolHandler(const char *scheme,
nsIProtocolHandler* hdlr);
nsresult InitializeCaptivePortalService();
nsresult RecheckCaptivePortalIfLocalRedirect(nsIChannel* newChan);
// Prefs wrangling
void PrefsChanged(const char *pref = nullptr);
void ParsePortList(const char *pref, bool remove);
nsresult InitializeSocketTransportService();
nsresult InitializeNetworkLinkService();
nsresult InitializeProtocolProxyService();
// consolidated helper function
void LookupProxyInfo(nsIURI *aURI, nsIURI *aProxyURI, uint32_t aProxyFlags,
nsCString *aScheme, nsIProxyInfo **outPI);
nsresult NewChannelFromURIWithProxyFlagsInternal(nsIURI* aURI,
nsIURI* aProxyURI,
uint32_t aProxyFlags,
nsINode* aLoadingNode,
nsIPrincipal* aLoadingPrincipal,
nsIPrincipal* aTriggeringPrincipal,
const mozilla::Maybe<mozilla::dom::ClientInfo>& aLoadingClientInfo,
const mozilla::Maybe<mozilla::dom::ServiceWorkerDescriptor>& aController,
uint32_t aSecurityFlags,
uint32_t aContentPolicyType,
nsIChannel** result);
nsresult NewChannelFromURIWithProxyFlagsInternal(nsIURI* aURI,
nsIURI* aProxyURI,
uint32_t aProxyFlags,
nsILoadInfo* aLoadInfo,
nsIChannel** result);
nsresult SpeculativeConnectInternal(nsIURI *aURI,
nsIPrincipal *aPrincipal,
nsIInterfaceRequestor *aCallbacks,
bool aAnonymous);
private:
bool mOffline;
mozilla::Atomic<bool, mozilla::Relaxed> mOfflineForProfileChange;
bool mManageLinkStatus;
bool mConnectivity;
// If true, the connectivity state will be mirrored by IOService.offline
// meaning if !mConnectivity, GetOffline() will return true
bool mOfflineMirrorsConnectivity;
// Used to handle SetOffline() reentrancy. See the comment in
// SetOffline() for more details.
bool mSettingOffline;
bool mSetOfflineValue;
mozilla::Atomic<bool, mozilla::Relaxed> mShutdown;
mozilla::Atomic<bool, mozilla::Relaxed> mHttpHandlerAlreadyShutingDown;
nsCOMPtr<nsPISocketTransportService> mSocketTransportService;
nsCOMPtr<nsICaptivePortalService> mCaptivePortalService;
nsCOMPtr<nsINetworkLinkService> mNetworkLinkService;
bool mNetworkLinkServiceInitialized;
// Cached protocol handlers, only accessed on the main thread
nsWeakPtr mWeakHandler[NS_N(gScheme)];
// cached categories
nsCategoryCache<nsIChannelEventSink> mChannelEventSinks;
nsTArray<int32_t> mRestrictedPortList;
bool mNetworkNotifyChanged;
static bool sIsDataURIUniqueOpaqueOrigin;
static bool sBlockToplevelDataUriNavigations;
static bool sBlockFTPSubresources;
uint32_t mTotalRequests;
uint32_t mCacheWon;
uint32_t mNetWon;
// These timestamps are needed for collecting telemetry on PR_Connect,
// PR_ConnectContinue and PR_Close blocking time. If we spend very long
// time in any of these functions we want to know if and what network
// change has happened shortly before.
mozilla::Atomic<PRIntervalTime> mLastOfflineStateChange;
mozilla::Atomic<PRIntervalTime> mLastConnectivityChange;
mozilla::Atomic<PRIntervalTime> mLastNetworkLinkChange;
// Time a network tearing down started.
mozilla::Atomic<PRIntervalTime> mNetTearingDownStarted;
public:
// Used for all default buffer sizes that necko allocates.
static uint32_t gDefaultSegmentSize;
static uint32_t gDefaultSegmentCount;
};
/**
* Reference to the IO service singleton. May be null.
*/
extern nsIOService* gIOService;
} // namespace net
} // namespace mozilla
#endif // nsIOService_h__