directory-async: Count hidden files on deep size

We always skip hidden and backup files when counting the number of
files in a directory, if "show-hidden-files" is turned Off. This is
done so that the item count matches which items the user sees.

However, we have been skipping them also when computing the total size
of a folder contents. This is wrong because hiding content doesn't
make the folder actually smaller in size.

So, let's decouple deep size from deep count, such that, even when
skipping files in deep count, their size is always added to the total
content size.

Closes https://gitlab.gnome.org/GNOME/nautilus/-/issues/638

1 files changed, 35 insertions, 12 deletions

diff --git a/src/nautilus-directory-async.c b/src/nautilus-directory-async.c
index d5b93b5ac..e9fe732e3 100644
--- a/src/nautilus-directory-async.c
+++ b/src/nautilus-directory-async.c
@@ -114,7 +114,9 @@ struct DeepCountState
     GCancellable *cancellable;
     GFileEnumerator *enumerator;
     GFile *deep_count_location;
+    gboolean deep_size_only;
     GList *deep_count_subdirectories;
+    GList *deep_size_only_subdirectories;
     GArray *seen_deep_count_inodes;
     char *fs_id;
 };
@@ -2808,45 +2810,54 @@ deep_count_one (DeepCountState *state,
                 GFileInfo      *info)
 {
     NautilusFile *file;
-    GFile *subdir;
     gboolean is_seen_inode;
-    const char *fs_id;
-
-    if (should_skip_file (NULL, info))
-    {
-        return;
-    }
+    gboolean skip_count;
 
     is_seen_inode = seen_inode (state, info);
     if (!is_seen_inode)
     {
         mark_inode_as_seen (state, info);
     }
+    /* Count item only if not skipped (because it's not user-visible) */
+    skip_count = should_skip_file (NULL, info) || state->deep_size_only;
 
     file = state->directory->details->deep_count_file;
 
     if (g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY)
     {
+        const char *fs_id;
+
         /* Count the directory. */
-        file->details->deep_directory_count += 1;
+        file->details->deep_directory_count += skip_count ? 0 : 1;
 
         /* Record the fact that we have to descend into this directory. */
         fs_id = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_ID_FILESYSTEM);
         if (g_strcmp0 (fs_id, state->fs_id) == 0)
         {
+            GFile *subdir;
+
             /* only if it is on the same filesystem */
             subdir = g_file_get_child (state->deep_count_location, g_file_info_get_name (info));
-            state->deep_count_subdirectories = g_list_prepend
-                                                   (state->deep_count_subdirectories, subdir);
+            if (skip_count)
+            {
+                /* Count the size, even if skipped (because it still takes space). */
+                state->deep_size_only_subdirectories = g_list_prepend
+                                                           (state->deep_size_only_subdirectories, subdir);
+            }
+            else
+            {
+                state->deep_count_subdirectories = g_list_prepend
+                                                       (state->deep_count_subdirectories, subdir);
+            }
         }
     }
     else
     {
         /* Even non-regular files count as files. */
-        file->details->deep_file_count += 1;
+        file->details->deep_file_count += skip_count ? 0 : 1;
     }
 
-    /* Count the size. */
+    /* Count the size, even if skipped (because it still takes space). */
     if (!is_seen_inode && g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_SIZE))
     {
         file->details->deep_size += g_file_info_get_size (info);
@@ -2871,6 +2882,7 @@ deep_count_state_free (DeepCountState *state)
         g_object_unref (state->deep_count_location);
     }
     g_list_free_full (state->deep_count_subdirectories, g_object_unref);
+    g_list_free_full (state->deep_size_only_subdirectories, g_object_unref);
     g_array_free (state->seen_deep_count_inodes, TRUE);
     g_free (state->fs_id);
     g_free (state);
@@ -2898,6 +2910,16 @@ deep_count_next_dir (DeepCountState *state)
         location = state->deep_count_subdirectories->data;
         state->deep_count_subdirectories = g_list_remove
                                                (state->deep_count_subdirectories, location);
+        state->deep_size_only = FALSE;
+        deep_count_load (state, location);
+        g_object_unref (location);
+    }
+    else if (state->deep_size_only_subdirectories != NULL)
+    {
+        location = state->deep_size_only_subdirectories->data;
+        state->deep_size_only_subdirectories = g_list_remove
+                                                   (state->deep_size_only_subdirectories, location);
+        state->deep_size_only = TRUE;
         deep_count_load (state, location);
         g_object_unref (location);
     }
@@ -3131,6 +3153,7 @@ deep_count_start (NautilusDirectory *directory,
     state = g_new0 (DeepCountState, 1);
     state->directory = directory;
     state->cancellable = g_cancellable_new ();
+    state->deep_size_only = FALSE;
     state->seen_deep_count_inodes = g_array_new (FALSE, TRUE, sizeof (guint64));
     state->fs_id = NULL;