自学教程：C++ G_VFS_JOB函数代码示例

static voiddo_query_info_on_read (GVfsBackend *backend,		       GVfsJobQueryInfoRead *job,		       GVfsBackendHandle handle,		       GFileInfo *info,		       GFileAttributeMatcher *attribute_matcher){  int fd, res;  struct stat statbuf;      fd = GPOINTER_TO_INT (handle);  res = fstat (fd, &statbuf);  if (res == -1)    {      int errsv = errno;      g_vfs_job_failed (G_VFS_JOB (job), G_IO_ERROR,			g_io_error_from_errno (errsv),			"Error querying info in file: %s",			g_strerror (errsv));    }  else    {      g_file_info_set_size (info, statbuf.st_size);      g_file_info_set_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_DEVICE,					statbuf.st_dev);      g_file_info_set_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_MODIFIED, statbuf.st_mtime);      g_file_info_set_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_ACCESS, statbuf.st_atime);      g_file_info_set_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_CHANGED, statbuf.st_ctime);      g_vfs_job_succeeded (G_VFS_JOB (job));    }}

static gboolean read_idle_cb (gpointer data){  GVfsJobRead *job = data;  int fd;  ssize_t res;  fd = GPOINTER_TO_INT (job->handle);  res = read (fd, job->buffer, job->bytes_requested);  if (res == -1)    {      int errsv = errno;      g_vfs_job_failed (G_VFS_JOB (job), G_IO_ERROR,			g_io_error_from_errno (errsv),			"Error reading from file: %s",			g_strerror (errsv));    }  else    {      g_vfs_job_read_set_size (job, res);      g_vfs_job_succeeded (G_VFS_JOB (job));    }    return FALSE;}

static voiddo_seek_on_read (GVfsBackend *backend,		 GVfsJobSeekRead *job,		 GVfsBackendHandle handle,		 goffset    offset,		 GSeekType  type){  int whence;  int fd;  off_t final_offset;  g_print ("seek_on_read (%d, %u)/n", (int)offset, type);  if ((whence = gvfs_seek_type_to_lseek (type)) == -1)    whence = SEEK_SET;    fd = GPOINTER_TO_INT (handle);  final_offset = lseek (fd, offset, whence);    if (final_offset == (off_t)-1)    {      int errsv = errno;      g_vfs_job_failed (G_VFS_JOB (job), G_IO_ERROR,			g_io_error_from_errno (errsv),			"Error seeking in file: %s",			g_strerror (errsv));    }  else    {      g_vfs_job_seek_read_set_offset (job, offset);      g_vfs_job_succeeded (G_VFS_JOB (job));    }}

static gbooleantry_query_info (GVfsBackend *backend,                GVfsJobQueryInfo *job,                const char *filename,                GFileQueryInfoFlags flags,                GFileInfo *info,                GFileAttributeMatcher *matcher){  if (is_root (filename))  {    GIcon *icon;        g_file_info_set_file_type (info, G_FILE_TYPE_DIRECTORY);    g_file_info_set_name (info, "/");    g_file_info_set_display_name (info, g_vfs_backend_get_display_name (backend));    g_file_info_set_content_type (info, "inode/directory");    icon = g_vfs_backend_get_icon (backend);    if (icon != NULL)      g_file_info_set_icon (info, icon);    icon = g_vfs_backend_get_symbolic_icon (backend);    if (icon != NULL)      g_file_info_set_symbolic_icon (info, icon);    g_vfs_job_succeeded (G_VFS_JOB (job));  }  else    update_cache (G_VFS_BACKEND_AFP_BROWSE (backend), G_VFS_JOB (job)->cancellable,                  query_info_cb, job);    return TRUE;}

static voidquery_info_cb (GObject      *source_object,               GAsyncResult *res,               gpointer      user_data){  GVfsBackendAfpBrowse *afp_backend = G_VFS_BACKEND_AFP_BROWSE (source_object);  GVfsJobQueryInfo *job = G_VFS_JOB_QUERY_INFO (user_data);  GError *err = NULL;  GVfsAfpVolumeData *vol_data;  if (!update_cache_finish (afp_backend, res, &err))  {    g_vfs_job_failed_from_error (G_VFS_JOB (job), err);    g_error_free (err);    return;  }  vol_data = find_volume (afp_backend, job->filename);  if (!vol_data)  {    g_vfs_job_failed_literal (G_VFS_JOB (job),  G_IO_ERROR, G_IO_ERROR_NOT_FOUND,                              _("File doesn't exist"));    return;  }  fill_info (job->file_info, vol_data, afp_backend);  g_vfs_job_succeeded (G_VFS_JOB (job));}

