Use CEF multi-threaded handler and use C++11

Michael Fabian Dirks · jp9000 · commit 5e9ad21efe71 · 2017-01-16T03:07:31.000-08:00
This also enables CEF sandboxing, which should help users be more secure against harmful ads and sites. Closes #58
diff --git a/obs-browser/browser-manager-base.cpp b/obs-browser/browser-manager-base.cpp
@@ -9,6 +9,8 @@
 #include "browser-render-handler.hpp"
 #include "browser-load-handler.hpp"
 #include "browser-obs-bridge-base.hpp"
+#include <chrono>
+#include <thread>
 
 BrowserManager::BrowserManager()
 : pimpl(new BrowserManager::Impl())
@@ -104,25 +106,31 @@ void BrowserManager::DispatchJSEvent(const char *eventName, const char *jsonStri
 	pimpl->DispatchJSEvent(eventName, jsonString);
 }
 
-BrowserManager::Impl::Impl()
+std::string getBootstrap()
 {
-	os_event_init(&dispatchEvent, OS_EVENT_TYPE_AUTO);
-	pthread_mutex_init(&dispatchLock, nullptr);
+	std::string modulePath(BrowserManager::Instance()->GetModulePath());
+	std::string parentPath(modulePath.substr(0,
+		modulePath.find_last_of('/') + 1));
+#ifdef _WIN32
+	return parentPath + "/cef-bootstrap.exe";
+#else
+	return parentPath + "/cef-bootstrap";
+#endif
 }
 
-BrowserManager::Impl::~Impl()
-{
-	os_event_destroy(dispatchEvent);
-	pthread_mutex_destroy(&dispatchLock);
-}
+//////////////////////////////////////////////////////////////////////////
+// BrowserManager::Impl
+BrowserManager::Impl::Impl() {}
+
+BrowserManager::Impl::~Impl() {}
 
 int BrowserManager::Impl::CreateBrowser(
 		const BrowserSettings &browserSettings,
 		const std::shared_ptr<BrowserListener> &browserListener)
 {
 	int browserIdentifier = 0;
-	os_event_t *createdEvent;
-	os_event_init(&createdEvent, OS_EVENT_TYPE_AUTO);
+	std::mutex createMutex;
+	std::condition_variable createEvent;
 
 	BrowserOBSBridge *browserOBSBridge = new BrowserOBSBridgeBase();
 
@@ -157,11 +165,11 @@ int BrowserManager::Impl::CreateBrowser(
 			browserIdentifier = browser->GetIdentifier();
 			browserMap[browserIdentifier] = browser;
 		}
-		os_event_signal(createdEvent);
+		createEvent.notify_all();
 	}));
 
-	os_event_wait(createdEvent);
-	os_event_destroy(createdEvent);
+	std::unique_lock<std::mutex> createLock(createMutex);
+	createEvent.wait(createLock);
 	return browserIdentifier;
 }
 
@@ -170,15 +178,14 @@ BrowserManager::Impl::DestroyBrowser(int browserIdentifier)
 {
 	if (browserMap.count(browserIdentifier) > 0) {
 		CefRefPtr<CefBrowser> browser = browserMap[browserIdentifier];
-		os_event_t *closeEvent;
-		os_event_init(&closeEvent, OS_EVENT_TYPE_AUTO);
-		CefPostTask(TID_UI, BrowserTask::newTask([&, browser] 
+		std::mutex closeMutex;
+		std::condition_variable closeEvent;
+		CefPostTask(TID_UI, BrowserTask::newTask([&, browser]
 		{
 			browser->GetHost()->CloseBrowser(true);
-			os_event_signal(closeEvent);
+			closeEvent.notify_all();
 		}));
-		os_event_wait(closeEvent);
-		os_event_destroy(closeEvent);
+		closeEvent.wait(std::unique_lock<std::mutex>(closeMutex));
 		browserMap.erase(browserIdentifier);
 	}
 }
@@ -198,14 +205,13 @@ void BrowserManager::Impl::ExecuteOnBrowser(int browserIdentifier,
 				f(browser);
 			}));
 		} else {
-			os_event_t *finishedEvent;
-			os_event_init(&finishedEvent, OS_EVENT_TYPE_AUTO);
+			std::mutex finishedMutex;
+			std::condition_variable finishedEvent;
 			CefPostTask(TID_UI, BrowserTask::newTask([&] {
 				f(browser);
-				os_event_signal(finishedEvent);
+				finishedEvent.notify_all();
 			}));
-			os_event_wait(finishedEvent);
-			os_event_destroy(finishedEvent);
+			finishedEvent.wait(std::unique_lock<std::mutex>(finishedMutex));
 		}
 	}
 }
