#pragma once
#include <wtf/HashFunctions.h>
#include <wtf/HashTraits.h>
namespace WebCore {
class SessionID {
public:
SessionID()
: SessionID(emptySessionID())
{
}
enum SessionConstants : uint64_t {
EphemeralSessionMask = 0x8000000000000000,
DefaultSessionID = 1,
LegacyPrivateSessionID = DefaultSessionID | EphemeralSessionMask,
HashTableEmptyValueID = 0,
HashTableDeletedValueID = std::numeric_limits<uint64_t>::max(),
};
static SessionID emptySessionID() { return SessionID(HashTableEmptyValueID); }
static SessionID hashTableDeletedValue() { return SessionID(HashTableDeletedValueID); }
static SessionID defaultSessionID() { return SessionID(DefaultSessionID); }
static SessionID legacyPrivateSessionID() { return SessionID(LegacyPrivateSessionID); }
bool isValid() const { return m_sessionID != HashTableEmptyValueID && m_sessionID != HashTableDeletedValueID; }
bool isEphemeral() const { return m_sessionID & EphemeralSessionMask && m_sessionID != HashTableDeletedValueID; }
WEBCORE_EXPORT static SessionID generateEphemeralSessionID();
WEBCORE_EXPORT static SessionID generatePersistentSessionID();
WEBCORE_EXPORT static void enableGenerationProtection();
uint64_t sessionID() const { return m_sessionID; }
bool operator==(SessionID sessionID) const { return m_sessionID == sessionID.m_sessionID; }
bool operator!=(SessionID sessionID) const { return m_sessionID != sessionID.m_sessionID; }
bool isAlwaysOnLoggingAllowed() const { return !isEphemeral(); }
template<class Encoder> void encode(Encoder&) const;
template<class Decoder> static bool decode(Decoder&, SessionID&);
private:
explicit SessionID(uint64_t sessionID)
: m_sessionID(sessionID)
{
}
uint64_t m_sessionID;
};
template<class Encoder>
void SessionID::encode(Encoder& encoder) const
{
encoder << m_sessionID;
}
template<class Decoder>
bool SessionID::decode(Decoder& decoder, SessionID& sessionID)
{
if (!decoder.decode(sessionID.m_sessionID))
return false;
return true;
}
}
namespace WTF {
struct SessionIDHash {
static unsigned hash(const WebCore::SessionID& p) { return intHash(p.sessionID()); }
static bool equal(const WebCore::SessionID& a, const WebCore::SessionID& b) { return a == b; }
static const bool safeToCompareToEmptyOrDeleted = true;
};
template<> struct HashTraits<WebCore::SessionID> : GenericHashTraits<WebCore::SessionID> {
static WebCore::SessionID emptyValue() { return WebCore::SessionID::emptySessionID(); }
static void constructDeletedValue(WebCore::SessionID& slot) { slot = WebCore::SessionID::hashTableDeletedValue(); }
static bool isDeletedValue(const WebCore::SessionID& slot) { return slot == WebCore::SessionID::hashTableDeletedValue(); }
};
template<> struct DefaultHash<WebCore::SessionID> {
typedef SessionIDHash Hash;
};
}