/* 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 "nsICacheStorageService.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 final

  : 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, bool isTracking);

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() = default;

  private:

    virtual ~DNSListener() = default;

  };

  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() = default;

    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, bool isTracking, bool couldVary,

                       bool isNoStore, Predictor *predictor)

      :mTargetURI(targetURI)

      ,mHttpStatus(httpStatus)

      ,mMethod(method)

      ,mIsTracking(isTracking)

      ,mCouldVary(couldVary)

      ,mIsNoStore(isNoStore)

      ,mPredictor(predictor)

    { }

  private:

    virtual ~CacheabilityAction() = default;

    nsCOMPtr<nsIURI> mTargetURI;

    uint32_t mHttpStatus;

    nsCString mMethod;

    bool mIsTracking;

    bool mCouldVary;

    bool mIsNoStore;

    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() = default;

    void Complete();

    uint32_t mEntriesToVisit;

    nsTArray<nsCString> mKeysToDelete;

    RefPtr<Predictor> mPredictor;

    nsTArray<nsCOMPtr<nsIURI>> mURIsToVisit;

    nsTArray<nsCOMPtr<nsILoadContextInfo>> mInfosToVisit;

  };

  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() = default;

    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() = default;

    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

  //   * originAttributes - the originAttributes for this prediction

  //   * verifier - used for testing to verify the expected predictions happen

  void PredictForLink(nsIURI *targetURI,

                      nsIURI *sourceURI,

                      const OriginAttributes& originAttributes,

                      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);

  enum PrefetchIgnoreReason {

    PREFETCH_OK,

    NOT_FULL_URI,

    NO_REFERRER,

    MISSED_A_LOAD,

    PREFETCH_DISABLED,

    PREFETCH_DISABLED_VIA_COUNT,

    CONFIDENCE_TOO_LOW

  };

  // 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 ascii spec of the URI of the resource

  void SetupPrediction(int32_t confidence, uint32_t flags, const nsCString &uri,

                       PrefetchIgnoreReason reason);

  // Used to kick off a prefetch from RunPredictions if necessary

  //   * uri - the URI to prefetch

  //   * referrer - the URI of the referring page

  //   * originAttributes - the originAttributes of this prefetch

  //   * verifier - used for testing to ensure the expected prefetch happens

  nsresult Prefetch(nsIURI *uri, nsIURI *referrer,

                    const OriginAttributes& originAttributes,

                    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

  //   * originAttributs - the originAttributes we are predicting from

  //   * verifier - used for testing to ensure the expected predictions happen

  bool RunPredictions(nsIURI *referrer,

                      const OriginAttributes& originAttributes,

                      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

  //   * originAttributes - the originAttributes for this learning.

  void MaybeLearnForStartup(nsIURI *uri, bool fullUri,

                            const OriginAttributes& originAttributes);

  // 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 ascii spec of 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, nsCString &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,

                                  const OriginAttributes& originAttributes,

                                  bool isTracking, bool couldVary,

                                  bool isNoStore);

  // Gets the pref value and clamps it within the acceptable range.

  uint32_t ClampedPrefetchRollingLoadCount();

  // Our state

  bool mInitialized;

  bool mCleanedUp;

  nsCOMPtr<nsITimer> mCleanupTimer;

  nsTArray<nsCString> mKeysToOperateOn;

  nsTArray<nsCString> mValuesToOperateOn;

  nsCOMPtr<nsICacheStorageService> mCacheStorageService;

  nsCOMPtr<nsIIOService> mIOService;

  nsCOMPtr<nsISpeculativeConnect> mSpeculativeService;

  nsCOMPtr<nsIURI> mStartupURI;

  uint32_t mStartupTime;

  uint32_t mLastStartupTime;

  int32_t mStartupCount;

  nsCOMPtr<nsIDNSService> mDnsService;

  RefPtr<DNSListener> mDNSListener;

  nsTArray<nsCOMPtr<nsIURI>> mPrefetches;

  nsTArray<nsCOMPtr<nsIURI>> mPreconnects;

  nsTArray<nsCOMPtr<nsIURI>> mPreresolves;

  static Predictor *sSelf;

};

} // namespace net

} // namespace mozilla

#endif // mozilla_net_Predictor_h