@@ -221,14 +227,13 @@ void BrowserManager::Impl::ExecuteOnAllBrowsers(
 				f(browser);
 			}));
 		} else {
-			os_event_t *finishedEvent;
-			os_event_init(&finishedEvent, OS_EVENT_TYPE_AUTO);
+			std::mutex finishedMutex;
+			std::condition_variable finishedEvent;
 			CefPostTask(TID_UI, BrowserTask::newTask([&] {
 				f(browser);
-				os_event_signal(finishedEvent);
+				finishedEvent.notify_all();
 			}));
-			os_event_wait(finishedEvent);
-			os_event_destroy(finishedEvent);
+			finishedEvent.wait(std::unique_lock<std::mutex>(finishedMutex));
 		}
 	}
 }
@@ -363,112 +368,69 @@ void BrowserManager::Impl::DispatchJSEvent(const char *eventName, const char *js
 	});
 }
 
-void
-BrowserManager::Impl::Startup() 
+void BrowserManager::Impl::Startup()
 {
-	pthread_mutex_lock(&dispatchLock);
-	int ret = pthread_create(&managerThread, nullptr,
-		browserManagerEntry, this);
-	
-	if (ret != 0) {
-		blog(LOG_ERROR,
-			"BrowserManager: failed to create browser "
-			"manager thread.");
-		threadAlive = false;
-	}
-	else {
-		threadAlive = true;
-	}
-	pthread_mutex_unlock(&dispatchLock);
-		
-	return;
-}
+	// Initialize CEF
+	CefMainArgs mainArgs;
+	CefSettings settings;
+	settings.log_severity = LOGSEVERITY_VERBOSE;
+	settings.windowless_rendering_enabled = true;
+	settings.no_sandbox = false;
+	settings.multi_threaded_message_loop = true;
+	CefString(&settings.cache_path).FromASCII(obs_module_config_path(""));
+	CefString(&settings.browser_subprocess_path) = getBootstrap();
+	CefRefPtr<BrowserApp> app(new BrowserApp());
+	CefExecuteProcess(mainArgs, app, nullptr);
+	CefInitialize(mainArgs, settings, app, nullptr);
+	CefRegisterSchemeHandlerFactory("http", "absolute", new BrowserSchemeHandlerFactory());
 
-void BrowserManager::Impl::Shutdown() 
-{
-	os_event_t *shutdown_event;
-	os_event_init(&shutdown_event, OS_EVENT_TYPE_AUTO);
-
-	// post the task
-	CefPostTask(TID_UI, BrowserTask::newTask([] {
-		CefQuitMessageLoop();
-	}));
+	// Initialize event queue.
+	{
+		std::lock_guard<std::mutex> lock(events.mutex);
+		events.bQuit = false;
+		events.thread = std::thread(QueueThreadMain, this);
+	}
 
-	// this event will then get processed and shut down the dispatcher loop
-	PushEvent([this, shutdown_event] {
-		threadAlive = false;
-		os_event_signal(shutdown_event);
-	});
 
-	os_event_wait(shutdown_event);
-	os_event_destroy(shutdown_event);
 	return;
 }
 
-void *BrowserManager::Impl::browserManagerEntry(void* threadArgument)
+void BrowserManager::Impl::Shutdown()
 {
-	BrowserManager::Impl *browserManager =
-			static_cast<BrowserManager::Impl *>(threadArgument);
-	browserManager->BrowserManagerEntry();
-	return nullptr;
+	// Quit Event Thread
+	events.bQuit = true;
+	events.condvar.notify_all();
+	events.thread.join();
+
+	// Shut down CEF
+	CefShutdown();
+	return;
 }
 
 void BrowserManager::Impl::PushEvent(std::function<void()> event)
 {
-	pthread_mutex_lock(&dispatchLock);
-	queue.push_back(event);
-	pthread_mutex_unlock(&dispatchLock);
-	os_event_signal(dispatchEvent);
+	std::lock_guard<std::mutex> lock(events.mutex);
+	events.queue.push(event);
+	events.condvar.notify_one();
 }
 
