1HEADmaster

1 files changed, 931 insertions, 0 deletions

diff --git a/game/client/youtubeapi.cpp b/game/client/youtubeapi.cpp
new file mode 100644
index 0000000..c104221
--- /dev/null
+++ b/game/client/youtubeapi.cpp
@@ -0,0 +1,931 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================
+
+#if defined( WIN32 ) && !defined( _X360 )
+#include "winlite.h"
+#include <WinInet.h>
+#endif
+
+#include "youtubeapi.h"
+
+#include "platform.h"
+#include "convar.h"
+#include "fmtstr.h"
+#include "igamesystem.h"
+#include "strtools.h"
+#include "cdll_util.h"
+#include "utlmap.h"
+#include "utlstring.h"
+#include "vstdlib/jobthread.h"
+#include <steam/steam_api.h>
+#include <steam/isteamhttp.h>
+#include "cdll_client_int.h"
+#include "utlbuffer.h"
+#include "filesystem.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+//=============================================================================
+
+static ConVar youtube_http_proxy( "youtube_http_proxy", "", FCVAR_ARCHIVE, "HTTP proxy.  Specify if you have have problems uploading to YouTube." );
+
+//=============================================================================
+
+static bool GetStandardTagValue( const char *pTag, const char *pXML, CUtlString &strResult )
+{
+	const char *pStart = strstr( pXML, pTag );
+	if ( pStart != NULL )
+	{
+		pStart = strstr( pStart, ">" );
+		if ( pStart != NULL )
+		{
+			pStart += 1;
+			const char *pEnd = strstr( pStart, CFmtStr1024( "</%s", pTag ) );
+			if ( pEnd != NULL )
+			{
+				strResult.SetDirect( pStart, pEnd - pStart );
+				return true;
+			}
+		}
+	}
+	return false;
+}
+
+//=============================================================================
+
+class CYouTubeRetrieveInfoJob;
+
+namespace
+{
+	class CYouTubeSystem : public CAutoGameSystemPerFrame
+	{
+	public:
+
+		CYouTubeSystem();
+		~CYouTubeSystem();
+
+		// CAutoGameSystem
+		virtual bool Init();
+		virtual void PostInit();
+		virtual void Shutdown();
+		virtual bool IsPerFrame() { return true; }
+		virtual void Update( float frametime );
+
+		void Login( const char *pUserName, const char *pPassword, const char *pSource );
+		void LoginCancel();
+		YouTubeUploadHandle_t Upload( const char* pFilePath, const char *pMimeType, const char *pTitle, const char *pDescription, const char *pCategory, const char *pKeywords, eYouTubeAccessControl access );
+
+		bool IsUploadFinished( YouTubeUploadHandle_t handle );
+		bool GetUploadProgress( YouTubeUploadHandle_t handle, double &ultotal, double &ulnow );
+		bool GetUploadResults( YouTubeUploadHandle_t handle, bool &bSuccess, CUtlString &strURLToVideo, CUtlString &strURLToVideoStats );
+		void ClearUploadResults( YouTubeUploadHandle_t handle );
+		void CancelUpload( YouTubeUploadHandle_t handle );
+		void SetUploadFinished( YouTubeUploadHandle_t handle, bool bSuccess, const char *pURLToVideo, const char *pURLToVideoStats );
+
+		void SetUserProfile( const char *pUserProfile );
+		bool GetProfileURL( CUtlString &strProfileURL ) const;
+
+		YouTubeInfoHandle_t GetInfo( const char *pURLToVideoStats, CYouTubeResponseHandler &responseHandler );
+		void CancelGetInfo( YouTubeInfoHandle_t handle );
+
+		const char *GetDeveloperKey() const;
+		const char *GetDeveloperTag() const;
+		void SetDeveloperSettings( const char *pDeveloperKey, const char *pDeveloperTag );
+
+		const char *GetLoginName() const;
+		eYouTubeLoginStatus GetLoginStatus() const;
+		void SetLoginStatus( eYouTubeLoginStatus status );
+
+		const char* GetAuthToken() const;
+		void SetAuthToken( const char *pAuthToken );
+
+	private:
+		struct uploadstatus_t
+		{
+			bool bFinished;
+			bool bSuccess;
+			CUtlString strURLToVideo;
+			CUtlString strURLToVideoStats;
+		};
+
+		uploadstatus_t *GetStatus( YouTubeUploadHandle_t handle );
+
+		eYouTubeLoginStatus m_eLoginStatus;
+		CUtlString m_strYouTubeUserName;
+		CUtlString m_strDeveloperKey;
+		CUtlString m_strDeveloperTag;
+		CUtlString m_strAuthToken;
+		CUtlString m_strUserProfile;
+		CThreadMutex m_Mutex;
+		IThreadPool* m_pThreadPool;
+		CUtlMap< YouTubeUploadHandle_t, uploadstatus_t > m_mapUploads;
+		CUtlVector< CYouTubeRetrieveInfoJob * > m_vecRetrieveInfoJobs;
+	};
+};
+
+static CYouTubeSystem gYouTube;
+
+static ISteamHTTP *GetISteamHTTP()
+{
+	if ( steamapicontext != NULL && steamapicontext->SteamHTTP() )
+	{
+		return steamapicontext->SteamHTTP();
+	}
+#ifndef CLIENT_DLL
+	if ( steamgameserverapicontext != NULL )
+	{
+		return steamgameserverapicontext->SteamHTTP();
+	}
+#endif
+	return NULL;
+}
+
+//=============================================================================
+
+// Base class for all YouTube jobs
+class CYouTubeJob : public CJob
+{
+public:
+	CYouTubeJob( CYouTubeSystem *pSystem )
+	{
+		SetFlags( JF_IO );
+		// store local ones so we don't have to go through a mutex
+		m_strDeveloperKey = pSystem->GetDeveloperKey();
+		m_strDeveloperTag = pSystem->GetDeveloperTag();
+	}
+
+	virtual ~CYouTubeJob()
+	{
+	}
+
+	void CancelUpload()
+	{
+		m_bCancelled = true;
+	}
+
+	bool IsCancelled() const
+	{
+		return m_bCancelled;
+	}
+
+
+protected:
+	void OnHTTPRequestCompleted( HTTPRequestCompleted_t *pParam, bool bIOFailure )
+	{
+		m_bHTTPRequestPending = false;
+		if ( (!m_bAllowRequestFailure && pParam->m_eStatusCode != k_EHTTPStatusCode200OK) || bIOFailure || !pParam->m_bRequestSuccessful )
+		{
+			Warning( "Failed to get youtube url: HTTP status %d fetching %s\n", pParam->m_eStatusCode, m_sURL.String() );
+		}
+		else
+		{
+			OnHTTPRequestCompleted( pParam );
+		}
+	}
+
+	virtual void OnHTTPRequestCompleted( HTTPRequestCompleted_t *pParam ) { Assert( false ); }
+
+	void DoRequest( HTTPRequestHandle hRequest, const char *pchRequestURL )
+	{
+		m_sURL = pchRequestURL;
+
+		SteamAPICall_t hSteamAPICall;
+		if ( GetISteamHTTP()->SendHTTPRequest( hRequest, &hSteamAPICall ) )
+		{
+			m_HTTPRequestCompleted.Set( hSteamAPICall, this, &CYouTubeJob::OnHTTPRequestCompleted );
+		}
+
+		// Wait for it to finish.
+		while ( m_bHTTPRequestPending && !m_bCancelled )
+		{
+			ThreadSleep( 100 );
+		}
+
+		GetISteamHTTP()->ReleaseHTTPRequest( hSteamAPICall );
+	}
+
+
+	CCallResult<CYouTubeJob, HTTPRequestCompleted_t> m_HTTPRequestCompleted;
+
+	CUtlString m_strDeveloperKey;
+	CUtlString m_strDeveloperTag;
+	CUtlString m_sURL;
+	CUtlString m_strResponse;
+	bool m_bHTTPRequestPending = true;
+	bool m_bAllowRequestFailure = false;
+	bool m_bCancelled = false;
+};
+
+//=============================================================================
+
+class CYouTubeRetrieveUserProfile : public CYouTubeJob
+{
+public:
+	CYouTubeRetrieveUserProfile( CYouTubeSystem *pSystem ) 
+		: CYouTubeJob( pSystem )
+	{
+	}
+
+private:
+	void OnHTTPRequestCompleted( HTTPRequestCompleted_t *pParam ) OVERRIDE
+	{
+		uint32 unBodySize;
+		if ( !GetISteamHTTP()->GetHTTPResponseBodySize( pParam->m_hRequest, &unBodySize ) )
+		{
+			Assert( false );
+		}
+		else
+		{
+			m_strResponse.SetLength( unBodySize );
+
+			if ( GetISteamHTTP()->GetHTTPResponseBodyData( pParam->m_hRequest, (uint8*)m_strResponse.String(), unBodySize ) )
+			{
+				gYouTube.SetUserProfile( m_strResponse.Get() );
+			}
+		}
+	}
+
+	virtual JobStatus_t	DoExecute()
+	{
+		HTTPRequestHandle hRequest = GetISteamHTTP()->CreateHTTPRequest( k_EHTTPMethodGET, "http://gdata.youtube.com/feeds/api/users/default" );
+		GetISteamHTTP()->SetHTTPRequestNetworkActivityTimeout( hRequest, 30 );
+		GetISteamHTTP()->SetHTTPRequestHeaderValue( hRequest, "Authorization", CFmtStr1024( "GoogleLogin auth=%s", gYouTube.GetAuthToken() ) );
+
+		DoRequest( hRequest, "http://gdata.youtube.com/feeds/api/users/default" );
+
+		return JOB_OK;
+	}
+};
+
+//=============================================================================
+
+class CYouTubeRetrieveInfoJob : public CYouTubeJob
+{
+public:
+	CYouTubeRetrieveInfoJob( CYouTubeSystem *pSystem, const char *pVideoURL, CYouTubeResponseHandler &responseHandler ) 
+		: CYouTubeJob( pSystem )
+		, m_strURL( pVideoURL )
+		, m_responseHandler( responseHandler )
+	{
+	}
+
+	void NotifyResponseHandler()
+	{
+		m_responseHandler.HandleResponse( 200, m_strResponse.Get() );
+	}
+
+private:
+	void OnHTTPRequestCompleted( HTTPRequestCompleted_t *pParam ) OVERRIDE
+	{
+		uint32 unBodySize;
+		if ( !GetISteamHTTP()->GetHTTPResponseBodySize( pParam->m_hRequest, &unBodySize ) )
+		{
+			Assert( false );
+		}
+		else
+		{
+			m_strResponse.SetLength( unBodySize );
+			GetISteamHTTP()->GetHTTPResponseBodyData( pParam->m_hRequest, (uint8*)m_strResponse.String(), unBodySize );
+		}
+	}
+
+	virtual JobStatus_t	DoExecute()
+	{
+		HTTPRequestHandle hRequest = GetISteamHTTP()->CreateHTTPRequest( k_EHTTPMethodGET, m_strURL.Get() );
+		GetISteamHTTP()->SetHTTPRequestNetworkActivityTimeout( hRequest, 30 );
+
+		DoRequest( hRequest, m_strURL.Get() );
+
+		return JOB_OK;
+	}
+
+	// data
+	CUtlString m_strURL;
+	CYouTubeResponseHandler &m_responseHandler;
+};
+
+class CYouTubeLoginJob : public CYouTubeJob
+{
+public:
+	CYouTubeLoginJob( CYouTubeSystem *pSystem, const char *pUserName, const char *pPassword, const char *pSource ) 
+		: CYouTubeJob( pSystem )
+		, m_strUserName( pUserName )
+		, m_strPassword( pPassword )
+		, m_strSource( pSource )
+	{
+	}
+
+private:
+	
+	void SetLoginResults( const char *pLoginResults )
+	{
+		const char *pStart = strstr( pLoginResults, "Auth=" );
+		if ( pStart != NULL )
+		{
+			pStart += strlen( "Auth=" );			
+			const char *pEnd = strstr( pStart, "\r\n" );
+			if ( pEnd == NULL )
+			{
+				pEnd = strstr( pStart, "\n" );
+			}
+			CUtlString strAuthToken;
+			if ( pEnd != NULL )
+			{
+				strAuthToken.SetDirect( pStart, pEnd - pStart );
+			}
+			else
+			{
+				strAuthToken.SetDirect( pStart, strlen( pStart ) );
+			}	
+			gYouTube.SetAuthToken( strAuthToken.Get() );
+		}
+	}
+
+	void OnHTTPRequestCompleted( HTTPRequestCompleted_t *pParam ) OVERRIDE
+	{
+		eYouTubeLoginStatus loginStatus = kYouTubeLogin_LoggedIn;
+
+		if ( pParam->m_eStatusCode == 403 )
+		{
+			loginStatus = kYouTubeLogin_Forbidden;
+		}
+		else if ( pParam->m_eStatusCode != 200 )
+		{
+			loginStatus = kYouTubeLogin_GenericFailure;
+		}
+		else
+		{
+			uint32 unBodySize;
+			if ( !GetISteamHTTP()->GetHTTPResponseBodySize( pParam->m_hRequest, &unBodySize ) )
+			{
+				Assert( false );
+			}
+			else
+			{
+				m_strResponse.SetLength( unBodySize );
+				if ( GetISteamHTTP()->GetHTTPResponseBodyData( pParam->m_hRequest, (uint8*)m_strResponse.String(), unBodySize ) )
+				{
+					SetLoginResults( m_strResponse );
+				}
+			}
+		}
+
+		gYouTube.SetLoginStatus( loginStatus );
+
+	}
+
+	virtual JobStatus_t	DoExecute()
+	{
+		m_bAllowRequestFailure = true;
+
+		HTTPRequestHandle hRequest = GetISteamHTTP()->CreateHTTPRequest( k_EHTTPMethodPOST, "https://www.google.com/accounts/ClientLogin" );
+		GetISteamHTTP()->SetHTTPRequestNetworkActivityTimeout( hRequest, 30 );
+
+	//	GetISteamHTTP()->SetHTTPRequestHeaderValue( hRequest, "Content-Type", "application/x-www-form-urlencoded" );
+		GetISteamHTTP()->SetHTTPRequestHeaderValue( hRequest, "X-GData-Key", CFmtStr1024( "key=%s", m_strDeveloperKey.Get() ) );
+
+		char szUserNameEncoded[256];
+		char szPasswordEncoded[256];
+		char szSourceEncoded[256];
+		Q_URLEncode( szUserNameEncoded, sizeof( szUserNameEncoded ), m_strUserName.Get(), m_strUserName.Length() );
+		Q_URLEncode( szPasswordEncoded, sizeof( szPasswordEncoded ), m_strPassword.Get(), m_strPassword.Length() );
+		Q_URLEncode( szSourceEncoded, sizeof( szSourceEncoded ), m_strSource.Get(), m_strSource.Length() );
+
+		CFmtStr1024 data( "Email=%s&Passwd=%s&service=youtube&source=%s", szUserNameEncoded, szPasswordEncoded, szSourceEncoded );
+
+		GetISteamHTTP()->SetHTTPRequestRawPostBody( hRequest, "application/x-www-form-urlencoded", (uint8 *)data.Access(), data.Length() );
+
+		DoRequest( hRequest, "https://www.google.com/accounts/ClientLogin" );
+
+		return JOB_OK;
+	}
+
+	// data
+	CUtlString m_strUserName;
+	CUtlString m_strPassword;
+	CUtlString m_strSource;
+};
+
+// Job for uploading a file
+class CYouTubeUploadJob : public CYouTubeJob
+{
+public:
+	CYouTubeUploadJob( CYouTubeSystem *pSystem, const char* pFilePath, const char *pMimeType, const char *pTitle, const char *pDescription, const char *pCategory, const char *pKeywords, eYouTubeAccessControl access )
+		: CYouTubeJob( pSystem )
+		, m_strFilePath( pFilePath )
+		, m_strMimeType( pMimeType )
+		, m_strTitle( pTitle )
+		, m_strDesc( pDescription )
+		, m_strCategory( pCategory )
+		, m_strKeywords( pKeywords )
+		, m_eAccess( access )
+	{
+	}
+
+	void GetProgress( double &ultotal, double &ulnow  )
+	{
+		ultotal = 0;
+		ulnow = 0;
+	}
+
+private:
+
+	virtual JobStatus_t	DoExecute()
+	{
+		m_bAllowRequestFailure = true;
+
+		HTTPRequestHandle hRequest = GetISteamHTTP()->CreateHTTPRequest( k_EHTTPMethodPUT, "http://uploads.gdata.youtube.com/feeds/api/users/default/uploads" );
+		GetISteamHTTP()->SetHTTPRequestNetworkActivityTimeout( hRequest, 30 );
+
+		const char *pFileName = Q_UnqualifiedFileName( m_strFilePath.Get() );
+
+		GetISteamHTTP()->SetHTTPRequestHeaderValue( hRequest, "Authorization", CFmtStr1024( "GoogleLogin auth=%s", gYouTube.GetAuthToken() ) );
+		GetISteamHTTP()->SetHTTPRequestHeaderValue( hRequest, "X-GData-Key", CFmtStr1024( "key=%s", m_strDeveloperKey.Get() ) );
+		GetISteamHTTP()->SetHTTPRequestHeaderValue( hRequest, "GData-Version", "2" );
+		//GetISteamHTTP()->SetHTTPRequestHeaderValue( hRequest, "Content-Type", "multipart/form-data;boundary=-x" );
+		GetISteamHTTP()->SetHTTPRequestHeaderValue( hRequest, "Slug", CFmtStr1024( "%s", pFileName ) );
+
+		const char *pPrivateString = "";
+		const char *pAccessControlString = "";
+
+		switch ( m_eAccess )
+		{
+		case kYouTubeAccessControl_Public:
+			break;
+		case kYouTubeAccessControl_Private:
+			pPrivateString = "<yt:private/>";
+			break;
+		case kYouTubeAccessControl_Unlisted:
+			pAccessControlString = "<yt:accessControl action=\"list\" permission=\"denied\"/>";
+			break;
+		}
+
+		CFmtStr1024 strAPIRequest( "<?xml version=\"1.0\"?>"
+			"<entry "
+			"xmlns=\"http://www.w3.org/2005/Atom\" "
+			"xmlns:media=\"http://search.yahoo.com/mrss/\" "
+			"xmlns:yt=\"http://gdata.youtube.com/schemas/2007\">"
+			"<media:group>"
+			"<media:title type=\"plain\">%s</media:title>"
+			"<media:description type=\"plain\">%s</media:description>"
+			"<media:category scheme=\"http://gdata.youtube.com/schemas/2007/categories.cat\">"
+			"%s"
+			"</media:category>"
+			"%s"
+			"<media:keywords>%s</media:keywords>"
+			"<media:category scheme=\"http://gdata.youtube.com/schemas/2007/developertags.cat\">"
+			"%s"
+			"</media:category>"
+			"</media:group>"
+			"%s"
+			"</entry>",
+			m_strTitle.Get(),
+			m_strDesc.Get(),
+			m_strCategory.Get(),
+			pPrivateString,
+			m_strKeywords.Get(),
+			m_strDeveloperTag.Get(),
+			pAccessControlString );
+
+		CFmtStr1024 fmtstrBody(
+			"\r\nContent-Type: application/atom+xml; charset=UTF-8\r\n"
+			"\r\n---x\r\nContent-Disposition: form-data; name=\"apirequest\"\r\n\r\n%s"
+			"\r\n---x\r\nContent-Disposition: form-data; name=\"video\"\r\nContent-Type: %s\r\nContent-Transfer-Encoding: binary\r\n\r\n",
+			strAPIRequest.Access(), m_strMimeType.Get()
+		);
+
+		CUtlBuffer postDataRaw( 0, 0, 0 );
+
+		postDataRaw.Put( fmtstrBody.Access(), fmtstrBody.Length() );
+
+		CUtlBuffer fileData( 0, 0, 0 );
+		bool bReadFileOK = g_pFullFileSystem->ReadFile( m_strFilePath, nullptr, fileData );
+
+		if ( bReadFileOK )
+		{
+			postDataRaw.Put( fileData.Base(), fileData.TellPut() );
+
+			fileData.Clear();
+
+			static const char rgchFooter[] = "\r\n---x--\r\n";
+
+			postDataRaw.Put( rgchFooter, V_strlen( rgchFooter ) );
+
+			GetISteamHTTP()->SetHTTPRequestRawPostBody( hRequest, "multipart/form-data;boundary=-x", (uint8 *)postDataRaw.Base(), postDataRaw.TellPut() );
+
+			// BUGBUG: use SendHTTPRequestAndStreamResponse
+			DoRequest( hRequest, "http://uploads.gdata.youtube.com/feeds/api/users/default/uploads" );
+		}	
+
+		return JOB_OK;
+	}
+
+	void OnHTTPRequestCompleted( HTTPRequestCompleted_t *pParam ) OVERRIDE
+	{
+		bool bSuccess = false;
+
+		CUtlString strURLToVideoStats;
+		CUtlString strURLToVideo;
+
+		if ( pParam->m_eStatusCode == 200 )
+		{
+			bSuccess = true;
+
+			uint32 unBodySize;
+			if ( !GetISteamHTTP()->GetHTTPResponseBodySize( pParam->m_hRequest, &unBodySize ) )
+			{
+				Assert( false );
+			}
+			else
+			{
+				m_strResponse.SetLength( unBodySize );
+				if ( GetISteamHTTP()->GetHTTPResponseBodyData( pParam->m_hRequest, (uint8*)m_strResponse.String(), unBodySize ) )
+				{
+					// @note Tom Bui: wish I had an xml parser...
+					{
+						strURLToVideo = "";
+						// "<link rel='alternate' type='text/html' href='http://www.youtube.com/watch?v=7D4pb3irM_0&feature=youtube_gdata' /> ";
+						const char *kLinkStartTag = "<link rel='alternate' type='text/html' href='";
+						const char *kLinkTagEnd = "'/>";
+						const char *pStart = strstr( m_strResponse.Get(), kLinkStartTag );
+						if ( pStart != NULL )
+						{
+							pStart += strlen( kLinkStartTag );
+							const char *pEnd = strstr( pStart, kLinkTagEnd );
+							if ( pEnd != NULL )
+							{
+								strURLToVideo.SetDirect( pStart, pEnd - pStart );
+							}
+						}
+					}
+					{
+						strURLToVideoStats = "";
+						// "<link rel='self' type='text/html' href='http://www.youtube.com/watch?v=7D4pb3irM_0&feature=youtube_gdata' /> ";				
+						const char *kLinkStartTag = "<link rel='self' type='application/atom+xml' href='";
+						const char *kLinkTagEnd = "'/>";
+						const char *pStart = strstr( m_strResponse.Get(), kLinkStartTag );
+						if ( pStart != NULL )
+						{
+							pStart += strlen( kLinkStartTag );
+							const char *pEnd = strstr( pStart, kLinkTagEnd );
+							if ( pEnd != NULL )
+							{
+								strURLToVideoStats.SetDirect( pStart, pEnd - pStart );
+								// @note Tom Bui: we want at least version 2
+								if ( V_strstr( strURLToVideoStats.Get(), "?v=" ) == NULL )
+								{
+									strURLToVideoStats += "?v=2";
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+
+		gYouTube.SetUploadFinished( (YouTubeUploadHandle_t)this, bSuccess, strURLToVideo.Get(), strURLToVideoStats.Get() );
+	}
+
+	// data 
+	CUtlString m_strFilePath;
+	CUtlString m_strMimeType;
+	CUtlString m_strTitle;
+	CUtlString m_strDesc;
+	CUtlString m_strCategory;
+	CUtlString m_strKeywords;
+	eYouTubeAccessControl m_eAccess;
+};
+
+//=============================================================================
+
+CYouTubeSystem::CYouTubeSystem()
+	: m_eLoginStatus( kYouTubeLogin_NotLoggedIn )
+	, m_pThreadPool( NULL )
+	, m_mapUploads( DefLessFunc( YouTubeUploadHandle_t ) )
+{
+}
+
+CYouTubeSystem::~CYouTubeSystem()
+{
+}
+
+bool CYouTubeSystem::Init()
+{
+	m_pThreadPool = CreateThreadPool();
+	m_pThreadPool->Start( ThreadPoolStartParams_t( false, 4 ), "YouTubeSystem" );
+	return true;
+}
+
+void CYouTubeSystem::PostInit()
+{
+}
+
+void CYouTubeSystem::Shutdown()
+{
+	DestroyThreadPool( m_pThreadPool );
+	m_pThreadPool = NULL;
+}
+
+void CYouTubeSystem::Update( float frametime )
+{
+	AUTO_LOCK( m_Mutex );
+	FOR_EACH_VEC( m_vecRetrieveInfoJobs, i )
+	{
+		CYouTubeRetrieveInfoJob *pJob = m_vecRetrieveInfoJobs[i];
+		if ( pJob->IsFinished() )
+		{
+			pJob->NotifyResponseHandler();
+			// cleanup the job
+			pJob->Release();
+			// and remove
+			m_vecRetrieveInfoJobs.FastRemove( i );
+		}
+		else
+		{
+			++i;
+		}
+	}
+}
+
+void CYouTubeSystem::Login( const char *pUserName, const char *pPassword, const char *pSource )
+{
+	m_eLoginStatus = kYouTubeLogin_NotLoggedIn;
+	CYouTubeLoginJob *pJob = new CYouTubeLoginJob( this, pUserName, pPassword, pSource );
+	m_pThreadPool->AddJob( pJob );
+	pJob->Release();
+}
+
+void CYouTubeSystem::LoginCancel()
+{
+	m_eLoginStatus = kYouTubeLogin_Cancelled;
+}
+
+YouTubeUploadHandle_t CYouTubeSystem::Upload( const char* pFilePath, const char *pMimeType, const char *pTitle, const char *pDescription, const char *pCategory, const char *pKeywords, eYouTubeAccessControl access )
+{
+	if ( m_eLoginStatus != kYouTubeLogin_LoggedIn )
+	{
+		return NULL;
+	}
+	CYouTubeUploadJob *pJob = new CYouTubeUploadJob( this, pFilePath, pMimeType, pTitle, pDescription, pCategory, pKeywords, access );
+	m_pThreadPool->AddJob( pJob );
+	uploadstatus_t status = { false, false, "", "" };
+	m_mapUploads.Insert( (YouTubeUploadHandle_t)pJob, status );
+	return (YouTubeUploadHandle_t)pJob;
+}
+
+CYouTubeSystem::uploadstatus_t *CYouTubeSystem::GetStatus( YouTubeUploadHandle_t handle )
+{
+	int idx = m_mapUploads.Find( handle );
+	if ( m_mapUploads.IsValidIndex( idx ) )
+	{
+		return &m_mapUploads[idx];
+	}
+	return NULL;
+}
+
+bool CYouTubeSystem::IsUploadFinished( YouTubeUploadHandle_t handle )
+{
+	AUTO_LOCK( m_Mutex );
+	uploadstatus_t *pStatus = GetStatus( handle );
+	if ( pStatus != NULL )
+	{
+		return pStatus->bFinished;
+	}
+	return true;
+}
+
+bool CYouTubeSystem::GetUploadProgress( YouTubeUploadHandle_t handle, double &ultotal, double &ulnow )
+{
+	AUTO_LOCK( m_Mutex );
+	uploadstatus_t *pStatus = GetStatus( handle );
+	if ( pStatus != NULL )
+	{
+		CYouTubeUploadJob *pJob = (CYouTubeUploadJob*)handle;
+		pJob->GetProgress( ultotal, ulnow );
+		return true;
+	}
+	return false;
+}
+
+bool CYouTubeSystem::GetUploadResults( YouTubeUploadHandle_t handle, bool &bSuccess, CUtlString &strURLToVideo, CUtlString &strURLToVideoStats )
+{
+	AUTO_LOCK( m_Mutex );
+	uploadstatus_t *pStatus = GetStatus( handle );
+	if ( pStatus != NULL )
+	{
+		bSuccess = pStatus->bSuccess;
+		strURLToVideo = pStatus->strURLToVideo;
+		strURLToVideoStats = pStatus->strURLToVideoStats;
+		return true;
+	}
+	return false;
+}
+
+void CYouTubeSystem::ClearUploadResults( YouTubeUploadHandle_t handle )
+{
+	AUTO_LOCK( m_Mutex );
+	if ( m_mapUploads.Remove( handle ) )
+	{
+		CYouTubeUploadJob *pJob = (CYouTubeUploadJob*)handle;
+		pJob->Release();
+	}
+}
+
+void CYouTubeSystem::CancelUpload( YouTubeUploadHandle_t handle )
+{
+	AUTO_LOCK( m_Mutex );
+	if ( m_mapUploads.Remove( handle ) )
+	{
+		CYouTubeUploadJob *pJob = (CYouTubeUploadJob*)handle;
+		pJob->CancelUpload();
+		pJob->Release();
+	}
+}
+
+void CYouTubeSystem::SetUploadFinished( YouTubeUploadHandle_t handle, bool bSuccess, const char *pURLToVideo, const char *pURLToVideoStats )
+{
+	AUTO_LOCK( m_Mutex );
+	uploadstatus_t *pStatus = GetStatus( handle );
+	if ( pStatus )
+	{
+		pStatus->bFinished = true;
+		pStatus->bSuccess = bSuccess;
+		pStatus->strURLToVideo = pURLToVideo;
+		pStatus->strURLToVideoStats = pURLToVideoStats;
+	}
+}
+
+void CYouTubeSystem::SetUserProfile( const char *pUserProfile )
+{
+	AUTO_LOCK( m_Mutex );
+	m_strUserProfile = pUserProfile;
+	CUtlString author;
+	GetStandardTagValue( "author", m_strUserProfile.Get(), author );
+	GetStandardTagValue( "name", author.Get(), m_strYouTubeUserName );
+}
+
+YouTubeInfoHandle_t CYouTubeSystem::GetInfo( const char *pURLToVideoStats, CYouTubeResponseHandler &responseHandler )
+{
+	AUTO_LOCK( m_Mutex );
+	CYouTubeRetrieveInfoJob *pJob = new CYouTubeRetrieveInfoJob( this, pURLToVideoStats, responseHandler );
+	m_pThreadPool->AddJob( pJob );
+	m_vecRetrieveInfoJobs.AddToTail( pJob );
+	return (YouTubeInfoHandle_t)pJob;
+}
+
+void CYouTubeSystem::CancelGetInfo( YouTubeInfoHandle_t handle )
+{
+	AUTO_LOCK( m_Mutex );
+	int idx = m_vecRetrieveInfoJobs.Find( (CYouTubeRetrieveInfoJob*)handle );
+	if ( idx >= 0 && idx < m_vecRetrieveInfoJobs.Count() )
+	{
+		((CYouTubeRetrieveInfoJob*)handle)->Release();
+		m_vecRetrieveInfoJobs.FastRemove( idx );
+	}
+}
+
+void CYouTubeSystem::SetDeveloperSettings( const char *pDeveloperKey, const char *pDeveloperTag )
+{
+	AUTO_LOCK( m_Mutex );
+	m_strDeveloperKey = pDeveloperKey;
+	m_strDeveloperTag = pDeveloperTag;
+}
+
+const char *CYouTubeSystem::GetDeveloperKey() const
+{ 
+	AUTO_LOCK( m_Mutex );
+	return m_strDeveloperKey.Get(); 
+}
+
+const char *CYouTubeSystem::GetDeveloperTag() const
+{ 
+	AUTO_LOCK( m_Mutex );
+	return m_strDeveloperTag.Get(); 
+}
+
+const char *CYouTubeSystem::GetLoginName() const
+{
+	return m_strYouTubeUserName.Get();
+}
+
+eYouTubeLoginStatus CYouTubeSystem::GetLoginStatus() const
+{
+	return m_eLoginStatus;
+}
+
+bool CYouTubeSystem::GetProfileURL( CUtlString &strProfileURL ) const
+{
+	if ( m_eLoginStatus == kYouTubeLogin_LoggedIn )
+	{
+		strProfileURL = CFmtStr1024( "http://www.youtube.com/profile?user=%s", m_strYouTubeUserName.Get() );
+		return true;
+	}
+	return false;
+}
+
+void CYouTubeSystem::SetLoginStatus( eYouTubeLoginStatus status )
+{
+	AUTO_LOCK( m_Mutex );
+	m_eLoginStatus = status;
+	if ( m_eLoginStatus == kYouTubeLogin_LoggedIn )
+	{
+		CYouTubeRetrieveUserProfile *pJob = new CYouTubeRetrieveUserProfile( this );
+		m_pThreadPool->AddJob( pJob );
+		pJob->Release();
+	}
+}	
+
+void CYouTubeSystem::SetAuthToken( const char *pAuthToken )
+{
+	AUTO_LOCK( m_Mutex );
+	m_strAuthToken = pAuthToken;
+}
+
+const char* CYouTubeSystem::GetAuthToken() const
+{
+	AUTO_LOCK( m_Mutex );
+	return m_strAuthToken.Get();
+}
+
+//=============================================================================
+// Public API
+
+void YouTube_SetDeveloperSettings( const char *pDeveloperKey, const char *pDeveloperTag )
+{
+	gYouTube.SetDeveloperSettings( pDeveloperKey, pDeveloperTag );
+}
+
+void YouTube_Login( const char *pUserName, const char *pPassword, const char *pSource )
+{
+	if ( gYouTube.GetLoginStatus() == kYouTubeLogin_LoggedIn )
+	{
+		return;
+	}
+	gYouTube.Login( pUserName, pPassword, pSource );
+}
+
+void YouTube_LoginCancel()
+{
+	gYouTube.LoginCancel();
+}
+
+const char *YouTube_GetLoginName()
+{
+	return gYouTube.GetLoginName();
+}
+
+eYouTubeLoginStatus YouTube_GetLoginStatus()
+{
+	return gYouTube.GetLoginStatus();
+}
+
+bool YouTube_GetProfileURL( CUtlString &strProfileURL )
+{
+	return gYouTube.GetProfileURL( strProfileURL );
+}
+
+YouTubeUploadHandle_t YouTube_Upload( const char* pFilePath, const char *pMimeType, const char *pTitle, const char *pDescription, const char *pCategory, const char *pKeywords, eYouTubeAccessControl access )
+{
+	return gYouTube.Upload( pFilePath, pMimeType, pTitle, pDescription, pCategory, pKeywords, access );
+}
+
+bool YouTube_IsUploadFinished( YouTubeUploadHandle_t handle )
+{
+	return gYouTube.IsUploadFinished( handle );
+}
+
+bool YouTube_GetUploadProgress( YouTubeUploadHandle_t handle, double &ultotal, double &ulnow )
+{
+	return gYouTube.GetUploadProgress( handle, ultotal, ulnow );
+}
+
+bool YouTube_GetUploadResults( YouTubeUploadHandle_t handle, bool &bSuccess, CUtlString &strURLToVideo, CUtlString &strURLToVideoStats )
+{
+	return gYouTube.GetUploadResults( handle, bSuccess, strURLToVideo, strURLToVideoStats );
+}
+
+void YouTube_ClearUploadResults( YouTubeUploadHandle_t handle )
+{
+	gYouTube.ClearUploadResults( handle );
+}
+
+void YouTube_CancelUpload( YouTubeUploadHandle_t handle )
+{
+	gYouTube.CancelUpload( handle );
+}
+
+YouTubeInfoHandle_t YouTube_GetVideoInfo( const char *pURLToVideoStats, CYouTubeResponseHandler &responseHandler )
+{
+	return gYouTube.GetInfo( pURLToVideoStats, responseHandler );
+}
+
+void YouTube_CancelGetVideoInfo( YouTubeInfoHandle_t handle )
+{
+	gYouTube.CancelGetInfo( handle );
+}