bool TCPSocketChild::RecvCallback(const nsString& aType, const CallbackData& aData, const uint32_t& aReadyState) { mSocket->UpdateReadyState(aReadyState); if (aData.type() == CallbackData::Tvoid_t) { mSocket->FireEvent(aType); } else if (aData.type() == CallbackData::TTCPError) { const TCPError& err(aData.get_TCPError()); mSocket->FireErrorEvent(err.name(), err.message()); } else if (aData.type() == CallbackData::TSendableData) { const SendableData& data = aData.get_SendableData(); if (data.type() == SendableData::TArrayOfuint8_t) { mSocket->FireDataArrayEvent(aType, data.get_ArrayOfuint8_t()); } else if (data.type() == SendableData::TnsCString) { mSocket->FireDataStringEvent(aType, data.get_nsCString()); } else { MOZ_CRASH("Invalid callback data type!"); } } else { MOZ_CRASH("Invalid callback type!"); } return true; }
bool SBBreakpoint::PrivateBreakpointHitCallback(void *baton, StoppointCallbackContext *ctx, lldb::user_id_t break_id, lldb::user_id_t break_loc_id) { ExecutionContext exe_ctx (ctx->exe_ctx_ref); BreakpointSP bp_sp(exe_ctx.GetTargetRef().GetBreakpointList().FindBreakpointByID(break_id)); if (baton && bp_sp) { CallbackData *data = (CallbackData *)baton; lldb_private::Breakpoint *bp = bp_sp.get(); if (bp && data->callback) { Process *process = exe_ctx.GetProcessPtr(); if (process) { SBProcess sb_process (process->shared_from_this()); SBThread sb_thread; SBBreakpointLocation sb_location; assert (bp_sp); sb_location.SetLocation (bp_sp->FindLocationByID (break_loc_id)); Thread *thread = exe_ctx.GetThreadPtr(); if (thread) sb_thread.SetThread(thread->shared_from_this()); return data->callback (data->callback_baton, sb_process, sb_thread, sb_location); } } } return true; // Return true if we should stop at this breakpoint }
gboolean gtk_callback(void* callback) { CallbackData* cdata = (CallbackData*)callback; cdata->func(cdata->data); delete cdata; return false; }
/****************************************************************************** * void Event::setCallback ******************************************************************************/ void Event::setCallback(cl_int command_exec_callback_type, event_callback callback, void *user_data) { CallbackData data; bool call_now = false; data.callback = callback; data.user_data = user_data; pthread_mutex_lock(&p_state_mutex); /* if event already in or past command_exec_callback_type, call callback */ /* cl.h: CL_COMPLETE 0, CL_RUNNING 1, CL_SUBMITTED 2, CL_QUEUED 3 */ if (command_exec_callback_type >= p_status) call_now = true; else p_callbacks.insert(std::pair<Status, CallbackData>( (Status)command_exec_callback_type, data) ); pthread_mutex_unlock(&p_state_mutex); if (call_now) data.callback(desc(this), p_status, data.user_data); }
// static void AudioOutput::CallbackWrapper(int aEvent, void* aCookie, void* aInfo) { CallbackData* data = (CallbackData*) aCookie; data->Lock(); AudioOutput* me = data->GetOutput(); AudioTrack::Buffer* buffer = (AudioTrack::Buffer*) aInfo; if (!me) { // no output set, likely because the track was scheduled to be reused // by another player, but the format turned out to be incompatible. data->Unlock(); if (buffer) { buffer->size = 0; } return; } switch(aEvent) { case AudioTrack::EVENT_MORE_DATA: { size_t actualSize = (*me->mCallback)(me, buffer->raw, buffer->size, me->mCallbackCookie, CB_EVENT_FILL_BUFFER); if (actualSize == 0 && buffer->size > 0) { // We've reached EOS but the audio track is not stopped yet, // keep playing silence. memset(buffer->raw, 0, buffer->size); actualSize = buffer->size; } buffer->size = actualSize; } break; case AudioTrack::EVENT_STREAM_END: AUDIO_OFFLOAD_LOG(PR_LOG_DEBUG, ("Callback wrapper: EVENT_STREAM_END")); (*me->mCallback)(me, nullptr /* buffer */, 0 /* size */, me->mCallbackCookie, CB_EVENT_STREAM_END); break; case AudioTrack::EVENT_NEW_IAUDIOTRACK : AUDIO_OFFLOAD_LOG(PR_LOG_DEBUG, ("Callback wrapper: EVENT_TEAR_DOWN")); (*me->mCallback)(me, nullptr /* buffer */, 0 /* size */, me->mCallbackCookie, CB_EVENT_TEAR_DOWN); break; default: AUDIO_OFFLOAD_LOG(PR_LOG_DEBUG, ("received unknown event type: %d in" " Callback wrapper!", aEvent)); break; } data->Unlock(); }
static gboolean emit_select_callback_in_idle (gpointer user_data) { CallbackData *data = user_data; if (!data->aborted) data->callback (&data->rectangle, data->callback_data); else data->callback (NULL, data->callback_data); g_slice_free (CallbackData, data); return FALSE; }
static gboolean password_requester (GMimeCryptoContext *ctx, const char *user_id, const char* prompt_ctx, gboolean reprompt, GMimeStream *response, GError **err) { CallbackData *cbdata; gchar *password; ssize_t written; cbdata = g_object_get_data (G_OBJECT(ctx), CALLBACK_DATA); if (!cbdata || !cbdata->pw_func) return FALSE; password = cbdata->pw_func (user_id, prompt_ctx, reprompt, cbdata->user_data); if (!password) { mu_util_g_set_error (err, MU_ERROR_CRYPTO, "failed to get password"); return FALSE; } written = g_mime_stream_write_string (response, password); if (written != -1) written = g_mime_stream_write_string (response, "\n"); if (written == -1) mu_util_g_set_error (err, MU_ERROR_CRYPTO, "writing password to mime stream failed"); /* it seems that GMime tries to flush the fd; however, this * does not work for pipes/sockets, causing getting a password * to fail. * * I have reported this, and it has been fixed now: * * http://git.gnome.org/browse/gmime/commit/ * ?id=bda4834d3d9a1fbefb6d97edfef2bc1da9357f58 * * however, it may take a while before everybody has this * version of GMime (ie. version > 2.6.10) * */ memset (password, 0, strlen(password)); g_free (password); return written != -1 ? TRUE : FALSE; }
bool TCPSocketChild::RecvCallback(const nsString& aType, const CallbackData& aData, const nsString& aReadyState, const uint32_t& aBuffered) { if (NS_FAILED(mSocket->UpdateReadyStateAndBuffered(aReadyState, aBuffered))) NS_ERROR("Shouldn't fail!"); nsresult rv = NS_ERROR_FAILURE; if (aData.type() == CallbackData::Tvoid_t) { rv = mSocket->CallListenerVoid(aType); } else if (aData.type() == CallbackData::TTCPError) { const TCPError& err(aData.get_TCPError()); rv = mSocket->CallListenerError(aType, err.name()); } else if (aData.type() == CallbackData::TSendableData) { const SendableData& data = aData.get_SendableData(); if (data.type() == SendableData::TArrayOfuint8_t) { JSContext* cx = nsContentUtils::GetSafeJSContext(); JS::Rooted<JS::Value> val(cx); JS::Rooted<JSObject*> window(cx, mWindowObj); bool ok = IPC::DeserializeArrayBuffer(window, data.get_ArrayOfuint8_t(), &val); NS_ENSURE_TRUE(ok, true); rv = mSocket->CallListenerArrayBuffer(aType, val); } else if (data.type() == SendableData::TnsString) { rv = mSocket->CallListenerData(aType, data.get_nsString()); } else { MOZ_CRASH("Invalid callback data type!"); } } else { MOZ_CRASH("Invalid callback type!"); } NS_ENSURE_SUCCESS(rv, true); return true; }
static gboolean password_requester (GMimeCryptoContext *ctx, const char *user_id, const char* prompt_ctx, gboolean reprompt, GMimeStream *response, GError **err) { CallbackData *cbdata; gchar *password; ssize_t written; cbdata = g_object_get_data (G_OBJECT(ctx), CALLBACK_DATA); if (!cbdata || !cbdata->pw_func) return FALSE; password = cbdata->pw_func (user_id, prompt_ctx, reprompt, cbdata->user_data); if (!password) { mu_util_g_set_error (err, MU_ERROR_CRYPTO, "failed to get password"); return FALSE; } written = g_mime_stream_write_string (response, password); if (written != -1) written = g_mime_stream_write_string (response, "\n"); if (written == -1) mu_util_g_set_error (err, MU_ERROR_CRYPTO, "writing password to mime stream failed"); if (g_mime_stream_flush (response) != 0) g_printerr ("error flushing stream\n"); memset (password, 0, strlen(password)); g_free (password); return written != -1 ? TRUE : FALSE; }
void cMetainfoMenu::Display(void) { cOsdMenu::Display(); CallbackData data; #ifdef HAVE_LIBEXTRACTOR # if EXTRACTOR_VERSION >= 0x00060000 EXTRACTOR_PluginList * plugins; plugins = EXTRACTOR_plugin_add_defaults(EXTRACTOR_OPTION_DEFAULT_POLICY); EXTRACTOR_extract(plugins, m_Filename, NULL, 0, (EXTRACTOR_MetaDataProcessor)&extractor_callback_metainfo, &data); EXTRACTOR_plugin_remove_all(plugins); /* unload plugins */ # else // EXTRACTOR_VERSION >= 0x00060000 EXTRACTOR_ExtractorList * plugins; EXTRACTOR_KeywordList * md_list; plugins = EXTRACTOR_loadDefaultLibraries(); md_list = EXTRACTOR_getKeywords(plugins, m_Filename); md_list = EXTRACTOR_removeEmptyKeywords (md_list); md_list = EXTRACTOR_removeDuplicateKeywords(md_list, 0); md_list = EXTRACTOR_removeKeywordsOfType(md_list, EXTRACTOR_THUMBNAILS); while(md_list) { const char *key = EXTRACTOR_getKeywordTypeAsString(md_list->keywordType); if (key) data.Append(key, md_list->keyword); md_list = md_list->next; } EXTRACTOR_freeKeywords(md_list); EXTRACTOR_removeAll(plugins); /* unload plugins */ # endif // EXTRACTOR_VERSION >= 0x00060000 #else // HAVE_LIBEXTRACTOR cString cmd; if(xc.IsPlaylistFile(m_Filename)) cmd = cString::sprintf("file -b '%s'; cat '%s'", *m_Filename, *m_Filename); else if(xc.IsAudioFile(m_Filename)) cmd = cString::sprintf("mp3info -x '%s' ; file -b '%s'", *m_Filename, *m_Filename); else if(xc.IsVideoFile(m_Filename)) cmd = cString::sprintf("file -b '%s'; midentify '%s'", *m_Filename, *m_Filename); else if(xc.IsImageFile(m_Filename)) cmd = cString::sprintf("file -b '%s'; identify '%s'", *m_Filename, *m_Filename); else cmd = cString::sprintf("file -b '%s'", *m_Filename); cPipe p; if(p.Open(*cmd, "r")) { data.text_len = fread(data.text, 1, data.text_size - 1, p); if (data.text_len > 0) { data.text[data.text_len] = 0; strreplace(data.text, ',', '\n'); } } #endif // HAVE_LIBEXTRACTOR DisplayMenu()->SetText(data.text, false); data.text = NULL; cStatus::MsgOsdTextItem(cString::sprintf("%s\n%s", tr("Metainfo"), *m_Filename)); }
void CompartmentCallback(JSRuntime *rt, void *vdata, JSCompartment *compartment) { CallbackData *data = (CallbackData *) vdata; data->n += data->mallocSizeOf(compartment); }