Quelle  ConnectionAttempt.h

/* 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 ConnectionAttempt_h_
#define ConnectionAttempt_h_

#include "mozilla/TimeStamp.h"
#include "nsWeakReference.h"

namespace mozilla {
namespace net {

class ConnectionEntry;
class DnsAndConnectSocket;
class nsAHttpTransaction;
class nsHttpConnectionInfo;
class nsHttpTransaction;

// ConnectionAttempt is an abstraction layer between the legacy
// DnsAndConnectSocket connection path and the new
// HappyEyeballsConnectionAttempt implementation.
//
// It allows us to switch between the old and new connection
// establishment logic without changing higher-level code.
//
// We intentionally keep the legacy implementation to support
// the NS_HTTP_BE_CONSERVATIVE flag. Requests with this flag
// continue to use the old connection path until we are fully
// confident that the new Happy Eyeballs implementation is
// stable. This serves as a risk-mitigation mechanism during
// rollout.
class ConnectionAttempt : public nsSupportsWeakReference {
 public:
  NS_DECL_THREADSAFE_ISUPPORTS

  explicit ConnectionAttempt(nsHttpConnectionInfo* ci,
                             nsAHttpTransaction* trans, uint32_t caps,
                             bool speculative, bool urgentStart);

  virtual nsresult Init(ConnectionEntry* ent) = 0;
  // Cancel this connection attempt and release resources.
  virtual void Abandon() = 0;
  virtual double Duration(TimeStamp epoch) = 0;
  bool AcceptsTransaction(nsHttpTransaction* trans) const;
  virtual bool Claim(nsHttpTransaction* newTransaction = nullptr) = 0;
  // HE attempts are 1:1 owned by their creator transaction, and re-flipping
  // mFreeToUse to true on an HE that already has a real mTransaction lets
  // a *different* transaction Claim it without `Claim()` actually rebinding
  // the ownership — the new claimer ends up "remembered" by an HE that
  // doesn't dispatch it. (See HappyEyeballsConnectionAttempt::Unclaim.)
  virtual void Unclaim();
  virtual void OnTimeout() = 0;
  virtual void PrintDiagnostics(nsCString& log) = 0;
  virtual DnsAndConnectSocket* ToDnsAndConnectSocket() { return nullptr; }
  virtual uint32_t UnconnectedUDPConnsLength() const;

  bool IsSpeculative() { return mSpeculative; }
  bool Allow1918() { return mAllow1918; }
  void SetAllow1918(bool val) { mAllow1918 = val; }
  bool HasConnected() { return mHasConnected; }

 protected:
  virtual ~ConnectionAttempt() = default;

  RefPtr<nsHttpConnectionInfo> mConnInfo;
  RefPtr<nsAHttpTransaction> mTransaction;

  uint32_t mCaps = 0;
  // mSpeculative is set if the socket was created from
  // SpeculativeConnect(). It is cleared when a transaction would normally
  // start a new connection from scratch but instead finds this one in
  // the half open list and claims it for its own use. (which due to
  // the vagaries of scheduling from the pending queue might not actually
  // match up - but it prevents a speculative connection from opening
  // more connections than needed.)
  bool mSpeculative = false;
  // If created with a non-null urgent transaction, remember it, so we can
  // mark the connection as urgent right away when it's created.
  bool mUrgentStart = false;
  bool mAllow1918 = true;
  // mHasConnected tracks whether one of the sockets has completed the
  // connection process. It may have completed unsuccessfully.
  bool mHasConnected = false;

  // A ConnectionAttempt can be made for a concrete non-null transaction,
  // but the transaction can be dispatched to another connection. In that
  // case we can free this transaction to be claimed by other
  // transactions.
  bool mFreeToUse = true;
};

}  // namespace net
}  // namespace mozilla

#endif