PP_Resource
ppb_flash_menu_create(PP_Instance instance_id, const struct PP_Flash_Menu *menu_data)
{
struct pp_instance_s *pp_i = tables_get_pp_instance(instance_id);
if (!pp_i) {
trace_error("%s, bad instance\n", __func__);
return 0;
}
PP_Resource flash_menu = pp_resource_allocate(PP_RESOURCE_FLASH_MENU, pp_i);
if (pp_resource_get_type(flash_menu) != PP_RESOURCE_FLASH_MENU) {
trace_error("%s, resource allocation failure\n", __func__);
return 0;
}
struct flash_menu_create_param_s *p = g_slice_alloc0(sizeof(*p));
p->flash_menu = flash_menu;
p->menu_data = menu_data;
p->m_loop = ppb_message_loop_get_current();
p->depth = ppb_message_loop_get_depth(p->m_loop) + 1;
ppb_message_loop_post_work_with_result(p->m_loop, PP_MakeCCB(flash_menu_create_comt, p), 0,
PP_OK, p->depth, __func__);
ppb_message_loop_run_nested(p->m_loop);
g_slice_free1(sizeof(*p), p);
return flash_menu;
}
static
struct PP_Var
n2p_call(void *object, struct PP_Var method_name, uint32_t argc, struct PP_Var *argv,
struct PP_Var *exception)
{
if (method_name.type != PP_VARTYPE_STRING) {
trace_error("%s, method_name is not a string\n", __func__);
// TODO: fill exception
return PP_MakeUndefined();
}
struct call_param_s *p = g_slice_alloc(sizeof(*p));
p->object = object;
p->method_name = method_name;
p->argc = argc;
p->argv = argv;
p->exception = exception;
p->m_loop = ppb_message_loop_get_current();
p->depth = ppb_message_loop_get_depth(p->m_loop) + 1;
ppb_message_loop_post_work_with_result(p->m_loop, PP_MakeCCB(n2p_call_comt, p), 0, PP_OK,
p->depth, __func__);
ppb_message_loop_run_nested(p->m_loop);
struct PP_Var result = p->result;
g_slice_free1(sizeof(*p), p);
return result;
}
static
bool
n2p_has_property(void *object, struct PP_Var name, struct PP_Var *exception)
{
if (name.type != PP_VARTYPE_STRING) {
trace_error("%s, name is not a string\n", __func__);
// TODO: fill exception
return false;
}
struct has_property_param_s *p = g_slice_alloc(sizeof(*p));
p->object = object;
p->name = name;
p->exception = exception;
p->m_loop = ppb_message_loop_get_current();
p->depth = ppb_message_loop_get_depth(p->m_loop) + 1;
ppb_message_loop_post_work_with_result(p->m_loop, PP_MakeCCB(n2p_has_property_comt, p), 0,
PP_OK, p->depth, __func__);
ppb_message_loop_run_nested(p->m_loop);
bool result = p->result;
g_slice_free1(sizeof(*p), p);
return result;
}
bool
p2n_get_property(NPObject *npobj, NPIdentifier name, NPVariant *np_result)
{
if (!npn.identifierisstring(name)) {
trace_error("%s, name is not a string\n", __func__);
return false;
}
if (npobj->_class == &p2n_proxy_class) {
struct get_property_param_s *p = g_slice_alloc(sizeof(*p));
p->npobj = npobj;
p->name = npn.utf8fromidentifier(name);
p->np_result = np_result;
p->m_loop = ppb_message_loop_get_for_browser_thread();
p->depth = ppb_message_loop_get_depth(p->m_loop) + 1;
ppb_message_loop_post_work_with_result(p->m_loop,
PP_MakeCCB(p2n_get_property_prepare_comt, p), 0,
PP_OK, 0, __func__);
ppb_message_loop_run_nested(p->m_loop);
bool result = p->result;
npn.memfree(p->name);
g_slice_free1(sizeof(*p), p);
return result;
} else {
return npobj->_class->getProperty(npobj, name, np_result);
}
}
static
int
call_plugin_init_module(void)
{
int32_t (*ppp_initialize_module)(PP_Module module_id, PPB_GetInterface get_browser_interface);
if (!module_dl_handler)
return 0;
ppp_initialize_module = dlsym(module_dl_handler, "PPP_InitializeModule");
if (!ppp_initialize_module)
return 0;
struct call_plugin_init_module_param_s *p = g_slice_alloc(sizeof(*p));
p->m_loop = ppb_message_loop_get_for_browser_thread();
p->depth = ppb_message_loop_get_depth(p->m_loop) + 1;
p->ppp_initialize_module = ppp_initialize_module;
ppb_message_loop_post_work_with_result(p->m_loop,
PP_MakeCCB(call_plugin_init_module_prepare_comt, p), 0,
PP_OK, p->depth, __func__);
ppb_message_loop_run_nested(p->m_loop);
int res = p->result;
g_slice_free1(sizeof(*p), p);
return res;
}
static
void
n2p_deallocate(void *object)
{
struct deallocate_param_s *p = g_slice_alloc(sizeof(*p));
p->object = object;
p->m_loop = ppb_message_loop_get_current();
p->depth = ppb_message_loop_get_depth(p->m_loop) + 1;
ppb_message_loop_post_work_with_result(p->m_loop, PP_MakeCCB(n2p_deallocate_comt, p), 0, PP_OK,
p->depth, __func__);
ppb_message_loop_run_nested(p->m_loop);
g_slice_free1(sizeof(*p), p);
}
struct PP_Var
ppb_flash_get_proxy_for_url(PP_Instance instance, const char *url)
{
struct get_proxy_for_url_param_s *p = g_slice_alloc(sizeof(*p));
p->instance_id = instance;
p->url = url;
p->m_loop = ppb_message_loop_get_current();
p->depth = ppb_message_loop_get_depth(p->m_loop) + 1;
ppb_message_loop_post_work_with_result(p->m_loop, PP_MakeCCB(get_proxy_for_url_comt, p), 0,
PP_OK, p->depth, __func__);
ppb_message_loop_run_nested(p->m_loop);
struct PP_Var result = p->result;
g_slice_free1(sizeof(*p), p);
return result;
}
bool
p2n_enumerate(NPObject *npobj, NPIdentifier **value, uint32_t *count)
{
if (npobj->_class == &p2n_proxy_class) {
struct enumerate_param_s *p = g_slice_alloc(sizeof(*p));
p->npobj = npobj;
p->m_loop = ppb_message_loop_get_for_browser_thread();
p->depth = ppb_message_loop_get_depth(p->m_loop) + 1;
ppb_message_loop_post_work_with_result(p->m_loop, PP_MakeCCB(p2n_enumerate_prepare_comt, p),
0, PP_OK, 0, __func__);
ppb_message_loop_run_nested(p->m_loop);
bool result = p->result;
*count = p->count;
*value = npn.memalloc(p->count * sizeof(NPIdentifier));
char *tmpbuf = malloc(1);
for (uint32_t k = 0; k < p->count; k ++) {
uint32_t len = 0;
const char *s = ppb_var_var_to_utf8(p->values[k], &len);
// make zero-terminated string
char *ptr = realloc(tmpbuf, len + 1);
if (!ptr) {
result = false;
goto err;
}
tmpbuf = ptr;
memcpy(tmpbuf, s, len);
tmpbuf[len] = 0;
value[k] = npn.getstringidentifier(tmpbuf);
}
err:
free(tmpbuf);
g_slice_free1(sizeof(*p), p);
return result;
} else {
return npobj->_class->enumerate(npobj, value, count);
}
}
static
struct PP_Var
n2p_construct(void *object, uint32_t argc, struct PP_Var *argv, struct PP_Var *exception)
{
struct construct_param_s *p = g_slice_alloc(sizeof(*p));
p->object = object;
p->argc = argc;
p->argv = argv;
p->exception = exception;
p->m_loop = ppb_message_loop_get_current();
p->depth = ppb_message_loop_get_depth(p->m_loop) + 1;
ppb_message_loop_post_work_with_result(p->m_loop, PP_MakeCCB(n2p_construct_comt, p), 0, PP_OK,
p->depth, __func__);
ppb_message_loop_run_nested(p->m_loop);
struct PP_Var result = p->result;
g_slice_free1(sizeof(*p), p);
return result;
}
PP_Bool
ppb_flash_is_rect_topmost(PP_Instance instance, const struct PP_Rect *rect)
{
if (!rect)
return PP_FALSE;
struct topmost_rect_param_s *p = g_slice_alloc(sizeof(*p));
p->instance = instance;
p->rect = *rect;
p->m_loop = ppb_message_loop_get_current();
p->depth = ppb_message_loop_get_depth(p->m_loop) + 1;
ppb_message_loop_post_work_with_result(p->m_loop, PP_MakeCCB(topmost_rect_comt, p), 0, PP_OK,
p->depth, __func__);
ppb_message_loop_run_nested(p->m_loop);
PP_Bool result = p->result;
g_slice_free1(sizeof(*p), p);
return result;
}
struct PP_Var
ppb_flash_clipboard_read_data(PP_Instance instance_id, PP_Flash_Clipboard_Type clipboard_type,
uint32_t format)
{
if (!clipboard_type_and_format_are_supported(clipboard_type, format, __func__))
return PP_MakeUndefined();
struct clipboard_read_data_param_s *p = g_slice_alloc(sizeof(*p));
p->clipboard_type = clipboard_type;
p->format = format;
p->m_loop = ppb_message_loop_get_current();
p->depth = ppb_message_loop_get_depth(p->m_loop) + 1;
ppb_message_loop_post_work_with_result(p->m_loop, PP_MakeCCB(clipboard_read_data_comt, p), 0,
PP_OK, p->depth, __func__);
ppb_message_loop_run_nested(p->m_loop);
struct PP_Var result = p->result;
g_slice_free1(sizeof(*p), p);
return result;
}
static
void
call_plugin_shutdown_module(void)
{
if (!module_dl_handler)
return;
void (*ppp_shutdown_module)(void);
ppp_shutdown_module = dlsym(module_dl_handler, "PPP_ShutdownModule");
if (!ppp_shutdown_module)
return;
struct call_plugin_shutdown_module_param_s *p = g_slice_alloc(sizeof(*p));
p->m_loop = ppb_message_loop_get_for_browser_thread();
p->depth = ppb_message_loop_get_depth(p->m_loop) + 1;
p->ppp_shutdown_module = ppp_shutdown_module;
ppb_message_loop_post_work_with_result(p->m_loop,
PP_MakeCCB(call_plugin_shutdown_module_prepare_comt, p),
0, PP_OK, p->depth, __func__);
ppb_message_loop_run_nested(p->m_loop);
g_slice_free1(sizeof(*p), p);
}
int32_t
ppb_url_loader_follow_redirect(PP_Resource loader, struct PP_CompletionCallback callback)
{
struct pp_url_loader_s *ul = pp_resource_acquire(loader, PP_RESOURCE_URL_LOADER);
if (!ul) {
trace_error("%s, bad resource\n", __func__);
return PP_ERROR_BADRESOURCE;
}
char *new_url = nullsafe_strdup(ul->redirect_url);
free_and_nullify(ul, url);
free_and_nullify(ul, redirect_url);
free_and_nullify(ul, status_line);
free_and_nullify(ul, headers);
free_and_nullify(ul, request_headers);
if (ul->fd >= 0) {
close(ul->fd);
ul->fd = -1;
}
// abort further handling of the NPStream
if (ul->np_stream) {
ul->np_stream->pdata = NULL;
ul->np_stream = NULL;
}
ul->fd = open_temporary_file();
ul->url = new_url;
ul->read_pos = 0;
ul->method = PP_METHOD_GET;
ul->ccb = callback;
struct url_loader_open_param_s *p = g_slice_alloc(sizeof(*p));
p->url = ul->url;
p->loader = loader;
p->instance_id = ul->instance->id;
p->method = ul->method;
p->request_headers = ul->request_headers;
p->custom_referrer_url = ul->custom_referrer_url;
p->custom_content_transfer_encoding = ul->custom_content_transfer_encoding;
p->custom_user_agent = ul->custom_user_agent;
p->target = NULL;
p->post_len = 0;
p->post_data = NULL;
p->m_loop = ppb_message_loop_get_current();
p->depth = ppb_message_loop_get_depth(p->m_loop) + 1;
ppb_message_loop_post_work(p->m_loop, PP_MakeCCB(_url_loader_open_comt, p), 0);
ppb_message_loop_run_nested(p->m_loop);
pp_resource_release(loader);
int retval = p->retval;
g_slice_free1(sizeof(*p), p);
if (retval != NPERR_NO_ERROR)
return PP_ERROR_FAILED;
if (callback.func == NULL) {
int done = 0;
while (!done) {
ul = pp_resource_acquire(loader, PP_RESOURCE_URL_LOADER);
if (ul) {
done = ul->finished_loading;
pp_resource_release(loader);
} else {
break;
}
printf("waitin'\n");
usleep(10000);
}
return PP_OK;
}
return PP_OK_COMPLETIONPENDING;
}
int32_t
ppb_url_loader_open_target(PP_Resource loader, PP_Resource request_info,
struct PP_CompletionCallback callback, const char *target)
{
struct pp_url_loader_s *ul = pp_resource_acquire(loader, PP_RESOURCE_URL_LOADER);
if (!ul) {
trace_error("%s, bad resource\n", __func__);
return PP_ERROR_BADRESOURCE;
}
struct pp_url_request_info_s *ri = pp_resource_acquire(request_info,
PP_RESOURCE_URL_REQUEST_INFO);
if (!ri) {
trace_error("%s, bad resource\n", __func__);
pp_resource_release(loader);
return PP_ERROR_BADRESOURCE;
}
struct PP_Var full_url;
if (ri->is_immediate_javascript) {
full_url = ppb_var_var_from_utf8_z(ri->url);
} else {
struct PP_Var rel_url = ppb_var_var_from_utf8_z(ri->url);
full_url = ppb_url_util_dev_resolve_relative_to_document(ul->instance->id, rel_url, NULL);
ppb_var_release(rel_url);
}
ul->url = nullsafe_strdup(ppb_var_var_to_utf8(full_url, NULL));
ul->method = ri->method;
ul->read_pos = 0;
ul->request_headers = nullsafe_strdup(ri->headers);
ul->follow_redirects = ri->follow_redirects;
ul->stream_to_file = ri->stream_to_file;
ul->record_download_progress = ri->record_download_progress;
ul->record_upload_progress = ri->record_upload_progress;
ul->custom_referrer_url = nullsafe_strdup(ri->custom_referrer_url);
ul->allow_cross_origin_requests = ri->allow_cross_origin_requests;
ul->allow_credentials = ri->allow_credentials;
ul->custom_content_transfer_encoding = nullsafe_strdup(ri->custom_content_transfer_encoding);
ul->custom_user_agent = nullsafe_strdup(ri->custom_user_agent);
ul->target = nullsafe_strdup(target);
#define TRIM_NEWLINE(s) s = trim_nl(s)
TRIM_NEWLINE(ul->request_headers);
TRIM_NEWLINE(ul->custom_referrer_url);
TRIM_NEWLINE(ul->custom_content_transfer_encoding);
TRIM_NEWLINE(ul->custom_user_agent);
ul->post_len = ri->post_len;
if (ri->post_len > 0) {
ul->post_data = malloc(ri->post_len);
memcpy(ul->post_data, ri->post_data, ri->post_len);
}
ul->fd = open_temporary_file();
ul->ccb = callback;
ppb_var_release(full_url);
pp_resource_release(request_info);
struct url_loader_open_param_s *p = g_slice_alloc(sizeof(*p));
p->url = ul->url;
p->loader = loader;
p->instance_id = ul->instance->id;
p->method = ul->method;
p->request_headers = ul->request_headers;
p->custom_referrer_url = ul->custom_referrer_url;
p->custom_content_transfer_encoding = ul->custom_content_transfer_encoding;
p->custom_user_agent = ul->custom_user_agent;
p->target = ul->target;
p->post_len = ul->post_len;
p->post_data = ul->post_data;
p->m_loop = ppb_message_loop_get_current();
p->depth = ppb_message_loop_get_depth(p->m_loop) + 1;
ppb_core_add_ref_resource(loader); // add ref to ensure data in ul remain accessible
pp_resource_release(loader);
ppb_message_loop_post_work(p->m_loop, PP_MakeCCB(_url_loader_open_comt, p), 0);
ppb_message_loop_run_nested(p->m_loop);
ppb_core_release_resource(loader);
int retval = p->retval;
g_slice_free1(sizeof(*p), p);
if (retval != NPERR_NO_ERROR)
return PP_ERROR_FAILED;
if (callback.func == NULL) {
int done = 0;
while (!done) {
ul = pp_resource_acquire(loader, PP_RESOURCE_URL_LOADER);
if (ul) {
done = ul->finished_loading;
pp_resource_release(loader);
} else {
break;
}
printf("waitin'\n");
usleep(10000);
}
return PP_OK;
}
return PP_OK_COMPLETIONPENDING;
}
