[PATCH v6 0/6] convert: add "status=delayed" to filter process protocol

@@ -1543,14 +1543,14 @@ extern int ident_cmp(const struct ident_split *, const struct ident_split *);
 struct checkout {
 	struct index_state *istate;
 	const char *base_dir;
-	struct delayed_checkout *delayed_checkout;
 	int base_dir_len;
+	struct delayed_checkout *delayed_checkout;
 	unsigned force:1,
 		 quiet:1,
 		 not_new:1,
 		 refresh_cache:1;
 };
-#define CHECKOUT_INIT { NULL, "", NULL }
+#define CHECKOUT_INIT { NULL, "" }


 #define TEMPORARY_FILENAME_LENGTH 25

@@ -572,9 +572,9 @@ static int start_multi_file_filter_fn(struct subprocess_entry *subprocess)
 static void handle_filter_error(const struct strbuf *filter_status,
 				struct cmd2process *entry,
 				const unsigned int wanted_capability) {
-	if (!strcmp(filter_status->buf, "error")) {
-		/* The filter signaled a problem with the file. */
-	} else if (!strcmp(filter_status->buf, "abort") && wanted_capability) {
+	if (!strcmp(filter_status->buf, "error"))
+		; /* The filter signaled a problem with the file. */
+	else if (!strcmp(filter_status->buf, "abort") && wanted_capability) {
 		/*
 		 * The filter signaled a permanent problem. Don't try to filter
 		 * files with the same command for the lifetime of the current

@@ -626,12 +626,12 @@ static int apply_multi_file_filter(const char *path, const char *src, size_t len
 	}
 	process = &entry->subprocess.process;

-	if (!(wanted_capability & entry->supported_capabilities))
+	if (!(entry->supported_capabilities & wanted_capability))
 		return 0;

-	if (CAP_CLEAN & wanted_capability)
+	if (wanted_capability & CAP_CLEAN)
 		filter_type = "clean";
-	else if (CAP_SMUDGE & wanted_capability)
+	else if (wanted_capability & CAP_SMUDGE)
 		filter_type = "smudge";
 	else
 		die("unexpected filter type");

@@ -653,7 +653,7 @@ static int apply_multi_file_filter(const char *path, const char *src, size_t len
 	if (err)
 		goto done;

-	if (CAP_DELAY & entry->supported_capabilities &&
+	if ((entry->supported_capabilities & CAP_DELAY) &&
 	    dco && dco->state == CE_CAN_DELAY) {
 		can_delay = 1;
 		err = packet_write_fmt_gently(process->in, "can-delay=1\n");

@@ -736,16 +736,12 @@ int async_query_available_blobs(const char *cmd, struct string_list *delayed_pat
 	if (err)
 		goto done;

-	for (;;) {
-		const char* pre = "pathname=";
-		const int pre_len = strlen(pre);
-		line = packet_read_line(process->out, NULL);
-		if (!line)
-			break;
-		err = strlen(line) <= pre_len || strncmp(line, pre, pre_len);
-		if (err)
-			goto done;
-		string_list_insert(delayed_paths, xstrdup(line+pre_len));
+	while ((line = packet_read_line(process->out, NULL))) {
+		const char *path;
+		if (skip_prefix(line, "pathname=", &path))
+			string_list_insert(delayed_paths, xstrdup(path));
+		else
+			; /* ignore unknown keys */
 	}

 	err = subprocess_read_status(process->out, &filter_status);

@@ -784,9 +780,9 @@ static int apply_filter(const char *path, const char *src, size_t len,
 	if (!dst)
 		return 1;

-	if ((CAP_CLEAN & wanted_capability) && !drv->process && drv->clean)
+	if ((wanted_capability & CAP_CLEAN) && !drv->process && drv->clean)
 		cmd = drv->clean;
-	else if ((CAP_SMUDGE & wanted_capability) && !drv->process && drv->smudge)
+	else if ((wanted_capability & CAP_SMUDGE) && !drv->process && drv->smudge)
 		cmd = drv->smudge;

 	if (cmd && *cmd)

@@ -42,6 +42,10 @@ enum ce_delay_state {
 };

 struct delayed_checkout {
+	/* State of the currently processed cache entry. If the state is
+	CE_CAN_DELAY, then the filter can change this to CE_DELAYED. If
+	the state is CE_RETRY, then this signals the filter that the cache
+	entry was requested before. */
 	enum ce_delay_state state;
 	/* List of filter drivers that signaled delayed blobs. */
 	struct string_list filters;

@@ -159,10 +159,10 @@ int finish_delayed_checkout(struct checkout *state)
 	struct string_list_item *filter, *path;
 	struct delayed_checkout *dco = state->delayed_checkout;

-	if (!state->delayed_checkout) {
+	if (!state->delayed_checkout)
 		return errs;
-	}

+	dco->state = CE_RETRY;
 	while (dco->filters.nr > 0) {
 		for_each_string_list_item(filter, &dco->filters) {
 			struct string_list available_paths;

@@ -195,7 +195,7 @@ int finish_delayed_checkout(struct checkout *state)
 				struct cache_entry* ce = index_file_exists(
 					state->istate, path->string,
 					strlen(path->string), 0);
-				dco->state = CE_RETRY;
+				assert(dco->state == CE_RETRY);
 				errs |= (ce ? checkout_entry(ce, state, NULL) : 1);
 			}
 		}

@@ -205,6 +205,10 @@ int finish_delayed_checkout(struct checkout *state)

 	/* At this point we should not have any delayed paths anymore. */
 	errs |= dco->paths.nr;
+	for_each_string_list_item(path, &dco->paths) {
+		warning(_("%s was not filtered properly."), path->string);
+	}
+	string_list_clear(&dco->paths, 0);

 	free(dco);
 	state->delayed_checkout = NULL;