tf2/tf2_src/gcsdk/accountdetails.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Holds the CAccountDetails class.
//
//=============================================================================

#include "stdafx.h"
#include "accountdetails.h"
#include "rtime.h"
#include "gcsdk_gcmessages.pb.h"

#include "memdbgon.h" // needs to be the last include in the file

namespace GCSDK
{
GCConVar cv_account_details_cache_time( "account_details_cache_time", "600" );
GCConVar cv_account_details_failure_cache_time( "account_details_failure_cache_time", "10" );
GCConVar account_details_timeout( "account_details_timeout", "10" );
GCConVar cv_persona_name_cache_time( "persona_name_cache_time", "60" );
GCConVar cv_persona_name_failure_cache_time( "persona_name_failure_cache_time", "10" );
GCConVar cv_persona_name_batch_size( "persona_name_batch_size", "100" );
GCConVar persona_name_timeout( "persona_name_timeout", "10" );

const char *kszAccountDetailsKey = "AccountDetails-v001";

//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CAccountDetails::CAccountDetails()
:	m_rtimeCached( CRTime::RTime32TimeCur() ),
	m_bValid( false ),
	m_bPublicProfile( false ),
	m_bVacBanned( false ),
	m_bCyberCafe( false ),
	m_bSchoolAccount( false ),
	m_bFreeTrialAccount( false ),
	m_bSubscribed( false ),
	m_bLowViolence( false ),
	m_bLimited( false ),
	m_bAccountLocked( false ),
	m_bCommunityBanned( false ),
	m_bTradeBanned( false ),
	m_bIsSteamGuardEnabled( false ),
	m_bIsPhoneVerified( false ),
	m_bIsTwoFactorAuthEnabled( false ),
	m_bIsPhoneIdentifying( false ),
	m_unPackage( 0 ),
	m_rtimeVACBanEnd( 0 ),
	m_unSteamLevel( 0 ),
	m_unFriendCount( 0 ),
	m_rtimeAccountCreated( 0 ),
	m_rtimeTwoFactorEnabled( 0 ),
	m_rtimePhoneVerified( 0 ),
	m_unPhoneID( 0 )
{
}

//-----------------------------------------------------------------------------
// Purpose: Initialize a fresh CAccountDetails with data from Steam
//-----------------------------------------------------------------------------
void CAccountDetails::Init( CGCSystemMsg_GetAccountDetails_Response &msgResponse )
{
	m_bValid = true;
	m_sAccountName = msgResponse.account_name().c_str();
	m_bPublicProfile = msgResponse.is_profile_public();
	m_bPublicInventory = msgResponse.is_inventory_public();
	m_bVacBanned = msgResponse.is_vac_banned(); 
	m_bCyberCafe = msgResponse.is_cyber_cafe(); 
	m_bSchoolAccount = msgResponse.is_school_account(); 
	m_bFreeTrialAccount = msgResponse.is_free_trial_account(); 
	m_bSubscribed = msgResponse.is_subscribed(); 
	m_bLowViolence = msgResponse.is_low_violence(); 
	m_bLimited = msgResponse.is_limited(); 
	m_bAccountLocked = msgResponse.is_account_locked_down();
	m_bCommunityBanned = msgResponse.is_community_banned();
	m_bTradeBanned = msgResponse.is_trade_banned();
	m_unPackage = msgResponse.package();
	m_rtimeVACBanEnd = msgResponse.suspension_end_time();
	m_sCurrency = msgResponse.currency().c_str();
	m_unSteamLevel = msgResponse.steam_level();
	m_unFriendCount = msgResponse.friend_count();
	m_rtimeAccountCreated = msgResponse.account_creation_time();
	m_bIsSteamGuardEnabled = msgResponse.is_steamguard_enabled();
	m_bIsPhoneVerified = msgResponse.is_phone_verified();
	m_bIsTwoFactorAuthEnabled = msgResponse.is_two_factor_auth_enabled();
	m_bIsPhoneIdentifying = msgResponse.is_phone_identifying();
	m_rtimeTwoFactorEnabled = msgResponse.two_factor_enabled_time();
	m_rtimePhoneVerified = msgResponse.phone_verification_time();
	m_unPhoneID = msgResponse.phone_id();
}


//-----------------------------------------------------------------------------
// Purpose: Returns true if it's time to remove this entry from the cache
//-----------------------------------------------------------------------------
bool CAccountDetails::BIsExpired() const
{
	int nCacheSeconds = BIsValid() ? cv_account_details_cache_time.GetInt() : cv_account_details_failure_cache_time.GetInt();

	return m_rtimeCached + nCacheSeconds < CRTime::RTime32TimeCur();
}


//-----------------------------------------------------------------------------
// Purpose: Reverts this to an invalid record
//-----------------------------------------------------------------------------
void CAccountDetails::Reset()
{
	m_bValid = false;
	m_rtimeCached = CRTime::RTime32TimeCur();
}


#ifdef DBGFLAG_VALIDATE
//-----------------------------------------------------------------------------
// Purpose: Claims all the memory for the AccountDetails object
//-----------------------------------------------------------------------------
void CAccountDetails::Validate( CValidator &validator, const char *pchName )
{
	VALIDATE_SCOPE();
	ValidateObj( m_sAccountName );
}
#endif // DBGFLAG_VALIDATE


//-----------------------------------------------------------------------------
// Purpose: Sends a message to Steam to get a CAccountDetails object
//-----------------------------------------------------------------------------
class CGCJobSendGetAccountDetailsRequest : public CGCJob
{
	CAccountDetailsManager *m_pManager;
	CSteamID m_SteamID;

public:
	CGCJobSendGetAccountDetailsRequest( CGCBase *pGC, CAccountDetailsManager *pManager, const CSteamID &steamID )
		: CGCJob( pGC ), m_pManager( pManager ), m_SteamID( steamID ) {}
	virtual bool BYieldingRunGCJob()
	{
		// Yield immediately to be sure that the calling job gets in the wakeup list
		BYield();

		// These requests should come back very quickly, so if they don't we shouldn't wait very long
		// jamming up the system
		SetJobTimeout( account_details_timeout.GetInt() );

		// Get an empty account details object
		CAccountDetails *pAccount = m_pManager->m_hashAccountDetailsCache.PvRecordFind( m_SteamID.GetAccountID() );
		if ( NULL == pAccount )
		{
			pAccount = m_pManager->m_hashAccountDetailsCache.PvRecordInsert( m_SteamID.GetAccountID() );
		}
		else
		{
			// If the record isn't expired, why is it there?
			Assert( pAccount->BIsExpired() );
			pAccount->Reset();
		}		

		CProtoBufMsg< CGCSystemMsg_GetAccountDetails > msgReqeust( k_EGCMsgGetAccountDetails );
		CProtoBufMsg< CGCSystemMsg_GetAccountDetails_Response > msgReply;
		msgReqeust.Body().set_steamid( m_SteamID.ConvertToUint64() );
		msgReqeust.Body().set_appid( GGCBase()->GetAppID() );
		msgReqeust.ExpectingReply( GJobCur().GetJobID() );

		// try to get the account details at most 2 times
		const int kMaxTries = 2;
		for ( int iTries = 0; iTries < kMaxTries; iTries++ )
		{
			if( !m_pGC->BSendSystemMessage( msgReqeust ) )
			{
				EmitWarning( SPEW_GC, 2, "Unable to send GetAccountDetails system message\n" );
				continue;
			}

			// All of our request messages are identical, so if we get our replies
			// mixed up, it's OK.  Bypass the system used to protect us against
			// mismatched replies.
			ClearFailedToReceivedMsgType( k_EGCMsgGetAccountDetailsResponse );

			// Wait for the reply
			if( !BYieldingWaitForMsg( &msgReply, k_EGCMsgGetAccountDetailsResponse ) )
			{
				EmitWarning( SPEW_GC, 2, "Timeout waiting for GetAccountDetails reply for SteamID %s\n", m_SteamID.Render() );
				continue;
			}

			if ( k_EResultOK != msgReply.GetEResult() )
			{
				EmitInfo( SPEW_GC, 4, 4, "GetAccountDetails request failed with result %d for SteamID %s\n", msgReply.GetEResult(), m_SteamID.Render() );
				break;
			}

			Assert( msgReply.Body().eresult_deprecated() == k_EResultOK );

			// Sanity check the response
			if ( msgReply.Body().has_accountid() && msgReply.Body().accountid() != m_SteamID.GetAccountID() )
			{
				static bool bHasAlerted = false;
				if ( !bHasAlerted )
				{
					GGCBase()->PostAlert( k_EAlertTypeInfo, true, CFmtStr( "GetAccountDetails got a response for account %d, but we were expecting a response for account %s\n", msgReply.Body().accountid(), m_SteamID.Render() ) );
					bHasAlerted = true;
				}

				EmitError( SPEW_GC, "GetAccountDetails got a response for account %d, but we were expecting a response for account %s\n", msgReply.Body().accountid(), m_SteamID.Render() );
				break;
			}

			// All responses should have this
			if ( !msgReply.Body().has_account_name() )
			{
				EmitError( SPEW_GC, "GetAccountDetails got a response with missing fields for SteamID %s\n", m_SteamID.Render() );
				break;
			}

			pAccount->Init( msgReply.Body() );
			m_pManager->CachePersonaName( CSteamID( m_SteamID ), msgReply.Body().persona_name().c_str() );

			// We got a response, so we shouldn't try again
			break;
		}

		m_pManager->WakeWaitingAccountDetailsJobs( m_SteamID );
		return true;
	}
};


//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CCachedPersonaName::CCachedPersonaName()
	:	m_rtimeCached( 0 )	// This initialization value is important because it makes it expired on creation, 
							// and the rest of the code will only ask Steam for a name if the cached entry is expired
	,	m_nLoading( 0 )
	,	m_bPreloading( false )
{
}


//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
CCachedPersonaName::~CCachedPersonaName()
{
	Assert( !BIsLoading() );
}


//-----------------------------------------------------------------------------
// Purpose: Sets the newly retrieved persona name
//-----------------------------------------------------------------------------
void CCachedPersonaName::Init( const char *pchPersonaName )
{
	m_sPersonaName = pchPersonaName;
	m_rtimeCached = CRTime::RTime32TimeCur();
	m_bPreloading = false;
}


//-----------------------------------------------------------------------------
// Purpose: Returns true if it's time to remove this entry from the cache
//-----------------------------------------------------------------------------
bool CCachedPersonaName::BIsExpired() const
{
	int nCacheSeconds = BIsValid() ? cv_persona_name_cache_time.GetInt() : cv_persona_name_failure_cache_time.GetInt();

	return m_rtimeCached + nCacheSeconds < CRTime::RTime32TimeCur();
}


//-----------------------------------------------------------------------------
// Purpose: Returns true if there is an actual cached name
//-----------------------------------------------------------------------------
bool CCachedPersonaName::BIsValid() const
{
	return !m_sPersonaName.IsEmpty();
}


//-----------------------------------------------------------------------------
// Purpose: Reverts this to an invalid record
//-----------------------------------------------------------------------------
void CCachedPersonaName::Reset()
{
	m_sPersonaName.Clear();
	m_rtimeCached = CRTime::RTime32TimeCur();
	m_bPreloading = false;
}


//-----------------------------------------------------------------------------
// Purpose: Gets the cached string
//-----------------------------------------------------------------------------
const char *CCachedPersonaName::GetPersonaName() const
{
	return BIsValid() ? m_sPersonaName.Get() : "[unknown]";
}


//-----------------------------------------------------------------------------
// Purpose: Returns if this name is loading
//-----------------------------------------------------------------------------
bool CCachedPersonaName::BIsLoading() const
{
	return m_nLoading > 0 || m_bPreloading;
}


//-----------------------------------------------------------------------------
// Purpose: Sets that this name has been preloaded
//-----------------------------------------------------------------------------
void CCachedPersonaName::SetPreloading()
{
	m_bPreloading = true;
}


//-----------------------------------------------------------------------------
// Purpose: Sets that a job is waiting for this name to be loaded
//-----------------------------------------------------------------------------
void CCachedPersonaName::AddLoadingRef()
{
	m_nLoading++;
}


//-----------------------------------------------------------------------------
// Purpose: Releases the loading ref
//-----------------------------------------------------------------------------
void CCachedPersonaName::ReleaseLoadingRef()
{
	DbgVerify( --m_nLoading >= 0 );
}


#ifdef DBGFLAG_VALIDATE
//-----------------------------------------------------------------------------
// Purpose: Claims all the memory for the CCachedPersonaName object
//-----------------------------------------------------------------------------
void CCachedPersonaName::Validate( CValidator &validator, const char *pchName )
{
	VALIDATE_SCOPE();
	ValidateObj( m_sPersonaName );
}
#endif // DBGFLAG_VALIDATE


//-----------------------------------------------------------------------------
// Purpose: Sends a message to Steam to get a CAccountDetails object
//-----------------------------------------------------------------------------
class CGCJobSendGetPersonaNamesRequest : public CGCJob
{
	CAccountDetailsManager *m_pManager;
	CUtlVector<CSteamID> m_vecSteamIDs;

public:
	CGCJobSendGetPersonaNamesRequest( CGCBase *pGC, CAccountDetailsManager *pManager, CUtlVector<CSteamID> &vecSteamIDs )
		: CGCJob( pGC ), m_pManager( pManager )
	{
		m_vecSteamIDs.Swap( vecSteamIDs );
	}