static voidenumerate_cache_updated_cb (GObject      *source_object,                            GAsyncResult *res,                            gpointer      user_data){  GVfsBackendAfpBrowse *afp_backend = G_VFS_BACKEND_AFP_BROWSE (source_object);  GVfsJobEnumerate *job = G_VFS_JOB_ENUMERATE (user_data);  GError *err = NULL;  guint i;  if (!update_cache_finish (afp_backend, res, &err))  {    g_vfs_job_failed_from_error (G_VFS_JOB (job), err);    g_error_free (err);    return;  }  g_vfs_job_succeeded (G_VFS_JOB (job));    for (i = 0; i < afp_backend->volumes->len; i++)  {    GVfsAfpVolumeData *vol_data = g_ptr_array_index (afp_backend->volumes, i);        GFileInfo *info;    info = g_file_info_new ();    fill_info (info, vol_data, afp_backend);    g_vfs_job_enumerate_add_info (job, info);        g_object_unref (info);  }  g_vfs_job_enumerate_done (job);}

/* *** read_close () *** */static voidclose_read_ready (GObject      *source_object,                  GAsyncResult *result,                  gpointer      user_data){  GInputStream *stream;  GVfsJob      *job;  GError       *error;  gboolean      res;  job = G_VFS_JOB (user_data);  stream = G_INPUT_STREAM (source_object);  res = g_input_stream_close_finish (stream,                                     result,                                     &error);  if (res == FALSE)    {      g_vfs_job_failed_literal (G_VFS_JOB (job),                                error->domain,                                error->code,                                error->message);      g_error_free (error);    }  else    g_vfs_job_succeeded (job);  g_object_unref (stream);}

static gbooleantry_seek_on_read (GVfsBackend *backend,                  GVfsJobSeekRead *job,                  GVfsBackendHandle handle,                  goffset    offset,                  GSeekType  type){  GInputStream    *stream;  GError          *error = NULL;  stream = G_INPUT_STREAM (handle);  if (!g_seekable_seek (G_SEEKABLE (stream), offset, type,                        G_VFS_JOB (job)->cancellable, &error))    {      g_vfs_job_failed_literal (G_VFS_JOB (job),                                error->domain,                                error->code,                                error->message);      g_error_free (error);      return FALSE;    }  else    {      g_vfs_job_seek_read_set_offset (job, g_seekable_tell (G_SEEKABLE (stream)));      g_vfs_job_succeeded (G_VFS_JOB (job));    }  return TRUE;}

/* *** read () *** */static voidread_ready (GObject      *source_object,            GAsyncResult *result,            gpointer      user_data){  GInputStream *stream;  GVfsJob      *job;  GError       *error;  gssize        nread;  stream = G_INPUT_STREAM (source_object);   error  = NULL;  job    = G_VFS_JOB (user_data);  nread = g_input_stream_read_finish (stream, result, &error);  if (nread < 0)   {     g_vfs_job_failed_literal (G_VFS_JOB (job),                               error->domain,                               error->code,                               error->message);     g_error_free (error);     return;   }  g_vfs_job_read_set_size (G_VFS_JOB_READ (job), nread);  g_vfs_job_succeeded (job);}

static gbooleantrash_backend_delete (GVfsBackend   *vfs_backend,                      GVfsJobDelete *job,                      const char    *filename){  GVfsBackendTrash *backend = G_VFS_BACKEND_TRASH (vfs_backend);  GError *error = NULL;  g_debug ("before job: %d/n", G_OBJECT(job)->ref_count);  if (filename[1] == '/0')    g_set_error_literal (&error, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED,                         _("The trash folder may not be deleted"));  else    {      gboolean is_toplevel;      TrashItem *item;      GFile *real;      if (!backend->file_monitor && !backend->dir_monitor)        trash_watcher_rescan (backend->watcher);      real = trash_backend_get_file (backend, filename,                                     &item, &is_toplevel, &error);      if (real)        {          /* not interested in the 'real', but the item */          g_object_unref (real);          if (!is_toplevel)            g_set_error_literal (&error, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED,                                 _("Items in the trash may not be modified"));          else            {              if (trash_item_delete (item, &error))                {                  trash_backend_schedule_thaw (backend);                  g_vfs_job_succeeded (G_VFS_JOB (job));                  trash_item_unref (item);                  return TRUE;                }            }          trash_item_unref (item);        }    }  g_vfs_job_failed_from_error (G_VFS_JOB (job), error);  g_error_free (error);    return TRUE;}

