videolan/vlc
1
Fork 0
mirror of https://code.videolan.org/videolan/vlc synced 2024-07-21 07:24:15 +02:00
Code Releases Activity

dbus: use vlc_array_init() instead of vlc_array_new()

Browse Source 
This fixes missing error tests by making them unnecessary.

This also fixes a race in remove_timeout().
This commit is contained in:
Rémi Denis-Courmont 2017-02-19 23:08:44 +02:00
parent 7ecd9271af
commit bb5744f6cb
2 changed files with 33 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
modules/control/dbus/dbus.c
View File

@ -227,9 +227,9 @@ static int Open( vlc_object_t *p_this )
p_intf->p_sys = p_sys; p_intf->p_sys = p_sys;
p_sys->p_conn = p_conn; p_sys->p_conn = p_conn;
p_sys->p_events = vlc_array_new(); vlc_array_init( &p_sys->events );
p_sys->p_timeouts = vlc_array_new(); vlc_array_init( &p_sys->timeouts );
p_sys->p_watches = vlc_array_new(); vlc_array_init( &p_sys->watches );
vlc_mutex_init( &p_sys->lock ); vlc_mutex_init( &p_sys->lock );
p_playlist = pl_Get( p_intf ); p_playlist = pl_Get( p_intf );
@ -271,10 +271,6 @@ error:
dbus_connection_close( p_sys->p_conn ); dbus_connection_close( p_sys->p_conn );
dbus_connection_unref( p_conn ); dbus_connection_unref( p_conn );
vlc_array_destroy( p_sys->p_events );
vlc_array_destroy( p_sys->p_timeouts );
vlc_array_destroy( p_sys->p_watches );
vlc_mutex_destroy( &p_sys->lock ); vlc_mutex_destroy( &p_sys->lock );
vlc_close( p_sys->p_pipe_fds[1] ); vlc_close( p_sys->p_pipe_fds[1] );
@ -320,15 +316,15 @@ static void Close ( vlc_object_t *p_this )
dbus_connection_unref( p_sys->p_conn ); dbus_connection_unref( p_sys->p_conn );
// Free the events array // Free the events array
for( size_t i = 0; i < vlc_array_count( p_sys->p_events ); i++ ) for( size_t i = 0; i < vlc_array_count( &p_sys->events ); i++ )
{ {
callback_info_t* info = vlc_array_item_at_index( p_sys->p_events, i ); callback_info_t* info = vlc_array_item_at_index( &p_sys->events, i );
free( info ); free( info );
} }
vlc_mutex_destroy( &p_sys->lock ); vlc_mutex_destroy( &p_sys->lock );
vlc_array_destroy( p_sys->p_events ); vlc_array_clear( &p_sys->events );
vlc_array_destroy( p_sys->p_timeouts ); vlc_array_clear( &p_sys->timeouts );
vlc_array_destroy( p_sys->p_watches ); vlc_array_clear( &p_sys->watches );
vlc_close( p_sys->p_pipe_fds[1] ); vlc_close( p_sys->p_pipe_fds[1] );
vlc_close( p_sys->p_pipe_fds[0] ); vlc_close( p_sys->p_pipe_fds[0] );
free( p_sys ); free( p_sys );
@ -346,7 +342,7 @@ static dbus_bool_t add_timeout(DBusTimeout *to, void *data)
dbus_timeout_set_data(to, expiry, free); dbus_timeout_set_data(to, expiry, free);
vlc_mutex_lock(&sys->lock); vlc_mutex_lock(&sys->lock);
vlc_array_append(sys->p_timeouts, to); vlc_array_append(&sys->timeouts, to);
vlc_mutex_unlock(&sys->lock); vlc_mutex_unlock(&sys->lock);
return TRUE; return TRUE;
@ -356,10 +352,11 @@ static void remove_timeout(DBusTimeout *to, void *data)
{ {
intf_thread_t *intf = data; intf_thread_t *intf = data;
intf_sys_t *sys = intf->p_sys; intf_sys_t *sys = intf->p_sys;
unsigned idx = vlc_array_index_of_item(sys->p_timeouts, to); size_t idx;
vlc_mutex_lock(&sys->lock); vlc_mutex_lock(&sys->lock);
vlc_array_remove(sys->p_timeouts, idx); idx = vlc_array_index_of_item(&sys->timeouts, to);
vlc_array_remove(&sys->timeouts, idx);
vlc_mutex_unlock(&sys->lock); vlc_mutex_unlock(&sys->lock);
} }
@ -387,11 +384,11 @@ static int next_timeout(intf_thread_t *intf)
{ {
intf_sys_t *sys = intf->p_sys; intf_sys_t *sys = intf->p_sys;
mtime_t next_timeout = LAST_MDATE; mtime_t next_timeout = LAST_MDATE;
unsigned count = vlc_array_count(sys->p_timeouts); unsigned count = vlc_array_count(&sys->timeouts);
for (unsigned i = 0; i < count; i++) for (unsigned i = 0; i < count; i++)
{ {
DBusTimeout *to = vlc_array_item_at_index(sys->p_timeouts, i); DBusTimeout *to = vlc_array_item_at_index(&sys->timeouts, i);
if (!dbus_timeout_get_enabled(to)) if (!dbus_timeout_get_enabled(to))
continue; continue;
@ -422,9 +419,9 @@ static void process_timeouts(intf_thread_t *intf)
{ {
intf_sys_t *sys = intf->p_sys; intf_sys_t *sys = intf->p_sys;
for (size_t i = 0; i < vlc_array_count(sys->p_timeouts); i++) for (size_t i = 0; i < vlc_array_count(&sys->timeouts); i++)
{ {
DBusTimeout *to = vlc_array_item_at_index(sys->p_timeouts, i); DBusTimeout *to = vlc_array_item_at_index(&sys->timeouts, i);
if (!dbus_timeout_get_enabled(to)) if (!dbus_timeout_get_enabled(to))
continue; continue;
@ -450,7 +447,7 @@ static dbus_bool_t add_watch( DBusWatch *p_watch, void *p_data )
intf_sys_t *p_sys = (intf_sys_t*) p_intf->p_sys; intf_sys_t *p_sys = (intf_sys_t*) p_intf->p_sys;
vlc_mutex_lock( &p_sys->lock ); vlc_mutex_lock( &p_sys->lock );
vlc_array_append( p_sys->p_watches, p_watch ); vlc_array_append( &p_sys->watches, p_watch );
vlc_mutex_unlock( &p_sys->lock ); vlc_mutex_unlock( &p_sys->lock );
return TRUE; return TRUE;
@ -460,12 +457,11 @@ static void remove_watch( DBusWatch *p_watch, void *p_data )
{ {
intf_thread_t *p_intf = (intf_thread_t*) p_data; intf_thread_t *p_intf = (intf_thread_t*) p_data;
intf_sys_t *p_sys = (intf_sys_t*) p_intf->p_sys; intf_sys_t *p_sys = (intf_sys_t*) p_intf->p_sys;
size_t idx;
vlc_mutex_lock( &p_sys->lock ); vlc_mutex_lock( &p_sys->lock );
idx = vlc_array_index_of_item( &p_sys->watches, p_watch );
vlc_array_remove( p_sys->p_watches, vlc_array_remove( &p_sys->watches, idx );
vlc_array_index_of_item( p_sys->p_watches, p_watch ) );
vlc_mutex_unlock( &p_sys->lock ); vlc_mutex_unlock( &p_sys->lock );
} }
@ -493,7 +489,7 @@ static void watch_toggled( DBusWatch *p_watch, void *p_data )
static int GetPollFds( intf_thread_t *p_intf, struct pollfd *p_fds ) static int GetPollFds( intf_thread_t *p_intf, struct pollfd *p_fds )
{ {
intf_sys_t *p_sys = p_intf->p_sys; intf_sys_t *p_sys = p_intf->p_sys;
size_t i_watches = vlc_array_count( p_sys->p_watches ); size_t i_watches = vlc_array_count( &p_sys->watches );
int i_fds = 1; int i_fds = 1;
p_fds[0].fd = p_sys->p_pipe_fds[PIPE_OUT]; p_fds[0].fd = p_sys->p_pipe_fds[PIPE_OUT];
@ -502,7 +498,7 @@ static int GetPollFds( intf_thread_t *p_intf, struct pollfd *p_fds )
for( size_t i = 0; i < i_watches; i++ ) for( size_t i = 0; i < i_watches; i++ )
{ {
DBusWatch *p_watch = NULL; DBusWatch *p_watch = NULL;
p_watch = vlc_array_item_at_index( p_sys->p_watches, i ); p_watch = vlc_array_item_at_index( &p_sys->watches, i );
if( !dbus_watch_get_enabled( p_watch ) ) if( !dbus_watch_get_enabled( p_watch ) )
continue; continue;
@ -776,7 +772,7 @@ static void *Run( void *data )
{ {
vlc_mutex_lock( &p_sys->lock ); vlc_mutex_lock( &p_sys->lock );
size_t i_watches = vlc_array_count( p_sys->p_watches ); size_t i_watches = vlc_array_count( &p_sys->watches );
struct pollfd fds[i_watches]; struct pollfd fds[i_watches];
memset(fds, 0, sizeof fds); memset(fds, 0, sizeof fds);
@ -817,22 +813,22 @@ static void *Run( void *data )
process_timeouts(p_intf); process_timeouts(p_intf);
/* Get the list of watches to process */ /* Get the list of watches to process */
i_watches = vlc_array_count( p_sys->p_watches ); i_watches = vlc_array_count( &p_sys->watches );
DBusWatch *p_watches[i_watches ? i_watches : 1]; DBusWatch *p_watches[i_watches ? i_watches : 1];
for( size_t i = 0; i < i_watches; i++ ) for( size_t i = 0; i < i_watches; i++ )
{ {
p_watches[i] = vlc_array_item_at_index( p_sys->p_watches, i ); p_watches[i] = vlc_array_item_at_index( &p_sys->watches, i );
} }
/* Get the list of events to process */ /* Get the list of events to process */
size_t i_events = vlc_array_count( p_intf->p_sys->p_events ); size_t i_events = vlc_array_count( &p_sys->events );
callback_info_t* p_info[i_events ? i_events : 1]; callback_info_t* p_info[i_events ? i_events : 1];
for( size_t i = 0; i < i_events; i++ ) for( size_t i = 0; i < i_events; i++ )
{ {
p_info[i] = vlc_array_item_at_index( p_intf->p_sys->p_events, i ); p_info[i] = vlc_array_item_at_index( &p_sys->events, i );
} }
vlc_array_clear( p_intf->p_sys->p_events ); vlc_array_clear( &p_sys->events );
/* now we can release the lock and process what's pending */ /* now we can release the lock and process what's pending */
vlc_mutex_unlock( &p_intf->p_sys->lock ); vlc_mutex_unlock( &p_intf->p_sys->lock );
@ -946,7 +942,7 @@ static int InputCallback( vlc_object_t *p_this, const char *psz_var,
p_info->signal = SIGNAL_STATE; p_info->signal = SIGNAL_STATE;
} }
if( p_info->signal ) if( p_info->signal )
vlc_array_append( p_intf->p_sys->p_events, p_info ); vlc_array_append( &p_sys->events, p_info );
else else
free( p_info ); free( p_info );
vlc_mutex_unlock( &p_intf->p_sys->lock ); vlc_mutex_unlock( &p_intf->p_sys->lock );
@ -1007,7 +1003,7 @@ static int AllCallback( vlc_object_t *p_this, const char *psz_var,
// Append the event // Append the event
*p_info = info; *p_info = info;
vlc_mutex_lock( &p_intf->p_sys->lock ); vlc_mutex_lock( &p_intf->p_sys->lock );
vlc_array_append( p_intf->p_sys->p_events, p_info ); vlc_array_append( &p_intf->p_sys->events, p_info );
vlc_mutex_unlock( &p_intf->p_sys->lock ); vlc_mutex_unlock( &p_intf->p_sys->lock );
wakeup_main_loop( p_intf ); wakeup_main_loop( p_intf );

6
modules/control/dbus/dbus_common.h
View File

@ -97,9 +97,9 @@ struct intf_sys_t
dbus_int32_t i_playing_state; dbus_int32_t i_playing_state;
bool b_can_play; bool b_can_play;
bool b_dead; bool b_dead;
vlc_array_t *p_events; vlc_array_t events;
vlc_array_t *p_timeouts; vlc_array_t timeouts;
vlc_array_t *p_watches; vlc_array_t watches;
int p_pipe_fds[2]; int p_pipe_fds[2];
vlc_mutex_t lock; vlc_mutex_t lock;
vlc_thread_t thread; vlc_thread_t thread;