gecko-dev/netwerk/base/Predictor.h

481 строка
17 KiB
C++

/* vim: set ts=2 sts=2 et sw=2: */
/* 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_Predictor_h
#define mozilla_net_Predictor_h
#include "nsINetworkPredictor.h"
#include "nsINetworkPredictorVerifier.h"
#include "nsCOMPtr.h"
#include "nsICacheEntry.h"
#include "nsICacheEntryOpenCallback.h"
#include "nsICacheStorageVisitor.h"
#include "nsIDNSListener.h"
#include "nsIInterfaceRequestor.h"
#include "nsIObserver.h"
#include "nsISpeculativeConnect.h"
#include "nsIStreamListener.h"
#include "mozilla/RefPtr.h"
#include "nsString.h"
#include "nsTArray.h"
#include "mozilla/TimeStamp.h"
class nsICacheStorage;
class nsIDNSService;
class nsIIOService;
class nsILoadContextInfo;
class nsITimer;
namespace mozilla {
namespace net {
class nsHttpRequestHead;
class nsHttpResponseHead;
class Predictor : public nsINetworkPredictor
, public nsIObserver
, public nsISpeculativeConnectionOverrider
, public nsIInterfaceRequestor
, public nsICacheEntryMetaDataVisitor
, public nsINetworkPredictorVerifier
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSINETWORKPREDICTOR
NS_DECL_NSIOBSERVER
NS_DECL_NSISPECULATIVECONNECTIONOVERRIDER
NS_DECL_NSIINTERFACEREQUESTOR
NS_DECL_NSICACHEENTRYMETADATAVISITOR
NS_DECL_NSINETWORKPREDICTORVERIFIER
Predictor();
nsresult Init();
void Shutdown();
static nsresult Create(nsISupports *outer, const nsIID& iid, void **result);
// Used to update whether a particular URI was cacheable or not.
// sourceURI and targetURI are the same as the arguments to Learn
// and httpStatus is the status code we got while loading targetURI.
static void UpdateCacheability(nsIURI *sourceURI, nsIURI *targetURI,
uint32_t httpStatus,
nsHttpRequestHead &requestHead,
nsHttpResponseHead *reqponseHead,
nsILoadContextInfo *lci);
private:
virtual ~Predictor();
// Stores callbacks for a child process predictor (for test purposes)
nsCOMPtr<nsINetworkPredictorVerifier> mChildVerifier;
union Reason {
PredictorLearnReason mLearn;
PredictorPredictReason mPredict;
};
class DNSListener : public nsIDNSListener
{
public:
NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIDNSLISTENER
DNSListener()
{ }
private:
virtual ~DNSListener()
{ }
};
class Action : public nsICacheEntryOpenCallback
{
public:
NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSICACHEENTRYOPENCALLBACK
Action(bool fullUri, bool predict, Reason reason,
nsIURI *targetURI, nsIURI *sourceURI,
nsINetworkPredictorVerifier *verifier, Predictor *predictor);
Action(bool fullUri, bool predict, Reason reason,
nsIURI *targetURI, nsIURI *sourceURI,
nsINetworkPredictorVerifier *verifier, Predictor *predictor,
uint8_t stackCount);
static const bool IS_FULL_URI = true;
static const bool IS_ORIGIN = false;
static const bool DO_PREDICT = true;
static const bool DO_LEARN = false;
private:
virtual ~Action();
bool mFullUri : 1;
bool mPredict : 1;
union {
PredictorPredictReason mPredictReason;
PredictorLearnReason mLearnReason;
};
nsCOMPtr<nsIURI> mTargetURI;
nsCOMPtr<nsIURI> mSourceURI;
nsCOMPtr<nsINetworkPredictorVerifier> mVerifier;
TimeStamp mStartTime;
uint8_t mStackCount;
RefPtr<Predictor> mPredictor;
};
class CacheabilityAction : public nsICacheEntryOpenCallback
, public nsICacheEntryMetaDataVisitor
{
public:
NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSICACHEENTRYOPENCALLBACK
NS_DECL_NSICACHEENTRYMETADATAVISITOR
CacheabilityAction(nsIURI *targetURI, uint32_t httpStatus,
const nsCString &method, Predictor *predictor)
:mTargetURI(targetURI)
,mHttpStatus(httpStatus)
,mMethod(method)
,mPredictor(predictor)
{ }
private:
virtual ~CacheabilityAction() { }
nsCOMPtr<nsIURI> mTargetURI;
uint32_t mHttpStatus;
nsCString mMethod;
RefPtr<Predictor> mPredictor;
nsTArray<nsCString> mKeysToCheck;
nsTArray<nsCString> mValuesToCheck;
};
class Resetter : public nsICacheEntryOpenCallback,
public nsICacheEntryMetaDataVisitor,
public nsICacheStorageVisitor
{
public:
NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSICACHEENTRYOPENCALLBACK
NS_DECL_NSICACHEENTRYMETADATAVISITOR
NS_DECL_NSICACHESTORAGEVISITOR
explicit Resetter(Predictor *predictor);
private:
virtual ~Resetter() { }
void Complete();
uint32_t mEntriesToVisit;
nsTArray<nsCString> mKeysToDelete;
RefPtr<Predictor> mPredictor;
nsTArray<nsCOMPtr<nsIURI>> mURIsToVisit;
};
class SpaceCleaner : public nsICacheEntryMetaDataVisitor
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSICACHEENTRYMETADATAVISITOR
explicit SpaceCleaner(Predictor *predictor)
:mLRUStamp(0)
,mLRUKeyToDelete(nullptr)
,mPredictor(predictor)
{ }
void Finalize(nsICacheEntry *entry);
private:
virtual ~SpaceCleaner() { }
uint32_t mLRUStamp;
const char *mLRUKeyToDelete;
nsTArray<nsCString> mLongKeysToDelete;
RefPtr<Predictor> mPredictor;
};
class PrefetchListener : public nsIStreamListener
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIREQUESTOBSERVER
NS_DECL_NSISTREAMLISTENER
PrefetchListener(nsINetworkPredictorVerifier *verifier, nsIURI *uri,
Predictor *predictor)
:mVerifier(verifier)
,mURI(uri)
,mPredictor(predictor)
{ }
private:
virtual ~PrefetchListener() { }
nsCOMPtr<nsINetworkPredictorVerifier> mVerifier;
nsCOMPtr<nsIURI> mURI;
RefPtr<Predictor> mPredictor;
TimeStamp mStartTime;
};
// Observer-related stuff
nsresult InstallObserver();
void RemoveObserver();
// Service startup utilities
void MaybeCleanupOldDBFiles();
// The guts of prediction
// This is the top-level driver for doing any prediction that needs
// information from the cache. Returns true if any predictions were queued up
// * reason - What kind of prediction this is/why this prediction is
// happening (pageload, startup)
// * entry - the cache entry with the information we need
// * isNew - whether or not the cache entry is brand new and empty
// * fullUri - whether we are doing predictions based on a full page URI, or
// just the origin of the page
// * targetURI - the URI that we are predicting based upon - IOW, the URI
// that is being loaded or being redirected to
// * verifier - used for testing to verify the expected predictions happen
// * stackCount - used to ensure we don't recurse too far trying to find the
// final redirection in a redirect chain
bool PredictInternal(PredictorPredictReason reason, nsICacheEntry *entry,
bool isNew, bool fullUri, nsIURI *targetURI,
nsINetworkPredictorVerifier *verifier,
uint8_t stackCount);
// Used when predicting because the user's mouse hovered over a link
// * targetURI - the URI target of the link
// * sourceURI - the URI of the page on which the link appears
// * verifier - used for testing to verify the expected predictions happen
void PredictForLink(nsIURI *targetURI,
nsIURI *sourceURI,
nsINetworkPredictorVerifier *verifier);
// Used when predicting because a page is being loaded (which may include
// being the target of a redirect). All arguments are the same as for
// PredictInternal. Returns true if any predictions were queued up.
bool PredictForPageload(nsICacheEntry *entry,
nsIURI *targetURI,
uint8_t stackCount,
bool fullUri,
nsINetworkPredictorVerifier *verifier);
// Used when predicting pages that will be used near browser startup. All
// arguments are the same as for PredictInternal. Returns true if any
// predictions were queued up.
bool PredictForStartup(nsICacheEntry *entry,
bool fullUri,
nsINetworkPredictorVerifier *verifier);
// Utilities related to prediction
// Used to update our rolling load count (how many of the last n loads was a
// partular resource loaded on?)
// * entry - cache entry of page we're loading
// * flags - value that contains our rolling count as the top 20 bits (but
// we may use fewer than those 20 bits for calculations)
// * key - metadata key that we will update on entry
// * hitCount - part of the metadata we need to preserve
// * lastHit - part of the metadata we need to preserve
void UpdateRollingLoadCount(nsICacheEntry *entry, const uint32_t flags,
const char *key, const uint32_t hitCount,
const uint32_t lastHit);
// Used to calculate how much to degrade our confidence for all resources
// on a particular page, because of how long ago the most recent load of that
// page was. Returns a value between 0 (very recent most recent load) and 100
// (very distant most recent load)
// * lastLoad - time stamp of most recent load of a page
int32_t CalculateGlobalDegradation(uint32_t lastLoad);
// Used to calculate how confident we are that a particular resource will be
// used. Returns a value between 0 (no confidence) and 100 (very confident)
// * hitCount - number of times this resource has been seen when loading
// this page
// * hitsPossible - number of times this page has been loaded
// * lastHit - timestamp of the last time this resource was seen when
// loading this page
// * lastPossible - timestamp of the last time this page was loaded
// * globalDegradation - value calculated by CalculateGlobalDegradation for
// this page
int32_t CalculateConfidence(uint32_t hitCount, uint32_t hitsPossible,
uint32_t lastHit, uint32_t lastPossible,
int32_t globalDegradation);
// Used to calculate all confidence values for all resources associated with a
// page.
// * entry - the cache entry with all necessary information about this page
// * referrer - the URI that we are loading (may be null)
// * lastLoad - timestamp of the last time this page was loaded
// * loadCount - number of times this page has been loaded
// * gloablDegradation - value calculated by CalculateGlobalDegradation for
// this page
// * fullUri - whether we're predicting for a full URI or origin-only
void CalculatePredictions(nsICacheEntry *entry, nsIURI *referrer,
uint32_t lastLoad, uint32_t loadCount,
int32_t globalDegradation, bool fullUri);
// Used to prepare any necessary prediction for a resource on a page
// * confidence - value calculated by CalculateConfidence for this resource
// * flags - the flags taken from the resource
// * uri - the URI of the resource
void SetupPrediction(int32_t confidence, uint32_t flags, nsIURI *uri);
// Used to kick off a prefetch from RunPredictions if necessary
// * uri - the URI to prefetch
// * referrer - the URI of the referring page
// * verifier - used for testing to ensure the expected prefetch happens
nsresult Prefetch(nsIURI *uri, nsIURI *referrer, nsINetworkPredictorVerifier *verifier);
// Used to actually perform any predictions set up via SetupPrediction.
// Returns true if any predictions were performed.
// * referrer - the URI we are predicting from
// * verifier - used for testing to ensure the expected predictions happen
bool RunPredictions(nsIURI *referrer, nsINetworkPredictorVerifier *verifier);
// Used to guess whether a page will redirect to another page or not. Returns
// true if a redirection is likely.
// * entry - cache entry with all necessary information about this page
// * loadCount - number of times this page has been loaded
// * lastLoad - timestamp of the last time this page was loaded
// * globalDegradation - value calculated by CalculateGlobalDegradation for
// this page
// * redirectURI - if this returns true, the URI that is likely to be
// redirected to, otherwise null
bool WouldRedirect(nsICacheEntry *entry, uint32_t loadCount,
uint32_t lastLoad, int32_t globalDegradation,
nsIURI **redirectURI);
// The guts of learning information
// This is the top-level driver for doing any updating of our information in
// the cache
// * reason - why this learn is happening (pageload, startup, redirect)
// * entry - the cache entry with the information we need
// * isNew - whether or not the cache entry is brand new and empty
// * fullUri - whether we are doing predictions based on a full page URI, or
// just the origin of the page
// * targetURI - the URI that we are adding to our data - most often a
// resource loaded by a page the user navigated to
// * sourceURI - the URI that caused targetURI to be loaded, usually the
// page the user navigated to
void LearnInternal(PredictorLearnReason reason, nsICacheEntry *entry,
bool isNew, bool fullUri, nsIURI *targetURI,
nsIURI *sourceURI);
// Used when learning about a resource loaded by a page
// * entry - the cache entry with information that needs updating
// * targetURI - the URI of the resource that was loaded by the page
void LearnForSubresource(nsICacheEntry *entry, nsIURI *targetURI);
// Used when learning about a redirect from one page to another
// * entry - the cache entry of the page that was redirected from
// * targetURI - the URI of the redirect target
void LearnForRedirect(nsICacheEntry *entry, nsIURI *targetURI);
// Used to learn about pages loaded close to browser startup. This results in
// LearnForStartup being called if we are, in fact, near browser startup
// * uri - the URI of a page that has been loaded (may not have been near
// browser startup)
// * fullUri - true if this is a full page uri, false if it's an origin
void MaybeLearnForStartup(nsIURI *uri, bool fullUri);
// Used in conjunction with MaybeLearnForStartup to learn about pages loaded
// close to browser startup
// * entry - the cache entry that stores the startup page list
// * targetURI - the URI of a page that was loaded near browser startup
void LearnForStartup(nsICacheEntry *entry, nsIURI *targetURI);
// Used to parse the data we store in cache metadata
// * key - the cache metadata key
// * value - the cache metadata value
// * uri - (out) the URI this metadata entry was about
// * hitCount - (out) the number of times this URI has been seen
// * lastHit - (out) timestamp of the last time this URI was seen
// * flags - (out) flags for this metadata entry
bool ParseMetaDataEntry(const char *key, const char *value, nsIURI **uri,
uint32_t &hitCount, uint32_t &lastHit,
uint32_t &flags);
// Used to update whether a particular URI was cacheable or not.
// sourceURI and targetURI are the same as the arguments to Learn
// and httpStatus is the status code we got while loading targetURI.
void UpdateCacheabilityInternal(nsIURI *sourceURI, nsIURI *targetURI,
uint32_t httpStatus, const nsCString &method);
// Make sure our prefs are in their expected range of values
void SanitizePrefs();
// Our state
bool mInitialized;
bool mEnabled;
bool mEnableHoverOnSSL;
bool mEnablePrefetch;
int32_t mPageDegradationDay;
int32_t mPageDegradationWeek;
int32_t mPageDegradationMonth;
int32_t mPageDegradationYear;
int32_t mPageDegradationMax;
int32_t mSubresourceDegradationDay;
int32_t mSubresourceDegradationWeek;
int32_t mSubresourceDegradationMonth;
int32_t mSubresourceDegradationYear;
int32_t mSubresourceDegradationMax;
int32_t mPrefetchRollingLoadCount;
int32_t mPrefetchMinConfidence;
int32_t mPreconnectMinConfidence;
int32_t mPreresolveMinConfidence;
int32_t mRedirectLikelyConfidence;
int32_t mPrefetchForceValidFor;
int32_t mMaxResourcesPerEntry;
bool mCleanedUp;
nsCOMPtr<nsITimer> mCleanupTimer;
nsTArray<nsCString> mKeysToOperateOn;
nsTArray<nsCString> mValuesToOperateOn;
nsCOMPtr<nsICacheStorage> mCacheDiskStorage;
nsCOMPtr<nsIIOService> mIOService;
nsCOMPtr<nsISpeculativeConnect> mSpeculativeService;
nsCOMPtr<nsIURI> mStartupURI;
uint32_t mStartupTime;
uint32_t mLastStartupTime;
int32_t mStartupCount;
uint32_t mMaxURILength;
nsCOMPtr<nsIDNSService> mDnsService;
RefPtr<DNSListener> mDNSListener;
nsTArray<nsCOMPtr<nsIURI>> mPrefetches;
nsTArray<nsCOMPtr<nsIURI>> mPreconnects;
nsTArray<nsCOMPtr<nsIURI>> mPreresolves;
bool mDoingTests;
static Predictor *sSelf;
};
} // namespace net
} // namespace mozilla
#endif // mozilla_net_Predictor_h