static voidtrash_backend_enumerate_non_root (GVfsBackendTrash      *backend,                                  GVfsJobEnumerate      *job,                                  const gchar           *filename,                                  GFileAttributeMatcher *attribute_matcher,                                  GFileQueryInfoFlags    flags){  GError *error = NULL;  GFile *real;  real = trash_backend_get_file (backend, filename, NULL, NULL, &error);  if (real)    {      GFileEnumerator *enumerator;      enumerator = g_file_enumerate_children (real, job->attributes,                                              job->flags,                                               G_VFS_JOB (job)->cancellable, &error);      g_object_unref (real);      if (enumerator)        {          GFileInfo *info;          g_vfs_job_succeeded (G_VFS_JOB (job));          while ((info = g_file_enumerator_next_file (enumerator,                                                      G_VFS_JOB (job)->cancellable,                                                      &error)))            {              trash_backend_add_info (NULL, info, FALSE);              g_vfs_job_enumerate_add_info (job, info);              g_object_unref (info);            }          /* error from next_file?  ignore. */          if (error)            g_error_free (error);          g_vfs_job_enumerate_done (job);          g_object_unref (enumerator);          return;        }    }  g_vfs_job_failed_from_error (G_VFS_JOB (job), error);  g_error_free (error);}

static gbooleantry_mount (GVfsBackend  *backend,           GVfsJobMount *job,           GMountSpec   *mount_spec,           GMountSource *mount_source,           gboolean      is_automount){  GVfsBackendHttp *op_backend;  const char      *uri_str;  char            *path;  SoupURI         *uri;  GMountSpec      *real_mount_spec;  op_backend = G_VFS_BACKEND_HTTP (backend);  uri = NULL;  uri_str = g_mount_spec_get (mount_spec, "uri");  if (uri_str)    uri = soup_uri_new (uri_str);  g_debug ("+ try_mount: %s/n", uri_str ? uri_str : "(null)");  if (uri == NULL)    {      g_vfs_job_failed (G_VFS_JOB (job),                        G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,                        _("Invalid mount spec"));      return TRUE;    }  real_mount_spec = g_mount_spec_new ("http");  g_mount_spec_set (real_mount_spec, "uri", uri_str);  if (uri->path != NULL)    {      path = g_uri_unescape_string (uri->path, "/");      g_free (real_mount_spec->mount_prefix);      real_mount_spec->mount_prefix = g_mount_spec_canonicalize_path (path);      g_free (path);    }  g_vfs_backend_set_mount_spec (backend, real_mount_spec);  op_backend->mount_base = uri;  g_vfs_job_succeeded (G_VFS_JOB (job));  return TRUE;}

static gbooleantry_mount (GVfsBackend *backend,           GVfsJobMount *job,           GMountSpec *mount_spec,           GMountSource *mount_source,           gboolean is_automount){  GVfsBackendAfpBrowse *afp_backend = G_VFS_BACKEND_AFP_BROWSE (backend);  const char *host, *portstr, *user;  guint16 port = 548;  host = g_mount_spec_get (mount_spec, "host");  if (host == NULL)  {    g_vfs_job_failed (G_VFS_JOB (job),                      G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,                      _("No hostname specified"));    return TRUE;  }  portstr = g_mount_spec_get (mount_spec, "port");  if (portstr != NULL)  {    port = atoi (portstr);  }  afp_backend->addr = G_NETWORK_ADDRESS (g_network_address_new (host, port));  user = g_mount_spec_get (mount_spec, "user");  afp_backend->user = g_strdup (user);  return FALSE;}

static voiddo_unmount (GVfsBackend *backend,            GVfsJobUnmount *job,            GMountUnmountFlags flags,            GMountSource *mount_source){  GVfsBackendAfpBrowse *afp_backend = G_VFS_BACKEND_AFP_BROWSE (backend);  if (!(flags & G_MOUNT_UNMOUNT_FORCE))  {    g_vfs_afp_server_logout_sync (afp_backend->server, G_VFS_JOB (job)->cancellable,                                  NULL);  }  g_vfs_job_succeeded (G_VFS_JOB (job));}