	virtual bool BYieldingRunGCJob()
	{
		// Yield immediately to be sure that the calling job gets in the wakeup list
		BYield();

		// These requests should come back very quickly, so if they don't we shouldn't wait very long
		// jamming up the system
		SetJobTimeout( persona_name_timeout.GetInt() );

		CProtoBufMsg< CMsgGCGetPersonaNames > msgReqeust( k_EGCMsgGetPersonaNames );
		msgReqeust.ExpectingReply( GJobCur().GetJobID() );

		FOR_EACH_VEC( m_vecSteamIDs, i )
		{
			msgReqeust.Body().add_steamids( m_vecSteamIDs[i].ConvertToUint64() );
		}
		
		CProtoBufMsg< CMsgGCGetPersonaNames_Response > msgReply;
		if( !m_pGC->BSendSystemMessage( msgReqeust ) ||
			!BYieldingWaitForMsg( &msgReply, k_EGCMsgGetPersonaNamesResponse ) )
		{
			FOR_EACH_VEC( m_vecSteamIDs, i )
			{
				m_pManager->CachePersonaNameFailure( m_vecSteamIDs[i] );
			}

			//if we are shutting down, don't bother reporting this issue, we know we won't be able to get persona names
			if( !GGCBase()->GetIsShuttingDown() )
			{
				EmitWarning( SPEW_GC, 2, "GetPersonaNames request failed for %d IDs:", m_vecSteamIDs.Count() );
				FOR_EACH_VEC( m_vecSteamIDs, nID )
				{
					EmitWarning( SPEW_GC, 2, " %s", m_vecSteamIDs[ nID ].Render() );
				}
				EmitWarning( SPEW_GC, 2, "\n" );
			}
		}
		else
		{
			for ( int i = 0; i < msgReply.Body().succeeded_lookups_size(); i++ )
			{
				const CMsgGCGetPersonaNames_Response_PersonaName &result = msgReply.Body().succeeded_lookups( i );
				m_pManager->CachePersonaName( CSteamID( result.steamid() ), result.persona_name().c_str() );
			}
			for ( int i = 0; i < msgReply.Body().failed_lookup_steamids_size(); i++ )
			{
				m_pManager->CachePersonaNameFailure( CSteamID( msgReply.Body().failed_lookup_steamids( i ) ) );
			}
		}

		FOR_EACH_VEC( m_vecSteamIDs, i )
		{
			m_pManager->WakeWaitingPersonaNameJobs( m_vecSteamIDs[i] );
		}
		return true;
	}
};


//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CAccountDetailsManager::CAccountDetailsManager()
	: m_hashAccountDetailsCache( k_nAccountDetailsRunInterval / k_cMicroSecPerShellFrame )
	, m_hashPersonaNameCache( k_nAccountDetailsRunInterval / k_cMicroSecPerShellFrame )
{
	m_hashAccountDetailsCache.Init( k_cAccountDetailsInit, k_cBucketAccountDetails );
	m_hashPersonaNameCache.Init( k_cAccountDetailsInit, k_cBucketAccountDetails );
}


//-----------------------------------------------------------------------------
// Purpose: Work to be done once per frame
//-----------------------------------------------------------------------------
void CAccountDetailsManager::MarkFrame()
{
	m_hashAccountDetailsCache.StartFrameSchedule( true );
	m_hashPersonaNameCache.StartFrameSchedule( true );
	SendBatchedPersonaNamesRequest();
}


//-----------------------------------------------------------------------------
// Purpose: Gets a CAccountDetails object
//-----------------------------------------------------------------------------
CAccountDetails *CAccountDetailsManager::YieldingGetAccountDetails( const CSteamID &steamID, bool bForceReload )
{
	AssertRunningJob();
	if( !steamID.IsValid() || !steamID.BIndividualAccount() )
		return NULL;

	// Check the local cache
	CAccountDetails *pAccountDetails = NULL;
	if ( BFindAccountDetailsInLocalCache( steamID, &pAccountDetails ) )
	{
		if ( pAccountDetails && bForceReload )
		{
			// Clear it, continue with fresh load
			m_hashAccountDetailsCache.Remove( pAccountDetails );
		}
		else
		{
			return pAccountDetails;
		}
	}

	// Not in the local cache, ask Steam
	int iMapIndex = m_mapQueuedAccountDetailsRequests.Find( steamID );
	if ( !m_mapQueuedAccountDetailsRequests.IsValidIndex( iMapIndex ) )
	{
		iMapIndex = m_mapQueuedAccountDetailsRequests.Insert( steamID );
		CGCJobSendGetAccountDetailsRequest *pJob = new CGCJobSendGetAccountDetailsRequest( GGCBase(), this, steamID );
		pJob->StartJob( NULL );
	}

	m_mapQueuedAccountDetailsRequests[iMapIndex].AddToTail( GJobCur().GetJobID() );
	GJobCur().BYieldingWaitForWorkItem();

	// Check again, if it's not there then it's not there
	BFindAccountDetailsInLocalCache( steamID, &pAccountDetails );
	return pAccountDetails;
}


//-----------------------------------------------------------------------------
// Purpose: Finds an AccountDetails object in the local cache. Returns true
//	if it was found, false if it should be checked remotely
//-----------------------------------------------------------------------------
bool CAccountDetailsManager::BFindAccountDetailsInLocalCache( const CSteamID &steamID, CAccountDetails **ppAccount )
{
	CAccountDetails *pAccountLocal = m_hashAccountDetailsCache.PvRecordFind( steamID.GetAccountID() );
	if( NULL == pAccountLocal || pAccountLocal->BIsExpired() )
		return false;

	*ppAccount = pAccountLocal->BIsValid() ? pAccountLocal : NULL;
	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Wakes any jobs waiting on this result
//-----------------------------------------------------------------------------
void CAccountDetailsManager::WakeWaitingAccountDetailsJobs( const CSteamID &steamID )
{
	int iMapIndex = m_mapQueuedAccountDetailsRequests.Find( steamID );
	if ( !m_mapQueuedAccountDetailsRequests.IsValidIndex( iMapIndex ) )
		return; 

	CCopyableUtlVector<JobID_t> &vecJobsWaiting = m_mapQueuedAccountDetailsRequests[iMapIndex];
	FOR_EACH_VEC( vecJobsWaiting, i )
	{
		GGCBase()->GetJobMgr().BRouteWorkItemCompletedDelayed( vecJobsWaiting[i], false );
	}
	m_mapQueuedAccountDetailsRequests.RemoveAt( iMapIndex );
}


//-----------------------------------------------------------------------------
// Purpose: Gets a persona name for a user
//-----------------------------------------------------------------------------
const char *CAccountDetailsManager::YieldingGetPersonaName( const CSteamID &steamID )
{
	VPROF_BUDGET( "CAccountDetailsManager::YieldingGetPersonaName", VPROF_BUDGETGROUP_STEAM );

	AssertRunningJob();

	if( !steamID.IsValid() || !steamID.BIndividualAccount() )
		return "[unknown]";

	// Check the local cache
	CCachedPersonaName *pPersonaName = FindOrCreateCachedPersonaName( steamID );
	if ( !pPersonaName->BIsExpired() )
		return pPersonaName->GetPersonaName(); 

	// Not in the local cache, ask Steam
	pPersonaName->AddLoadingRef();

	// Queue the request and start a lookup job if we have enough pending
	int iMapIndex = m_mapQueuedPersonaNameRequests.Find( steamID );
	if ( !m_mapQueuedPersonaNameRequests.IsValidIndex( iMapIndex ) )
	{
		iMapIndex = m_mapQueuedPersonaNameRequests.Insert( steamID );
		m_vecPendingPersonaNameLookups.AddToTail( steamID );
		if ( m_vecPendingPersonaNameLookups.Count() >= cv_persona_name_batch_size.GetInt() )
		{
			SendBatchedPersonaNamesRequest();
		}
	}

	m_mapQueuedPersonaNameRequests[iMapIndex].AddToTail( GJobCur().GetJobID() );
	GJobCur().BYieldingWaitForWorkItem();

	// At this point we'll either have a persona name or we won't
	pPersonaName->ReleaseLoadingRef();
	return pPersonaName->GetPersonaName();
}


//-----------------------------------------------------------------------------
// Purpose: Let's the system know that we should load the persona name for this
//	user, but does not block on it
//-----------------------------------------------------------------------------
void CAccountDetailsManager::PreloadPersonaName( const CSteamID &steamID )
{
	if( !steamID.IsValid() || !steamID.BIndividualAccount() )
		return;

	// See if we already have it
	CCachedPersonaName *pCachedName = FindOrCreateCachedPersonaName( steamID );
	if ( !pCachedName->BIsExpired() || pCachedName->BIsLoading() )
		return;

	// Queue the request and start a lookup job if we have enough pending
	pCachedName->SetPreloading();
	m_mapQueuedPersonaNameRequests.Insert( steamID );
	m_vecPendingPersonaNameLookups.AddToTail( steamID );
	if ( m_vecPendingPersonaNameLookups.Count() >= cv_persona_name_batch_size.GetInt() )
	{
		SendBatchedPersonaNamesRequest();
	}
}


//-----------------------------------------------------------------------------
// Purpose: Sends a batch of persona name requests
//-----------------------------------------------------------------------------
void CAccountDetailsManager::SendBatchedPersonaNamesRequest()
{
	if ( 0 == m_vecPendingPersonaNameLookups.Count() )
		return;

	// Start the job. This swaps out our buffer with an empty one
	CGCJobSendGetPersonaNamesRequest *pJob = new CGCJobSendGetPersonaNamesRequest( GGCBase(), this, m_vecPendingPersonaNameLookups );
	pJob->StartJob( NULL );
}


//-----------------------------------------------------------------------------
// Purpose: Caches a persona name
//-----------------------------------------------------------------------------
void CAccountDetailsManager::CachePersonaName( const CSteamID &steamID, const char *pchPersonaName )
{
	CCachedPersonaName *pCachedPersonaName = FindOrCreateCachedPersonaName( steamID );
	pCachedPersonaName->Init( pchPersonaName );
}


//-----------------------------------------------------------------------------
// Purpose: Remembers that we failed to cache a persona name
//-----------------------------------------------------------------------------
void CAccountDetailsManager::CachePersonaNameFailure( const CSteamID &steamID )
{
	CCachedPersonaName *pCachedPersonaName = FindOrCreateCachedPersonaName( steamID );
	pCachedPersonaName->Reset();
}


//-----------------------------------------------------------------------------
// Purpose: Purges a specific persona name from the cache
//-----------------------------------------------------------------------------
void CAccountDetailsManager::ClearCachedPersonaName( const CSteamID &steamID )
{
	CCachedPersonaName *pPersonaNameLocal = m_hashPersonaNameCache.PvRecordFind( steamID.GetAccountID() );
	if( NULL != pPersonaNameLocal && !pPersonaNameLocal->BIsLoading() )
	{
		m_hashPersonaNameCache.Remove( pPersonaNameLocal );
	}
}


//-----------------------------------------------------------------------------
// Purpose: Gets a CCachedPersonaName record
//-----------------------------------------------------------------------------
CCachedPersonaName *CAccountDetailsManager::FindOrCreateCachedPersonaName( const CSteamID &steamID )
{
	CCachedPersonaName *pPersonaName = m_hashPersonaNameCache.PvRecordFind( steamID.GetAccountID() );
	if ( NULL != pPersonaName )
		return pPersonaName;
	else
		return m_hashPersonaNameCache.PvRecordInsert( steamID.GetAccountID() );
}


//-----------------------------------------------------------------------------
// Purpose: Wakes any jobs waiting on this result
//-----------------------------------------------------------------------------
void CAccountDetailsManager::WakeWaitingPersonaNameJobs( const CSteamID &steamID )
{
	int iMapIndex = m_mapQueuedPersonaNameRequests.Find( steamID );
	if ( !m_mapQueuedPersonaNameRequests.IsValidIndex( iMapIndex ) )
		return; 

	CCopyableUtlVector<JobID_t> &vecJobsWaiting = m_mapQueuedPersonaNameRequests[iMapIndex];
	FOR_EACH_VEC( vecJobsWaiting, i )
	{
		GGCBase()->GetJobMgr().BRouteWorkItemCompletedDelayed( vecJobsWaiting[i], false );
	}
	m_mapQueuedPersonaNameRequests.RemoveAt( iMapIndex );
}


//-----------------------------------------------------------------------------
// Purpose: Purges old data from the cache. Returns true if there is more
//	work to do
//-----------------------------------------------------------------------------
bool CAccountDetailsManager::BExpireRecords( CLimitTimer &limitTimer )
{
	VPROF_BUDGET( "Expire account details", VPROF_BUDGETGROUP_STEAM );

	for ( CAccountDetails *pDetails = m_hashAccountDetailsCache.PvRecordRun(); NULL != pDetails; pDetails = m_hashAccountDetailsCache.PvRecordRun() )
	{
		if ( pDetails->BIsExpired() )
		{
			m_hashAccountDetailsCache.Remove( pDetails );
		}

		if ( limitTimer.BLimitReached() )
			return true;
	}

	for ( CCachedPersonaName *pPersonaName = m_hashPersonaNameCache.PvRecordRun(); NULL != pPersonaName; pPersonaName = m_hashPersonaNameCache.PvRecordRun() )
	{
		if ( pPersonaName->BIsExpired() && !pPersonaName->BIsLoading() )
		{
			m_hashPersonaNameCache.Remove( pPersonaName );
		}

		if ( limitTimer.BLimitReached() )
			return true;
	}

	return false;
}


//-----------------------------------------------------------------------------
// Purpose: Prints status
//-----------------------------------------------------------------------------
void CAccountDetailsManager::Dump() const
{
	int nJobsWaiting = 0;
	FOR_EACH_MAP_FAST( m_mapQueuedAccountDetailsRequests, iMap )
	{
		nJobsWaiting += m_mapQueuedAccountDetailsRequests[iMap].Count();
	}

	EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "\tAccount Details: %d cached, %d lookups in flight, %d jobs waiting\n", m_hashAccountDetailsCache.Count(), m_mapQueuedAccountDetailsRequests.Count(), nJobsWaiting );

	nJobsWaiting = 0;
	FOR_EACH_MAP_FAST( m_mapQueuedPersonaNameRequests, iMap )
	{
		nJobsWaiting += m_mapQueuedPersonaNameRequests[iMap].Count();
	}

	EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "\tPersona Names: %d cached, %d lookups in flight, %d jobs waiting\n", m_hashPersonaNameCache.Count(), m_mapQueuedPersonaNameRequests.Count(), nJobsWaiting );
}

} // namespace GCSDK