struct PP_Var
ppb_font_dev_get_font_families(PP_Instance instance)
{
PangoFontFamily **families;
int n, k, total_len;
pango_font_map_list_families(tables_get_pango_font_map(), &families, &n);
total_len = 0;
for (k = 0; k < n; k ++) {
const char *name = pango_font_family_get_name(families[k]);
total_len += strlen(name) + 1; // with '\0' at the end
}
char *s = malloc(total_len);
char *ptr = s;
for (k = 0; k < n; k ++) {
const char *name = pango_font_family_get_name(families[k]);
const int len = strlen(name);
memcpy(ptr, name, len + 1); // with '\0' at the end
ptr += len + 1;
}
struct PP_Var var = ppb_var_var_from_utf8(s, total_len);
free(s);
g_free(families);
return var;
}
int32_t
ppb_flash_drm_get_device_id(PP_Resource drm, struct PP_Var *id,
struct PP_CompletionCallback callback)
{
const char *salt_fname = fpp_config_get_pepper_salt_file_name();
FILE *fp;
char salt[salt_length];
(void)drm;
fp = fopen(salt_fname, "rb");
if (!fp) {
// create salt
trace_info("%s, creating salt file\n", __func__);
fp = fopen(salt_fname, "wb");
if (!fp) {
trace_error("%s, can't create salt file\n", __func__);
return PP_ERROR_FAILED;
}
get_system_salt(salt);
size_t written = fwrite(salt, 1, salt_length, fp);
fclose(fp);
if (written != salt_length) {
trace_error("%s, can't write to salt file\n", __func__);
return PP_ERROR_FAILED;
}
fp = fopen(salt_fname, "rb");
if (!fp) {
trace_error("%s, can't open salt file\n", __func__);
return PP_ERROR_FAILED;
}
}
size_t read_bytes = fread(salt, 1, salt_length, fp);
fclose(fp);
if (read_bytes != salt_length) {
trace_error("%s, truncated salt file. Remove it and try again\n", __func__);
return PP_ERROR_FAILED;
}
*id = ppb_var_var_from_utf8(salt, salt_length);
ppb_core_call_on_main_thread2(0, callback, PP_OK, __func__);
return PP_OK_COMPLETIONPENDING;
}
static
void
_get_document_url_ptac(void *user_data)
{
struct get_document_url_param_s *p = user_data;
p->result = ppb_var_var_from_utf8("", 0);
NPIdentifier location_id = npn.getstringidentifier("location");
NPIdentifier href_id = npn.getstringidentifier("href");
NPObject *np_location_obj;
NPVariant location_var, href_var;
if (!npn.getproperty(p->npp, p->np_window_obj, location_id, &location_var))
goto err_2;
if (location_var.type != NPVariantType_Object)
goto err_3;
np_location_obj = location_var.value.objectValue;
if (!npn.getproperty(p->npp, np_location_obj, href_id, &href_var))
goto err_3;
struct PP_Var var = np_variant_to_pp_var(href_var);
if (var.type != PP_VARTYPE_STRING) {
ppb_var_release(var);
goto err_4;
}
ppb_var_release(p->result);
p->result = var;
err_4:
npn.releasevariantvalue(&href_var);
err_3:
npn.releasevariantvalue(&location_var);
err_2:
ppb_message_loop_post_quit_depth(p->m_loop, PP_FALSE, p->depth);
return;
}
static
void
clipboard_read_data_ptac(void *user_data)
{
struct clipboard_read_data_param_s *p = user_data;
p->result = PP_MakeUndefined();
GtkClipboard *clipboard = get_clipboard_of_type(p->clipboard_type);
if (!clipboard)
goto quit;
GdkAtom target = get_clipboard_target_atom(p->format);
if (target == GDK_NONE)
goto quit;
GtkSelectionData *sd = gw_gtk_clipboard_wait_for_contents(clipboard, target);
if (sd) {
const guchar *sd_data = gw_gtk_selection_data_get_data(sd);
const gint sd_length = gw_gtk_selection_data_get_length(sd);
switch (p->format) {
case PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT:
case PP_FLASH_CLIPBOARD_FORMAT_HTML:
p->result = ppb_var_var_from_utf8((char *)sd_data, sd_length);
break;
default:
p->result = ppb_var_array_buffer_create(sd_length);
memcpy(ppb_var_array_buffer_map(p->result), sd_data, sd_length);
ppb_var_array_buffer_unmap(p->result);
break;
}
gw_gtk_selection_data_free(sd);
}
quit:
ppb_message_loop_post_quit_depth(p->m_loop, PP_FALSE, p->depth);
}
PP_Bool
ppb_flash_draw_glyphs(PP_Instance instance, PP_Resource pp_image_data,
const struct PP_BrowserFont_Trusted_Description *font_desc,
uint32_t color, const struct PP_Point *position, const struct PP_Rect *clip,
const float transformation[3][3], PP_Bool allow_subpixel_aa,
uint32_t glyph_count, const uint16_t glyph_indices[],
const struct PP_Point glyph_advances[])
{
struct pp_image_data_s *id = pp_resource_acquire(pp_image_data, PP_RESOURCE_IMAGE_DATA);
if (!id) {
trace_error("%s, bad resource\n", __func__);
return PP_FALSE;
}
cairo_t *cr = cairo_create(id->cairo_surf);
const char *font_family;
if (font_desc->face.type == PP_VARTYPE_STRING) {
font_family = ppb_var_var_to_utf8(font_desc->face, NULL);
} else {
switch (font_desc->family) {
case PP_BROWSERFONT_TRUSTED_FAMILY_SERIF:
font_family = "serif";
break;
case PP_BROWSERFONT_TRUSTED_FAMILY_SANSSERIF:
font_family = "sans-serif";
break;
case PP_BROWSERFONT_TRUSTED_FAMILY_MONOSPACE:
font_family = "monospace";
break;
default:
font_family = "";
break;
}
}
cairo_select_font_face(cr, font_family,
font_desc->italic ? CAIRO_FONT_SLANT_ITALIC
: CAIRO_FONT_SLANT_NORMAL,
font_desc->weight >= (int)PP_FONTWEIGHT_700 ? CAIRO_FONT_WEIGHT_BOLD
: CAIRO_FONT_WEIGHT_NORMAL);
cairo_set_font_size(cr, font_desc->size);
if (allow_subpixel_aa) {
cairo_font_options_t *options = cairo_font_options_create();
cairo_font_options_set_antialias(options, CAIRO_ANTIALIAS_SUBPIXEL);
cairo_set_font_options(cr, options);
cairo_font_options_destroy(options);
}
if (clip) {
cairo_rectangle(cr, clip->point.x, clip->point.y, clip->size.width, clip->size.height);
cairo_clip(cr);
}
cairo_set_source_rgba(cr, ((color >> 16) & 0xffu) / 255.0,
((color >> 8) & 0xffu) / 255.0,
((color >> 0) & 0xffu) / 255.0,
((color >> 24) & 0xffu) / 255.0);
cairo_matrix_t matrix;
cairo_matrix_init(&matrix, transformation[0][0], transformation[0][1],
transformation[1][0], transformation[1][1],
transformation[0][2], transformation[1][2]);
cairo_set_matrix(cr, &matrix);
cairo_glyph_t *c_glyphs = malloc(glyph_count * sizeof(cairo_glyph_t));
struct PP_Point current = {.x = 0, .y = 0};
for (uint32_t k = 0; k < glyph_count; k ++) {
c_glyphs[k].index = glyph_indices[k];
c_glyphs[k].x = current.x;
c_glyphs[k].y = current.y;
current.x += glyph_advances[k].x;
current.y += glyph_advances[k].y;
}
cairo_show_glyphs(cr, c_glyphs, glyph_count);
free(c_glyphs);
cairo_surface_flush(id->cairo_surf);
cairo_destroy(cr);
pp_resource_release(pp_image_data);
return PP_TRUE;
}
struct get_proxy_for_url_param_s {
PP_Instance instance_id;
const char *url;
struct PP_Var result;
PP_Resource m_loop;
int depth;
};
static
void
get_proxy_for_url_ptac(void *user_data)
{
struct get_proxy_for_url_param_s *p = user_data;
struct pp_instance_s *pp_i = tables_get_pp_instance(p->instance_id);
p->result = PP_MakeUndefined();
if (pp_i && pp_i->npp && npn.getvalueforurl) {
char *value = NULL;
uint32_t len = 0;
NPError err;
err = npn.getvalueforurl(pp_i->npp, NPNURLVProxy, p->url, &value, &len);
if (err == NPERR_NO_ERROR) {
p->result = ppb_var_var_from_utf8(value, len);
}
}
ppb_message_loop_post_quit_depth(p->m_loop, PP_FALSE, p->depth);
}
static
void
get_proxy_for_url_comt(void *user_data, int32_t result)
{
ppb_core_call_on_browser_thread(0, get_proxy_for_url_ptac, user_data);
}