static gbooleantry_enumerate (GVfsBackend *backend,	       GVfsJobEnumerate *job,	       const char *filename,	       GFileAttributeMatcher *matcher,	       GFileQueryInfoFlags flags){  GFileInfo *info1, *info2;  GList *l;  g_print ("try_enumerate (%s)/n", filename);  g_vfs_job_succeeded (G_VFS_JOB (job));  info1 = g_file_info_new ();  info2 = g_file_info_new ();  g_file_info_set_name (info1, "file1");  g_file_info_set_file_type (info1, G_FILE_TYPE_REGULAR);  g_file_info_set_name (info2, "file2");  g_file_info_set_file_type (info2, G_FILE_TYPE_REGULAR);    l = NULL;  l = g_list_append (l, info1);  l = g_list_append (l, info2);  g_vfs_job_enumerate_add_infos (job, l);  g_list_free (l);  g_object_unref (info1);  g_object_unref (info2);  g_vfs_job_enumerate_done (job);    return TRUE;}

static gbooleantrash_backend_query_fs_info (GVfsBackend           *vfs_backend,                             GVfsJobQueryFsInfo    *job,                             const char            *filename,                             GFileInfo             *info,                             GFileAttributeMatcher *matcher){  g_file_info_set_attribute_string (info,                                    G_FILE_ATTRIBUTE_FILESYSTEM_TYPE,                                    "trash");  g_file_info_set_attribute_boolean (info,                                     G_FILE_ATTRIBUTE_FILESYSTEM_REMOTE,                                     FALSE);  g_file_info_set_attribute_boolean (info,                                     G_FILE_ATTRIBUTE_FILESYSTEM_READONLY,                                     FALSE);  g_file_info_set_attribute_uint32 (info,                                    G_FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW,                                    G_FILESYSTEM_PREVIEW_TYPE_IF_LOCAL);  g_vfs_job_succeeded (G_VFS_JOB (job));  return TRUE;}

static gbooleantry_query_info (GVfsBackend           *backend,                GVfsJobQueryInfo      *job,                const char            *filename,                GFileQueryInfoFlags    flags,                GFileInfo             *info,                GFileAttributeMatcher *attribute_matcher){  SoupMessage *msg;  SoupURI     *uri;  if (g_file_attribute_matcher_matches_only (attribute_matcher,                                             G_FILE_ATTRIBUTE_THUMBNAIL_PATH))    {      g_vfs_job_succeeded (G_VFS_JOB (job));      return TRUE;    }  uri = http_backend_get_mount_base (backend);  msg = soup_message_new_from_uri (SOUP_METHOD_HEAD, uri);  http_backend_queue_message (backend, msg, query_info_ready, job);  return TRUE;}

/* *** open_read () *** */static voidopen_for_read_ready (GObject      *source_object,                     GAsyncResult *result,                     gpointer      user_data){  GInputStream *stream;  GVfsJob      *job;  SoupMessage  *msg;  gboolean      res;  gboolean      can_seek;  GError       *error;  stream = G_INPUT_STREAM (source_object);  error  = NULL;  job    = G_VFS_JOB (user_data);  res = g_vfs_http_input_stream_send_finish (stream,					     result,					     &error);  if (res == FALSE)    {      g_vfs_job_failed_literal (G_VFS_JOB (job),                                error->domain,                                error->code,                                error->message);      g_error_free (error);      g_object_unref (stream);      return;    }  msg = g_vfs_http_input_stream_get_message (stream);  if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code))    {      http_job_failed (G_VFS_JOB (job), msg);      g_object_unref (msg);      g_object_unref (stream);      return;    }  g_object_unref (msg);  can_seek = G_IS_SEEKABLE (stream) && g_seekable_can_seek (G_SEEKABLE (stream));  g_vfs_job_open_for_read_set_can_seek (G_VFS_JOB_OPEN_FOR_READ (job), can_seek);  g_vfs_job_open_for_read_set_handle (G_VFS_JOB_OPEN_FOR_READ (job), stream);  g_vfs_job_succeeded (job);}