-std::string getBootstrap()
+void BrowserManager::Impl::QueueThreadMain(void* data)
 {
-	std::string modulePath(BrowserManager::Instance()->GetModulePath());
-	std::string parentPath(modulePath.substr(0,
-			modulePath.find_last_of('/') + 1));
-#ifdef _WIN32	
-	return parentPath + "/cef-bootstrap.exe";
-#else
-	return parentPath + "/cef-bootstrap";
-#endif
+	auto obj = static_cast<BrowserManager::Impl*>(data);
+	obj->QueueThreadLocalMain();
 }
 
-void BrowserManager::Impl::BrowserManagerEntry()
-{
-	std::string bootstrapPath = getBootstrap();
-	bool thread_exit = false;
-	PushEvent([] {
-		CefMainArgs mainArgs;
-		CefSettings settings;
-		settings.log_severity = LOGSEVERITY_VERBOSE;
-		settings.windowless_rendering_enabled = true;
-		settings.no_sandbox = true;
-		CefString(&settings.cache_path).FromASCII(obs_module_config_path(""));
-		CefString(&settings.browser_subprocess_path) = getBootstrap();
-		CefRefPtr<BrowserApp> app(new BrowserApp());
-		CefExecuteProcess(mainArgs, app, nullptr);
-		CefInitialize(mainArgs, settings, app, nullptr);
-		CefRegisterSchemeHandlerFactory("http", "absolute", new BrowserSchemeHandlerFactory());
-		CefRunMessageLoop();
-		CefShutdown();
-	});
-
-	while (true) {
-		
-		if (os_event_timedwait(dispatchEvent, 10) != ETIMEDOUT) {
-			pthread_mutex_lock(&dispatchLock);
-			while (!queue.empty()) {
-				auto event = queue[0];
-				event();
-				queue.erase(queue.begin());
-			}
-			thread_exit = !threadAlive;
-			pthread_mutex_unlock(&dispatchLock);
-			if (thread_exit) {
-				return;
-			}
+void BrowserManager::Impl::QueueThreadLocalMain()
+{
+	std::unique_lock<std::mutex> ulock(events.mutex);
+	do {
+		events.condvar.wait(ulock);
+		while (events.queue.size() > 0) {
+			auto v = events.queue.front();
+			v();
+			events.queue.pop();
 		}
-	}
+	} while (events.bQuit == false);
 }
 
 static BrowserManager *instance;
diff --git a/obs-browser/browser-manager-base.hpp b/obs-browser/browser-manager-base.hpp
@@ -9,6 +9,11 @@
 #include <functional>
 #include <util/threading.h>
 
+#include <thread>
+#include <mutex>
+#include <condition_variable>
+#include <queue>
+
 #include "browser-manager.hpp"
 
 class BrowserManager::Impl
@@ -18,14 +23,6 @@ class BrowserManager::Impl
 	Impl();
 	~Impl();
 
-private:
-
-	static void *browserManagerEntry(void* threadArguments);
-	void BrowserManagerEntry();
-
-
-public:
-
 	void Startup();
 	void Shutdown();
 	
@@ -71,12 +68,19 @@ class BrowserManager::Impl
 			bool async = false);
 
 private:
-	bool threadAlive;
-	os_event_t *dispatchEvent;
-	pthread_t managerThread;
-	pthread_mutex_t dispatchLock;
-
 	std::map<int, std::shared_ptr<BrowserListener>> listenerMap;
 	std::map<int, CefRefPtr<CefBrowser> > browserMap;
-	std::vector<std::function<void()>> queue;
+
+	// Holds Queue related Information
+	struct {
+		std::thread thread;
+		std::mutex mutex;
+		std::condition_variable condvar;
+		std::queue<std::function<void()>> queue;
+
+		bool bQuit = false;
+	} events;
+	static void QueueThreadMain(void*);
+	void QueueThreadLocalMain();
+
 };
