C++ (Cpp) loadHandler Examples

Example #1

File: browser-manager-base.cpp Project: The-Design-Zoo/obs-studio

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);

	CefPostTask(TID_UI, BrowserTask::newTask(
			[&] 
	{

		CefRefPtr<BrowserRenderHandler> renderHandler(
				new BrowserRenderHandler(browserSettings.width, 
				browserSettings.height, browserListener));

		CefRefPtr<BrowserLoadHandler> loadHandler(
				new BrowserLoadHandler(browserSettings.css));

		CefRefPtr<BrowserClient> browserClient(
				new BrowserClient(renderHandler,loadHandler)); 

		CefWindowInfo windowInfo;
		windowInfo.transparent_painting_enabled = true;
		windowInfo.width = browserSettings.width;
		windowInfo.height = browserSettings.height;
		windowInfo.windowless_rendering_enabled = true;

		CefBrowserSettings cefBrowserSettings;
		cefBrowserSettings.windowless_frame_rate = browserSettings.fps;

		CefRefPtr<CefBrowser> browser =
				CefBrowserHost::CreateBrowserSync(windowInfo, 
				browserClient, browserSettings.url, 
				cefBrowserSettings, nullptr);

		if (browser != nullptr) {
			browserIdentifier = browser->GetIdentifier();
			browserMap[browserIdentifier] = browser;
		}
		os_event_signal(createdEvent);
	}));

	os_event_wait(createdEvent);
	os_event_destroy(createdEvent);
	return browserIdentifier;
}

Example #2

File: main.c Project: interfector/mcvm

int
main(int argc, char** argv)
{
	asm_env* env = malloc( sizeof(asm_env) );
	struct assembly opcode = { 0, 0, 0, NULL };
	unsigned char* args;
	int i;

	FILE* fp;
	struct stat st;

	for(i = 0;i < R_REGS;i++)
		env->regs[ i ] = 0;

	env->eflags =
	env->current_op = 
	env->current_args = 0;

	/*
	env->mem_size = sizeof( assembly_code );
	env->mem_base = malloc( env->mem_size );

	memset( env->mem_base, 0x00, env->mem_size );
	memcpy( env->mem_base, assembly_code, sizeof(assembly_code) );
	*/

	if(!argv[1])
	{
		printf("Usage: %s <file>\n", argv[0]);
		return 1;
	}

	if(!(fp = fopen(argv[1], "r")))
		pdie("fopen", 2);

	if(stat(argv[1], &st) < 0)
		pdie("stat", 3);

	env->mem_size = (int) st.st_size;
	env->mem_base = malloc( env->mem_size + STACKSTART );
	memset( env->mem_base, 0x00, env->mem_size + STACKSTART );

	env->regs[ R_EBP ] = env->regs[ R_ESP ] = (unsigned int)STACKSTART;
	env->regs[ R_ESP ] += 4; /* - */

	if(fread(env->mem_base, 1, env->mem_size, fp) != env->mem_size)
		pdie("fread", 4);

	fclose( fp );

	env->mem_size += (STACKSTART + STACKSIZE);

	if(getenv("LIBSYSCALL"))
		loadHandler();

	for(env->eip = 0;env->eip < env->mem_size;env->eip++)
	{
		env->current_op = env->mem_base[ env->eip ];
		opcode = getOpcode( env->mem_base[ env->eip ] );

		if( !opcode.function )
			die( env, "SIGILL" );

		if( opcode.bytes > 0 )
		{
			env->current_args = 0;
			args = malloc( opcode.bytes );
			memcpy( args, env->mem_base + env->eip + 1, opcode.bytes);

			for(i = 0;i < opcode.bytes;i++)
				env->current_args |= (args[i] << (i * 8));
		}

		opcode.function( env );

		env->eip += opcode.bytes;
	}

	env->eip -= (opcode.bytes + 1);

	dumpAll( env );

	free( env );

	return 0;
}