/* ======================= method implementations ======================= */static gbooleantrash_backend_open_for_read (GVfsBackend        *vfs_backend,                             GVfsJobOpenForRead *job,                             const char         *filename){  GVfsBackendTrash *backend = G_VFS_BACKEND_TRASH (vfs_backend);  GError *error = NULL;  if (filename[1] == '/0')    g_set_error_literal (&error, G_IO_ERROR, G_IO_ERROR_IS_DIRECTORY,                         _("Can't open directory"));  else    {      GFile *real;      if (!backend->file_monitor && !backend->dir_monitor)        trash_watcher_rescan (backend->watcher);      real = trash_backend_get_file (backend, filename, NULL, NULL, &error);      if (real)        {          GFileInputStream *stream;          stream = g_file_read (real, G_VFS_JOB (job)->cancellable, &error);          g_object_unref (real);                if (stream)            {              g_vfs_job_open_for_read_set_handle (job, stream);              g_vfs_job_open_for_read_set_can_seek (job, TRUE);              g_vfs_job_succeeded (G_VFS_JOB (job));              return TRUE;            }        }    }  g_vfs_job_failed_from_error (G_VFS_JOB (job), error);  g_error_free (error);  return TRUE;}

static gbooleantry_mount (GVfsBackend *backend,	   GVfsJobMount *job,	   GMountSpec *mount_spec,	   GMountSource *mount_source,	   gboolean is_automount){  g_vfs_job_succeeded (G_VFS_JOB (job));  return TRUE;}

static gbooleanrecent_backend_delete (GVfsBackend   *vfs_backend,                       GVfsJobDelete *job,                       const char    *filename){  GVfsBackendRecent *backend = G_VFS_BACKEND_RECENT (vfs_backend);  GError *error = NULL;  g_debug ("before job: %d/n", G_OBJECT(job)->ref_count);  if (filename[1] == '/0')    {      g_set_error_literal (&error, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED,                           _("The recent folder may not be deleted"));    }  else    {      RecentItem *item;      item = g_hash_table_lookup (backend->items, filename + 1);      if (item)        {          gboolean res;          res = gtk_recent_manager_remove_item (backend->recent_manager,                                                item->uri,                                                &error);          if (res)            {              g_vfs_job_succeeded (G_VFS_JOB (job));              return TRUE;            }        }      else        g_set_error_literal (&error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND,                             _("No such file or directory"));    }  g_vfs_job_failed_from_error (G_VFS_JOB (job), error);  g_error_free (error);  return TRUE;}

static gbooleantry_open_for_read (GVfsBackend        *backend,                   GVfsJobOpenForRead *job,                   const char         *filename){  SoupURI *uri;  uri = http_backend_get_mount_base (backend);  http_backend_open_for_read (backend, G_VFS_JOB (job), uri);  return TRUE;}

static gbooleantry_query_fs_info (GVfsBackend *backend,                   GVfsJobQueryFsInfo *job,                   const char *filename,                   GFileInfo *info,                   GFileAttributeMatcher *matcher){  g_file_info_set_attribute_string (info, G_FILE_ATTRIBUTE_FILESYSTEM_TYPE, "http");  g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_FILESYSTEM_REMOTE, TRUE);  g_vfs_job_succeeded (G_VFS_JOB (job));  return TRUE;}

static gbooleantry_mount_mountable (GVfsBackend *backend,                     GVfsJobMountMountable *job,                     const char *filename,                     GMountSource *mount_source){  GVfsBackendAfpBrowse *afp_backend = G_VFS_BACKEND_AFP_BROWSE (backend);    if (is_root (filename))  {    g_vfs_job_failed (G_VFS_JOB (job),                      G_IO_ERROR, G_IO_ERROR_NOT_MOUNTABLE_FILE,                      _("The file is not a mountable"));    return TRUE;  }  update_cache (afp_backend, G_VFS_JOB (job)->cancellable, mount_mountable_cb, job);  return TRUE;                                      }

static gbooleantry_enumerate (GVfsBackend *backend,               GVfsJobEnumerate *job,               const char *filename,               GFileAttributeMatcher *attribute_matcher,               GFileQueryInfoFlags flags){  GVfsBackendAfpBrowse *afp_backend = G_VFS_BACKEND_AFP_BROWSE (backend);  if (!is_root(filename))  {    g_vfs_job_failed (G_VFS_JOB (job),                      G_IO_ERROR, G_IO_ERROR_NOT_FOUND,                      _("File doesn't exist"));    return TRUE;  }  update_cache (afp_backend, G_VFS_JOB (job)->cancellable,                enumerate_cache_updated_cb, job);    return TRUE;}

