xds: always keep empty mutated headers and ignore keep_empty_value

Updates the HeaderMutator library to always apply mutations even if
the resulting value is empty, ignoring the keep_empty_value setting
altogether. Empty mutated values are now kept in the metadata and
the header key is no longer discarded.

- Removes containsEmpty check and helper from HeaderMutator.
- Updates HeaderMutatorTest to assert that empty mutations are kept.

Author: kannanjgithub

xds/src/main/java/io/grpc/xds/internal/headermutations/HeaderMutator.java

@@ -72,19 +72,13 @@ private void updateHeader(final HeaderValueOption option, Metadata mutableHeader
       if (header.rawValue().isPresent()) {
         Metadata.Key<byte[]> key = Metadata.Key.of(header.key(), Metadata.BINARY_BYTE_MARSHALLER);
         updateHeader(action, key, header.rawValue().get().toByteArray(), mutableHeaders);
-        if (containsEmpty(key, mutableHeaders)) {
-          mutableHeaders.discardAll(key);
-        }
       } else {
         logger.fine("Missing binary rawValue for header: " + header.key());
       }
     } else {
       if (header.value().isPresent()) {
         Metadata.Key<String> key = Metadata.Key.of(header.key(), Metadata.ASCII_STRING_MARSHALLER);
         updateHeader(action, key, header.value().get(), mutableHeaders);
-        if (containsEmpty(key, mutableHeaders)) {
-          mutableHeaders.discardAll(key);
-        }
       } else {
         logger.fine("Missing value for header: " + header.key());
       }
@@ -118,24 +112,5 @@ private <T> void updateHeader(final HeaderAppendAction action, final Metadata.Ke
         logger.fine("Unknown HeaderAppendAction: " + action);
     }
   }
-
-  private <T> boolean containsEmpty(Metadata.Key<T> key, Metadata headers) {
-    Iterable<T> values = headers.getAll(key);
-    if (values == null) {
-      return false;
-    }
-    for (T val : values) {
-      if (val instanceof String) {
-        if (((String) val).isEmpty()) {
-          return true;
-        }
-      } else if (val instanceof byte[]) {
-        if (((byte[]) val).length == 0) {
-          return true;
-        }
-      }
-    }
-    return false;
-  }
 }
 

xds/src/test/java/io/grpc/xds/internal/headermutations/HeaderMutatorTest.java

@@ -201,7 +201,7 @@ public void applyResponseMutations_binary() {
   }
 
   @Test
-  public void applyMutations_keepEmptyValue() {
+  public void applyMutations_emptyValuesAreKept() {
     Metadata headers = new Metadata();
     headers.put(APPEND_KEY, "existing-value");
     headers.put(OVERWRITE_KEY, "existing-value");
@@ -242,28 +242,28 @@ public void applyMutations_keepEmptyValue() {
 
     headerMutator.applyMutations(mutations, headers);
 
-    assertThat(headers.containsKey(NEW_ADD_KEY)).isFalse();
-    assertThat(headers.containsKey(APPEND_KEY)).isFalse();
-    assertThat(headers.containsKey(OVERWRITE_KEY)).isFalse();
-    assertThat(headers.containsKey(ADD_KEY)).isFalse();
-    assertThat(headers.containsKey(OVERWRITE_IF_EXISTS_KEY)).isFalse();
+    assertThat(headers.get(NEW_ADD_KEY)).isEqualTo("");
+    assertThat(headers.getAll(APPEND_KEY)).containsExactly("existing-value", "");
+    assertThat(headers.get(OVERWRITE_KEY)).isEqualTo("");
+    assertThat(headers.get(ADD_KEY)).isEqualTo("");
+    assertThat(headers.get(OVERWRITE_IF_EXISTS_KEY)).isEqualTo("");
 
     Metadata.Key<String> keepEmptyKey =
         Metadata.Key.of("keep-empty-key", Metadata.ASCII_STRING_MARSHALLER);
     Metadata.Key<String> keepEmptyOverwriteKey =
         Metadata.Key.of("keep-empty-overwrite-key", Metadata.ASCII_STRING_MARSHALLER);
 
-    assertThat(headers.containsKey(keepEmptyKey)).isFalse();
-    assertThat(headers.containsKey(keepEmptyOverwriteKey)).isFalse();
+    assertThat(headers.get(keepEmptyKey)).isEqualTo("");
+    assertThat(headers.get(keepEmptyOverwriteKey)).isEqualTo("");
 
     Metadata.Key<byte[]> keepEmptyBinKey =
         Metadata.Key.of("keep-empty-bin-key-bin", Metadata.BINARY_BYTE_MARSHALLER);
     Metadata.Key<byte[]> ignoreEmptyBinKey =
         Metadata.Key.of("ignore-empty-bin-key-bin", Metadata.BINARY_BYTE_MARSHALLER);
 
-    assertThat(headers.containsKey(keepEmptyBinKey)).isFalse();
-    assertThat(headers.containsKey(ignoreEmptyBinKey)).isFalse();
-    assertThat(headers.containsKey(overwriteEmptyBinKey)).isFalse();
+    assertThat(headers.get(keepEmptyBinKey)).isEqualTo(new byte[0]);
+    assertThat(headers.get(ignoreEmptyBinKey)).isEqualTo(new byte[0]);
+    assertThat(headers.get(overwriteEmptyBinKey)).isEqualTo(new byte[0]);
   }
 
   @Test