New Ticket     Tickets     Wiki     Browse Source     Timeline     Roadmap     Ticket Reports     Search

Ticket #38657: patch-port-glib2-2.6.31-and-up.diff

File patch-port-glib2-2.6.31-and-up.diff, 23.3 KB (added by ionic@…, 15 months ago)

Changes required to remove deprecated glib2 functionality in gnome-vfs

  • daemon/daemon-connection.c

    old new  
    6767        gint32            id; 
    6868} FileHandle; 
    6969 
    70 static GStaticMutex cancellations_lock = G_STATIC_MUTEX_INIT; 
     70static GMutex cancellations_lock; 
    7171static GHashTable *cancellations; 
    7272 
    73 static GStaticMutex directory_handles_lock = G_STATIC_MUTEX_INIT; 
     73static GMutex directory_handles_lock; 
    7474static GHashTable *directory_handles; 
    7575static guint next_directory_id = 1; 
    7676 
    77 static GStaticMutex file_handles_lock = G_STATIC_MUTEX_INIT; 
     77static GMutex file_handles_lock; 
    7878static GHashTable *file_handles; 
    7979static guint next_file_id = 1; 
    8080 
     
    239239        } 
    240240        dbus_connection_unref (conn->conn); 
    241241 
    242         g_static_mutex_lock (&directory_handles_lock); 
     242        g_mutex_lock (&directory_handles_lock); 
    243243        if (directory_handles) { 
    244244                g_hash_table_foreach_remove (directory_handles, 
    245245                                             directory_handle_last_conn_is, 
    246246                                             conn); 
    247247        } 
    248         g_static_mutex_unlock (&directory_handles_lock); 
     248        g_mutex_unlock (&directory_handles_lock); 
    249249         
    250         g_static_mutex_lock (&file_handles_lock); 
     250        g_mutex_lock (&file_handles_lock); 
    251251        if (file_handles) { 
    252252                g_hash_table_foreach_remove (file_handles, 
    253253                                             file_handle_last_conn_is, 
    254254                                             conn); 
    255255        } 
    256         g_static_mutex_unlock (&file_handles_lock); 
     256        g_mutex_unlock (&file_handles_lock); 
    257257         
    258258        g_assert (!g_main_loop_is_running (conn->main_loop)); 
    259259 
     
    320320 
    321321        handle = cancellation_handle_new (id, conn->conn_id); 
    322322         
    323         g_static_mutex_lock (&cancellations_lock); 
     323        g_mutex_lock (&cancellations_lock); 
    324324        if (cancellations == NULL) { 
    325325                cancellations = g_hash_table_new_full (cancellation_handle_hash, cancellation_handle_equal, 
    326326                                                       NULL, (GDestroyNotify) cancellation_handle_free); 
    327327        } 
    328328         
    329329        g_hash_table_insert (cancellations, handle, handle); 
    330         g_static_mutex_unlock (&cancellations_lock); 
     330        g_mutex_unlock (&cancellations_lock); 
    331331 
    332332        return handle; 
    333333} 
     
    338338{ 
    339339        d(g_print ("Removing cancellation handle %d\n", handle->id)); 
    340340 
    341         g_static_mutex_lock (&cancellations_lock); 
     341        g_mutex_lock (&cancellations_lock); 
    342342        if (!g_hash_table_remove (cancellations, handle)) { 
    343343                g_warning ("Could't remove cancellation."); 
    344344        } 
    345         g_static_mutex_unlock (&cancellations_lock); 
     345        g_mutex_unlock (&cancellations_lock); 
    346346} 
    347347 
    348348/* Note: This is called from the main thread. */ 
     
    354354 
    355355        handle = NULL; 
    356356 
    357         g_static_mutex_lock (&cancellations_lock); 
     357        g_mutex_lock (&cancellations_lock); 
    358358         
    359359        lookup.conn_id = conn_id; 
    360360        lookup.id = cancellation_id; 
     
    368368                } 
    369369        } 
    370370         
    371         g_static_mutex_unlock (&cancellations_lock); 
     371        g_mutex_unlock (&cancellations_lock); 
    372372} 
    373373 
    374374 
     
    408408{ 
    409409        DirectoryHandle *handle; 
    410410 
    411         g_static_mutex_lock (&directory_handles_lock); 
     411        g_mutex_lock (&directory_handles_lock); 
    412412        handle = directory_handle_new (conn, vfs_handle, next_directory_id++); 
    413413 
    414414        if (directory_handles == NULL) { 
     
    418418         
    419419        g_hash_table_insert (directory_handles, 
    420420                             GINT_TO_POINTER (handle->id), handle); 
    421         g_static_mutex_unlock (&directory_handles_lock); 
     421        g_mutex_unlock (&directory_handles_lock); 
    422422 
    423423        return handle; 
    424424} 
     
    426426static void 
    427427remove_directory_handle (DirectoryHandle  *handle) 
    428428{ 
    429         g_static_mutex_lock (&directory_handles_lock); 
     429        g_mutex_lock (&directory_handles_lock); 
    430430        if (!g_hash_table_remove (directory_handles, 
    431431                                  GINT_TO_POINTER (handle->id))) { 
    432432                g_warning ("Couldn't remove directory handle %d\n", 
    433433                           handle->id); 
    434434        } 
    435         g_static_mutex_unlock (&directory_handles_lock); 
     435        g_mutex_unlock (&directory_handles_lock); 
    436436} 
    437437 
    438438static DirectoryHandle * 
     
    441441{ 
    442442        DirectoryHandle *handle; 
    443443         
    444         g_static_mutex_lock (&directory_handles_lock); 
     444        g_mutex_lock (&directory_handles_lock); 
    445445        handle = g_hash_table_lookup (directory_handles, 
    446446                                      GINT_TO_POINTER (id)); 
    447447        if (handle) { 
    448448                handle->last_connection = conn; 
    449449        } 
    450         g_static_mutex_unlock (&directory_handles_lock); 
     450        g_mutex_unlock (&directory_handles_lock); 
    451451        return handle; 
    452452} 
    453453 
     
    487487{ 
    488488        FileHandle *handle; 
    489489 
    490         g_static_mutex_lock (&file_handles_lock); 
     490        g_mutex_lock (&file_handles_lock); 
    491491        handle = file_handle_new (conn, vfs_handle, next_file_id++); 
    492492 
    493493        if (file_handles == NULL) { 
     
    497497         
    498498        g_hash_table_insert (file_handles, 
    499499                             GINT_TO_POINTER (handle->id), handle); 
    500         g_static_mutex_unlock (&file_handles_lock); 
     500        g_mutex_unlock (&file_handles_lock); 
    501501 
    502502        return handle; 
    503503} 
     
    505505static void 
    506506remove_file_handle (FileHandle       *handle) 
    507507{ 
    508         g_static_mutex_lock (&file_handles_lock); 
     508        g_mutex_lock (&file_handles_lock); 
    509509        if (!g_hash_table_remove (file_handles, 
    510510                                  GINT_TO_POINTER (handle->id))) { 
    511511                g_warning ("Couldn't remove file handle %d\n", handle->id); 
    512512        } 
    513         g_static_mutex_unlock (&file_handles_lock); 
     513        g_mutex_unlock (&file_handles_lock); 
    514514} 
    515515 
    516516static FileHandle * 
     
    519519{ 
    520520        FileHandle *handle; 
    521521 
    522         g_static_mutex_lock (&file_handles_lock); 
     522        g_mutex_lock (&file_handles_lock); 
    523523        handle = g_hash_table_lookup (file_handles, 
    524524                                      GINT_TO_POINTER (id)); 
    525525        if (handle) { 
    526526                handle->last_connection = conn; 
    527527        } 
    528         g_static_mutex_unlock (&file_handles_lock); 
     528        g_mutex_unlock (&file_handles_lock); 
    529529         
    530530        return handle; 
    531531} 
  • libgnomevfs/gnome-vfs-async-job-map.c

    old new  
    2727#include <glib.h> 
    2828 
    2929/* job map bits guarded by this lock */ 
    30 static GStaticRecMutex async_job_map_lock = G_STATIC_REC_MUTEX_INIT; 
     30static GRecMutex async_job_map_lock; 
    3131static guint async_job_map_next_id; 
    3232static int async_job_map_locked = 0; 
    3333static gboolean async_job_map_shutting_down; 
    3434static GHashTable *async_job_map; 
    3535 
    3636/* callback map bits guarded by this lock */ 
    37 static GStaticMutex async_job_callback_map_lock = G_STATIC_MUTEX_INIT; 
     37static GMutex async_job_callback_map_lock; 
    3838static GHashTable *async_job_callback_map; 
    3939static guint async_job_callback_map_next_id; 
    4040 
     
    161161void  
    162162_gnome_vfs_async_job_map_lock (void) 
    163163{ 
    164         g_static_rec_mutex_lock (&async_job_map_lock); 
     164        g_rec_mutex_lock (&async_job_map_lock); 
    165165        async_job_map_locked++; 
    166166} 
    167167 
     
    169169_gnome_vfs_async_job_map_unlock (void) 
    170170{ 
    171171        async_job_map_locked--; 
    172         g_static_rec_mutex_unlock (&async_job_map_lock); 
     172        g_rec_mutex_unlock (&async_job_map_lock); 
    173173} 
    174174 
    175175void  
     
    185185{ 
    186186        GnomeVFSNotifyResult *notify_result; 
    187187         
    188         g_static_mutex_lock (&async_job_callback_map_lock); 
     188        g_mutex_lock (&async_job_callback_map_lock); 
    189189         
    190190        if (async_job_callback_map == NULL) { 
    191191                g_assert (async_job_map_shutting_down); 
     
    199199        *valid = notify_result != NULL; 
    200200        *cancelled = notify_result != NULL && notify_result->cancelled; 
    201201 
    202         g_static_mutex_unlock (&async_job_callback_map_lock); 
     202        g_mutex_unlock (&async_job_callback_map_lock); 
    203203} 
    204204 
    205205gboolean  
     
    207207{ 
    208208        gboolean cancelled; 
    209209 
    210         g_static_mutex_lock (&async_job_callback_map_lock); 
     210        g_mutex_lock (&async_job_callback_map_lock); 
    211211 
    212212        g_assert (!async_job_map_shutting_down); 
    213213         
     
    232232                g_hash_table_insert (async_job_callback_map, GUINT_TO_POINTER (notify_result->callback_id), 
    233233                        notify_result); 
    234234        } 
    235         g_static_mutex_unlock (&async_job_callback_map_lock); 
     235        g_mutex_unlock (&async_job_callback_map_lock); 
    236236         
    237237        return !cancelled; 
    238238} 
     
    243243        g_assert (async_job_callback_map != NULL); 
    244244 
    245245        JOB_DEBUG (("removing callback %d ", callback_id)); 
    246         g_static_mutex_lock (&async_job_callback_map_lock); 
     246        g_mutex_lock (&async_job_callback_map_lock); 
    247247 
    248248        g_hash_table_remove (async_job_callback_map, GUINT_TO_POINTER (callback_id)); 
    249249 
    250         g_static_mutex_unlock (&async_job_callback_map_lock); 
     250        g_mutex_unlock (&async_job_callback_map_lock); 
    251251} 
    252252 
    253253static void 
     
    268268void 
    269269_gnome_vfs_async_job_cancel_job_and_callbacks (GnomeVFSAsyncHandle *job_handle, GnomeVFSJob *job) 
    270270{ 
    271         g_static_mutex_lock (&async_job_callback_map_lock); 
     271        g_mutex_lock (&async_job_callback_map_lock); 
    272272         
    273273        if (job != NULL) { 
    274274                job->cancelled = TRUE; 
     
    282282                                      callback_map_cancel_one, job_handle); 
    283283        } 
    284284 
    285         g_static_mutex_unlock (&async_job_callback_map_lock); 
     285        g_mutex_unlock (&async_job_callback_map_lock); 
    286286} 
    287287 
    288288void 
    289289async_job_callback_map_destroy (void) 
    290290{ 
    291         g_static_mutex_lock (&async_job_callback_map_lock); 
     291        g_mutex_lock (&async_job_callback_map_lock); 
    292292 
    293293        if (async_job_callback_map) { 
    294294                g_hash_table_destroy (async_job_callback_map); 
    295295                async_job_callback_map = NULL; 
    296296        } 
    297297 
    298         g_static_mutex_unlock (&async_job_callback_map_lock); 
     298        g_mutex_unlock (&async_job_callback_map_lock); 
    299299} 
  • libgnomevfs/gnome-vfs-daemon-method.c

    old new  
    8181static DBusHandlerResult connection_message_func      (DBusConnection  *conn, 
    8282                                                       DBusMessage     *message, 
    8383                                                       gpointer         data); 
     84static void 
     85destroy_private_connection (gpointer data) 
     86{ 
     87        LocalConnection *ret = data; 
     88 
     89        dbus_connection_close (ret->connection); 
     90        dbus_connection_unref (ret->connection); 
     91        g_free (ret); 
     92} 
    8493 
    85 static GStaticPrivate  local_connection_private = G_STATIC_PRIVATE_INIT; 
     94static GPrivate  local_connection_private = G_PRIVATE_INIT (destroy_private_connection); 
    8695 
    8796 
    8897static DBusObjectPathVTable connection_vtable = { 
     
    343352        gchar *sender; 
    344353} CancellationRequest; 
    345354 
    346 static void 
    347 destroy_private_connection (gpointer data) 
    348 { 
    349         LocalConnection *ret = data; 
    350  
    351         dbus_connection_close (ret->connection); 
    352         dbus_connection_unref (ret->connection); 
    353         g_free (ret); 
    354 } 
    355355 
    356356static void 
    357357private_connection_died (LocalConnection *connection) 
    358358{ 
    359         g_static_private_set (&local_connection_private, NULL, NULL); 
     359        g_private_set (&local_connection_private, NULL); 
    360360} 
    361361 
    362362static LocalConnection * 
     
    370370        dbus_int32_t conn_id; 
    371371        LocalConnection *ret; 
    372372 
    373         ret = g_static_private_get (&local_connection_private); 
     373        ret = g_private_get (&local_connection_private); 
    374374        if (ret != NULL) { 
    375375                return ret; 
    376376        } 
     
    438438        ret->conn_id = conn_id; 
    439439        ret->handle = 0; 
    440440 
    441         g_static_private_set (&local_connection_private, 
    442                               ret, destroy_private_connection); 
     441        g_private_set (&local_connection_private, 
     442                              ret); 
    443443         
    444444        return ret; 
    445445} 
  • libgnomevfs/gnome-vfs-dbus-utils.c

    old new  
    187187        return main_dbus; 
    188188} 
    189189 
    190 static GStaticPrivate  daemon_connection_private = G_STATIC_PRIVATE_INIT; 
     190static GPrivate  daemon_connection_private; 
    191191 
    192192DBusConnection * 
    193193_gnome_vfs_daemon_get_current_connection (void) 
    194194{ 
    195         return g_static_private_get (&daemon_connection_private); 
     195        return g_private_get (&daemon_connection_private); 
    196196} 
    197197 
    198198void 
    199199gnome_vfs_daemon_set_current_connection (DBusConnection *conn) 
    200200{ 
    201         g_static_private_set (&daemon_connection_private, conn, NULL); 
     201        g_private_set (&daemon_connection_private, conn); 
    202202} 
  • libgnomevfs/gnome-vfs-file-info.c

    old new  
    3131/* Mutex for making GnomeVFSFileInfo ref's/unref's atomic */ 
    3232/* Note that an atomic increment function (such as is present in NSPR) is preferable */ 
    3333/* FIXME: This mutex is probably not needed and might be causing performance issues */ 
    34 static GStaticMutex file_info_ref_lock = G_STATIC_MUTEX_INIT; 
     34static GMutex file_info_ref_lock; 
    3535 
    3636/* Register GnomeVFSFileInfo in the type system */ 
    3737GType  
     
    8383        g_return_if_fail (info != NULL); 
    8484        g_return_if_fail (info->refcount > 0); 
    8585 
    86         g_static_mutex_lock (&file_info_ref_lock); 
     86        g_mutex_lock (&file_info_ref_lock); 
    8787        info->refcount += 1; 
    88         g_static_mutex_unlock (&file_info_ref_lock); 
     88        g_mutex_unlock (&file_info_ref_lock); 
    8989         
    9090} 
    9191 
     
    101101        g_return_if_fail (info != NULL); 
    102102        g_return_if_fail (info->refcount > 0); 
    103103 
    104         g_static_mutex_lock (&file_info_ref_lock); 
     104        g_mutex_lock (&file_info_ref_lock); 
    105105        info->refcount -= 1; 
    106         g_static_mutex_unlock (&file_info_ref_lock); 
     106        g_mutex_unlock (&file_info_ref_lock); 
    107107 
    108108        if (info->refcount == 0) { 
    109109                gnome_vfs_file_info_clear (info); 
     
    133133        g_free (info->selinux_context); 
    134134 
    135135        /* Ensure the ref count is maintained correctly */ 
    136         g_static_mutex_lock (&file_info_ref_lock); 
     136        g_mutex_lock (&file_info_ref_lock); 
    137137 
    138138        old_refcount = info->refcount; 
    139139        memset (info, 0, sizeof (*info)); 
    140140        info->refcount = old_refcount; 
    141141 
    142         g_static_mutex_unlock (&file_info_ref_lock); 
     142        g_mutex_unlock (&file_info_ref_lock); 
    143143} 
    144144 
    145145 
     
    182182         * want serialize access differently (or perhaps you shouldn't 
    183183         * use copy) 
    184184         */ 
    185         g_static_mutex_lock (&file_info_ref_lock); 
     185        g_mutex_lock (&file_info_ref_lock); 
    186186 
    187187        old_refcount = dest->refcount; 
    188188 
     
    199199 
    200200        dest->refcount = old_refcount; 
    201201 
    202         g_static_mutex_unlock (&file_info_ref_lock); 
     202        g_mutex_unlock (&file_info_ref_lock); 
    203203 
    204204} 
    205205 
  • libgnomevfs/gnome-vfs-init.c

    old new  
    122122                return FALSE; 
    123123        } 
    124124 
    125         if (!g_thread_supported ()) 
    126                 g_thread_init (NULL); 
    127125 
    128126        G_LOCK (vfs_already_initialized); 
    129127 
     
    235233gboolean 
    236234gnome_vfs_is_primary_thread (void) 
    237235{ 
    238         if (g_thread_supported()) { 
    239                 return GPOINTER_TO_UINT(g_private_get (private_is_primary_thread)) == 1; 
    240         } else { 
    241                 return TRUE; 
    242         } 
     236        return GPOINTER_TO_UINT(g_private_get (private_is_primary_thread)) == 1; 
    243237} 
  • libgnomevfs/gnome-vfs-job.c

    old new  
    4343#include <string.h> 
    4444#include <unistd.h> 
    4545 
    46 static GStaticPrivate job_private = G_STATIC_PRIVATE_INIT; 
     46static GPrivate job_private; 
    4747 
    4848#if GNOME_VFS_JOB_DEBUG 
    4949 
     
    6464 * Since this id debug only, just use what the macro should be here. 
    6565 * even though it is not portable. 
    6666 */ 
    67 GStaticMutex debug_mutex = G_STATIC_MUTEX_INIT; 
     67GMutex debug_mutex; 
    6868#endif 
    6969 
    7070static int job_count = 0; 
     
    17341734set_current_job (GnomeVFSJob *job) 
    17351735{ 
    17361736        /* There shouldn't have been anything here. */ 
    1737         g_assert (g_static_private_get (&job_private) == NULL); 
     1737        g_assert (g_private_get (&job_private) == NULL); 
    17381738 
    1739         g_static_private_set (&job_private, job, NULL); 
     1739        g_private_set (&job_private, job); 
    17401740 
    17411741        _gnome_vfs_module_callback_use_stack_info (job->op->stack_info); 
    17421742        _gnome_vfs_module_callback_set_in_async_thread (TRUE); 
     
    17451745static void 
    17461746clear_current_job (void) 
    17471747{ 
    1748         g_static_private_set (&job_private, NULL, NULL); 
     1748        g_private_set (&job_private, NULL); 
    17491749 
    17501750        _gnome_vfs_module_callback_clear_stacks (); 
    17511751} 
     
    17571757         
    17581758        g_return_if_fail (context != NULL); 
    17591759 
    1760         job = g_static_private_get (&job_private); 
     1760        job = g_private_get (&job_private); 
    17611761 
    17621762        if (job != NULL) { 
    17631763                *context = job->op->context; 
     
    17771777        GnomeVFSJob *job; 
    17781778        GnomeVFSNotifyResult notify_result; 
    17791779 
    1780         job = g_static_private_get (&job_private); 
     1780        job = g_private_get (&job_private); 
    17811781 
    17821782        g_return_if_fail (job != NULL); 
    17831783 
  • libgnomevfs/gnome-vfs-method.c

    old new  
    6363 
    6464static GHashTable *module_hash = NULL; 
    6565G_LOCK_DEFINE_STATIC (gnome_vfs_method_init); 
    66 static GStaticRecMutex module_hash_lock = G_STATIC_REC_MUTEX_INIT; 
     66static GRecMutex module_hash_lock; 
    6767 
    6868static GList *module_path_list = NULL; 
    6969 
     
    343343        const char *args; 
    344344        gboolean run_in_daemon; 
    345345 
    346         g_static_rec_mutex_lock (&module_hash_lock); 
     346        g_rec_mutex_lock (&module_hash_lock); 
    347347 
    348348        module_element = g_hash_table_lookup (module_hash, name); 
    349349 
     
    408408        g_hash_table_insert (module_hash, module_element->name, module_element); 
    409409 
    410410 add_module_out: 
    411         g_static_rec_mutex_unlock (&module_hash_lock); 
     411        g_rec_mutex_unlock (&module_hash_lock); 
    412412 
    413413        return module_element; 
    414414} 
  • libgnomevfs/gnome-vfs-module-callback.c

    old new  
    5959 
    6060/* -- Global variables -- */ 
    6161 
    62 static GStaticMutex callback_table_lock = G_STATIC_MUTEX_INIT; 
     62static GMutex callback_table_lock; 
    6363static GHashTable *default_callbacks = NULL; 
    6464static GHashTable *default_async_callbacks = NULL; 
    6565static GHashTable *stack_tables_to_free = NULL; 
     
    6969static GPrivate *in_async_thread_key; 
    7070 
    7171static GCond *async_callback_cond; 
    72 static GStaticMutex async_callback_lock = G_STATIC_MUTEX_INIT; 
     72static GMutex async_callback_lock; 
    7373 
    7474/* -- Helper functions -- */ 
    7575 
     
    120120{ 
    121121        CallbackResponseData *response_data; 
    122122 
    123         g_static_mutex_lock (&async_callback_lock); 
     123        g_mutex_lock (&async_callback_lock); 
    124124        response_data = data; 
    125125        response_data->done = TRUE; 
    126126        g_cond_broadcast (async_callback_cond); 
    127127 
    128         g_static_mutex_unlock (&async_callback_lock); 
     128        g_mutex_unlock (&async_callback_lock); 
    129129} 
    130130 
    131131static void 
     
    146146         * new mutexes and condition variables all the time. 
    147147         */ 
    148148 
    149         g_static_mutex_lock (&async_callback_lock); 
     149        g_mutex_lock (&async_callback_lock); 
    150150        response_data.done = FALSE; 
    151151        _gnome_vfs_dispatch_module_callback (async_callback->callback, 
    152152                                            in, in_size, 
     
    156156                                            &response_data); 
    157157        while (!response_data.done) { 
    158158                g_cond_wait (async_callback_cond, 
    159                              g_static_mutex_get_mutex (&async_callback_lock)); 
     159                             &async_callback_lock); 
    160160        } 
    161161 
    162         g_static_mutex_unlock (&async_callback_lock); 
     162        g_mutex_unlock (&async_callback_lock); 
    163163} 
    164164 
    165165static void 
     
    410410 
    411411        stack_table = specific; 
    412412 
    413         g_static_mutex_lock (&callback_table_lock); 
     413        g_mutex_lock (&callback_table_lock); 
    414414        if (stack_tables_to_free != NULL) { 
    415415                g_hash_table_remove (stack_tables_to_free, stack_table); 
    416416        } else { 
    417417                stack_table = NULL; 
    418418        } 
    419         g_static_mutex_unlock (&callback_table_lock); 
     419        g_mutex_unlock (&callback_table_lock); 
    420420 
    421421        if (stack_table) { 
    422422                clear_stack_table (stack_table); 
     
    443443static void 
    444444free_stack_tables_to_free (void) 
    445445{ 
    446         g_static_mutex_lock (&callback_table_lock); 
     446        g_mutex_lock (&callback_table_lock); 
    447447        g_hash_table_foreach_remove (stack_tables_to_free, stack_table_free_hr_func , NULL); 
    448448        g_hash_table_destroy (stack_tables_to_free); 
    449449        stack_tables_to_free = NULL; 
    450         g_static_mutex_unlock (&callback_table_lock); 
     450        g_mutex_unlock (&callback_table_lock); 
    451451} 
    452452 
    453453void 
     
    461461 
    462462        async_callback_cond = g_cond_new (); 
    463463 
    464         g_atexit (free_stack_tables_to_free);    
     464        atexit (free_stack_tables_to_free);      
    465465} 
    466466 
    467467static void 
    468468free_default_callbacks (void) 
    469469{ 
    470         g_static_mutex_lock (&callback_table_lock); 
     470        g_mutex_lock (&callback_table_lock); 
    471471 
    472472        clear_callback_table (default_callbacks); 
    473473        g_hash_table_destroy (default_callbacks); 
     
    475475        clear_callback_table (default_async_callbacks); 
    476476        g_hash_table_destroy (default_async_callbacks); 
    477477 
    478         g_static_mutex_unlock (&callback_table_lock); 
     478        g_mutex_unlock (&callback_table_lock); 
    479479} 
    480480 
    481481/* This function should only be called with the mutex held. */ 
     
    486486                default_callbacks = g_hash_table_new (g_str_hash, g_str_equal); 
    487487                default_async_callbacks = g_hash_table_new (g_str_hash, g_str_equal); 
    488488 
    489                 g_atexit (free_default_callbacks); 
     489                atexit (free_default_callbacks); 
    490490        } 
    491491} 
    492492 
     
    496496{ 
    497497        /* Initialize per-thread data, if needed. */ 
    498498        if (g_private_get (callback_stacks_key) == NULL) { 
    499                 g_static_mutex_lock (&callback_table_lock); 
     499                g_mutex_lock (&callback_table_lock); 
    500500                g_private_set (callback_stacks_key, 
    501501                                     g_hash_table_new (g_str_hash, g_str_equal)); 
    502502                g_hash_table_insert (stack_tables_to_free, 
    503503                                     g_private_get (callback_stacks_key), 
    504504                                     GINT_TO_POINTER (1)); 
    505                 g_static_mutex_unlock (&callback_table_lock); 
     505                g_mutex_unlock (&callback_table_lock); 
    506506        } 
    507507 
    508508        if (g_private_get (async_callback_stacks_key) == NULL) { 
    509                 g_static_mutex_lock (&callback_table_lock); 
     509                g_mutex_lock (&callback_table_lock); 
    510510                g_private_set (async_callback_stacks_key, 
    511511                                     g_hash_table_new (g_str_hash, g_str_equal)); 
    512512                g_hash_table_insert (stack_tables_to_free, 
    513513                                     g_private_get (async_callback_stacks_key), 
    514514                                     GINT_TO_POINTER (1)); 
    515                 g_static_mutex_unlock (&callback_table_lock); 
     515                g_mutex_unlock (&callback_table_lock); 
    516516        } 
    517517} 
    518518 
     
    618618 
    619619        callback_info = callback_info_new (callback, callback_data, destroy_notify); 
    620620 
    621         g_static_mutex_lock (&callback_table_lock); 
     621        g_mutex_lock (&callback_table_lock); 
    622622 
    623623        initialize_global_if_needed (); 
    624624        insert_callback_into_table (default_callbacks, callback_name, callback_info); 
    625625 
    626         g_static_mutex_unlock (&callback_table_lock); 
     626        g_mutex_unlock (&callback_table_lock); 
    627627 
    628628        callback_info_unref (callback_info); 
    629629} 
     
    730730 
    731731        callback_info = async_callback_info_new (callback, callback_data, notify); 
    732732 
    733         g_static_mutex_lock (&callback_table_lock); 
     733        g_mutex_lock (&callback_table_lock); 
    734734 
    735735        initialize_global_if_needed (); 
    736736        insert_callback_into_table (default_async_callbacks, callback_name, callback_info);  
    737737 
    738         g_static_mutex_unlock (&callback_table_lock); 
     738        g_mutex_unlock (&callback_table_lock); 
    739739 
    740740        callback_info_unref (callback_info); 
    741741} 
     
    864864                        g_assert (callback != NULL); 
    865865                        callback_info_ref (callback); 
    866866                } else { 
    867                         g_static_mutex_lock (&callback_table_lock); 
     867                        g_mutex_lock (&callback_table_lock); 
    868868                        initialize_global_if_needed (); 
    869869                        callback = g_hash_table_lookup (default_async_callbacks, callback_name); 
    870870                        if (callback != NULL) { 
    871871                                callback_info_ref (callback); 
    872872                        } 
    873                         g_static_mutex_unlock (&callback_table_lock); 
     873                        g_mutex_unlock (&callback_table_lock); 
    874874                } 
    875875        } 
    876876 
     
    883883                        g_assert (callback != NULL); 
    884884                        callback_info_ref (callback); 
    885885                } else { 
    886                         g_static_mutex_lock (&callback_table_lock); 
     886                        g_mutex_lock (&callback_table_lock); 
    887887                        initialize_global_if_needed (); 
    888888                        callback = g_hash_table_lookup (default_callbacks, callback_name); 
    889889                        if (callback != NULL) { 
    890890                                callback_info_ref (callback); 
    891891                        } 
    892                         g_static_mutex_unlock (&callback_table_lock); 
     892                        g_mutex_unlock (&callback_table_lock); 
    893893                } 
    894894        } 
    895895 
     
    920920        stack_info->current_callbacks = g_hash_table_new (g_str_hash, g_str_equal); 
    921921        stack_info->current_async_callbacks = g_hash_table_new (g_str_hash, g_str_equal); 
    922922 
    923         g_static_mutex_lock (&callback_table_lock); 
     923        g_mutex_lock (&callback_table_lock); 
    924924        initialize_global_if_needed (); 
    925         g_static_mutex_unlock (&callback_table_lock); 
     925        g_mutex_unlock (&callback_table_lock); 
    926926 
    927927        initialize_per_thread_if_needed (); 
    928928        copy_callback_stack_tops (g_private_get (callback_stacks_key), 
  • libgnomevfs/gnome-vfs-resolve.c

    old new  
    139139restart_resolve (void) 
    140140{ 
    141141           static GTimeVal last_reload = { 0, 0 }; 
    142            static GStaticMutex mutex = G_STATIC_MUTEX_INIT; 
     142           static GMutex mutex; 
    143143           GTimeVal now; 
    144144           gboolean ret; 
    145145 
    146            g_static_mutex_lock (&mutex); 
     146           g_mutex_lock (&mutex); 
    147147           g_get_current_time (&now); 
    148148            
    149149           if ((now.tv_sec - last_reload.tv_sec) > RELOAD_TIMEVAL) { 
     
    155155                         ret = FALSE; 
    156156           } 
    157157         
    158            g_static_mutex_unlock (&mutex); 
     158           g_mutex_unlock (&mutex); 
    159159           return ret; 
    160160} 
    161161#else 
  • modules/sftp-method.c

    old new  
    14881488                        invoke_save_auth (uri, keyring, user_name, object, authtype, password); 
    14891489                } 
    14901490 
    1491                 if (!g_thread_supported ()) g_thread_init (NULL); 
    1492  
    14931491                *connection = g_new0 (SftpConnection, 1); 
    14941492                (*connection)->ref_count = 1; 
    14951493                (*connection)->in_fd = in_fd;