static gbooleantrash_backend_close_read (GVfsBackend       *backend,                          GVfsJobCloseRead  *job,                          GVfsBackendHandle  handle){  GError *error = NULL;  if (g_input_stream_close (handle, G_VFS_JOB (job)->cancellable, &error))    {      g_vfs_job_succeeded (G_VFS_JOB (job));      g_object_unref (handle);      return TRUE;    }  g_object_unref (handle);  g_vfs_job_failed_from_error (G_VFS_JOB (job), error);  g_error_free (error);  return TRUE;}

static gbooleantrash_backend_seek_on_read (GVfsBackend       *backend,                            GVfsJobSeekRead   *job,                            GVfsBackendHandle  handle,                            goffset            offset,                            GSeekType          type) {  GError *error = NULL;  if (g_seekable_seek (handle, offset, type, NULL, &error))    {      g_vfs_job_seek_read_set_offset (job, g_seekable_tell (handle));      g_vfs_job_succeeded (G_VFS_JOB (job));      return TRUE;    }  g_vfs_job_failed_from_error (G_VFS_JOB (job), error);  g_error_free (error);  return TRUE;}

static voidtrash_backend_enumerate_root (GVfsBackendTrash      *backend,                              GVfsJobEnumerate      *job,                              GFileAttributeMatcher *attribute_matcher,                              GFileQueryInfoFlags    flags){  GList *items, *node;  g_vfs_job_succeeded (G_VFS_JOB (job));  items = trash_root_get_items (backend->root);  for (node = items; node; node = node->next)    {      TrashItem *item = node->data;      GFileInfo *info;      info = g_file_query_info (trash_item_get_file (item),                                job->attributes, flags,                                G_VFS_JOB (job)->cancellable, NULL);      if (info)        {          g_file_info_set_attribute_mask (info, attribute_matcher);          g_file_info_set_name (info, trash_item_get_escaped_name (item));          trash_backend_add_info (item, info, TRUE);          g_vfs_job_enumerate_add_info (job, info);          g_object_unref (info);        }      trash_item_unref (item);    }  g_vfs_job_enumerate_done (job);  g_list_free (items);}

static gbooleanrecent_backend_enumerate (GVfsBackend           *vfs_backend,                          GVfsJobEnumerate      *job,                          const char            *filename,                          GFileAttributeMatcher *attribute_matcher,                          GFileQueryInfoFlags    flags){  GVfsBackendRecent *backend = G_VFS_BACKEND_RECENT (vfs_backend);  GHashTableIter iter;  gpointer key, value;  g_assert (filename[0] == '/');  g_vfs_job_succeeded (G_VFS_JOB (job));  g_hash_table_iter_init (&iter, backend->items);  while (g_hash_table_iter_next (&iter, &key, &value))    {      RecentItem *item = value;      GFileInfo *info;      info = g_file_query_info (item->file,                                job->attributes,                                flags,                                G_VFS_JOB (job)->cancellable,                                NULL);      if (info)        {          g_file_info_set_attribute_mask (info, attribute_matcher);          recent_backend_add_info (item, info);          g_vfs_job_enumerate_add_info (job, info);          g_object_unref (info);        }    }  g_vfs_job_enumerate_done (job);  return TRUE;}

static voidmount_mountable_cb (GObject      *source_object,                            GAsyncResult *res,                    gpointer      user_data){  GVfsBackendAfpBrowse *afp_backend = G_VFS_BACKEND_AFP_BROWSE (source_object);  GVfsJobMountMountable *job = G_VFS_JOB_MOUNT_MOUNTABLE (user_data);  GError *err;  GVfsAfpVolumeData *vol_data;  GMountSpec *mount_spec;  if (!update_cache_finish (afp_backend, res, &err))  {    g_vfs_job_failed_from_error (G_VFS_JOB (job), err);    g_error_free (err);    return;  }  vol_data = find_volume (afp_backend, job->filename);  if (!vol_data)  {    g_vfs_job_failed (G_VFS_JOB (job),  G_IO_ERROR, G_IO_ERROR_NOT_FOUND,                      _("File doesn't exist"));    return;  }  mount_spec = g_mount_spec_new ("afp-volume");  g_mount_spec_set (mount_spec, "host",                    g_network_address_get_hostname (G_NETWORK_ADDRESS (afp_backend->addr)));  g_mount_spec_set (mount_spec, "volume", vol_data->name);  g_mount_spec_set (mount_spec, "user", afp_backend->logged_in_user);  g_vfs_job_mount_mountable_set_target (job, mount_spec, "/", TRUE);  g_mount_spec_unref (mount_spec);  g_vfs_job_succeeded (G_VFS_JOB (job));}