1 files changed, 28 insertions, 28 deletions

diff --git a/test/core/util/slice_splitter.c b/test/core/util/slice_splitter.c
index 95b55a6505..177c9892a5 100644
--- a/test/core/util/slice_splitter.c
+++ b/test/core/util/slice_splitter.c
@@ -50,8 +50,8 @@ const char *grpc_slice_split_mode_name(grpc_slice_split_mode mode) {
   return "error";
 }
 
-void grpc_split_slices(grpc_slice_split_mode mode, gpr_slice *src_slices,
-                       size_t src_slice_count, gpr_slice **dst_slices,
+void grpc_split_slices(grpc_slice_split_mode mode, grpc_slice *src_slices,
+                       size_t src_slice_count, grpc_slice **dst_slices,
                        size_t *dst_slice_count) {
   size_t i, j;
   size_t length;
@@ -59,39 +59,39 @@ void grpc_split_slices(grpc_slice_split_mode mode, gpr_slice *src_slices,
   switch (mode) {
     case GRPC_SLICE_SPLIT_IDENTITY:
       *dst_slice_count = src_slice_count;
-      *dst_slices = gpr_malloc(sizeof(gpr_slice) * src_slice_count);
+      *dst_slices = gpr_malloc(sizeof(grpc_slice) * src_slice_count);
       for (i = 0; i < src_slice_count; i++) {
         (*dst_slices)[i] = src_slices[i];
-        gpr_slice_ref((*dst_slices)[i]);
+        grpc_slice_ref((*dst_slices)[i]);
       }
       break;
     case GRPC_SLICE_SPLIT_MERGE_ALL:
       *dst_slice_count = 1;
       length = 0;
       for (i = 0; i < src_slice_count; i++) {
-        length += GPR_SLICE_LENGTH(src_slices[i]);
+        length += GRPC_SLICE_LENGTH(src_slices[i]);
       }
-      *dst_slices = gpr_malloc(sizeof(gpr_slice));
-      **dst_slices = gpr_slice_malloc(length);
+      *dst_slices = gpr_malloc(sizeof(grpc_slice));
+      **dst_slices = grpc_slice_malloc(length);
       length = 0;
       for (i = 0; i < src_slice_count; i++) {
-        memcpy(GPR_SLICE_START_PTR(**dst_slices) + length,
-               GPR_SLICE_START_PTR(src_slices[i]),
-               GPR_SLICE_LENGTH(src_slices[i]));
-        length += GPR_SLICE_LENGTH(src_slices[i]);
+        memcpy(GRPC_SLICE_START_PTR(**dst_slices) + length,
+               GRPC_SLICE_START_PTR(src_slices[i]),
+               GRPC_SLICE_LENGTH(src_slices[i]));
+        length += GRPC_SLICE_LENGTH(src_slices[i]);
       }
       break;
     case GRPC_SLICE_SPLIT_ONE_BYTE:
       length = 0;
       for (i = 0; i < src_slice_count; i++) {
-        length += GPR_SLICE_LENGTH(src_slices[i]);
+        length += GRPC_SLICE_LENGTH(src_slices[i]);
       }
       *dst_slice_count = length;
-      *dst_slices = gpr_malloc(sizeof(gpr_slice) * length);
+      *dst_slices = gpr_malloc(sizeof(grpc_slice) * length);
       length = 0;
       for (i = 0; i < src_slice_count; i++) {
-        for (j = 0; j < GPR_SLICE_LENGTH(src_slices[i]); j++) {
-          (*dst_slices)[length] = gpr_slice_sub(src_slices[i], j, j + 1);
+        for (j = 0; j < GRPC_SLICE_LENGTH(src_slices[i]); j++) {
+          (*dst_slices)[length] = grpc_slice_sub(src_slices[i], j, j + 1);
           length++;
         }
       }
@@ -100,39 +100,39 @@ void grpc_split_slices(grpc_slice_split_mode mode, gpr_slice *src_slices,
 }
 
 void grpc_split_slices_to_buffer(grpc_slice_split_mode mode,
-                                 gpr_slice *src_slices, size_t src_slice_count,
-                                 gpr_slice_buffer *dst) {
-  gpr_slice *slices;
+                                 grpc_slice *src_slices, size_t src_slice_count,
+                                 grpc_slice_buffer *dst) {
+  grpc_slice *slices;
   size_t nslices;
   size_t i;
   grpc_split_slices(mode, src_slices, src_slice_count, &slices, &nslices);
   for (i = 0; i < nslices; i++) {
     /* add indexed to avoid re-merging split slices */
-    gpr_slice_buffer_add_indexed(dst, slices[i]);
+    grpc_slice_buffer_add_indexed(dst, slices[i]);
   }
   gpr_free(slices);
 }
 
-void grpc_split_slice_buffer(grpc_slice_split_mode mode, gpr_slice_buffer *src,
-                             gpr_slice_buffer *dst) {
+void grpc_split_slice_buffer(grpc_slice_split_mode mode, grpc_slice_buffer *src,
+                             grpc_slice_buffer *dst) {
   grpc_split_slices_to_buffer(mode, src->slices, src->count, dst);
 }
 
-gpr_slice grpc_slice_merge(gpr_slice *slices, size_t nslices) {
+grpc_slice grpc_slice_merge(grpc_slice *slices, size_t nslices) {
   uint8_t *out = NULL;
   size_t length = 0;
   size_t capacity = 0;
   size_t i;
 
   for (i = 0; i < nslices; i++) {
-    if (GPR_SLICE_LENGTH(slices[i]) + length > capacity) {
-      capacity = GPR_MAX(capacity * 2, GPR_SLICE_LENGTH(slices[i]) + length);
+    if (GRPC_SLICE_LENGTH(slices[i]) + length > capacity) {
+      capacity = GPR_MAX(capacity * 2, GRPC_SLICE_LENGTH(slices[i]) + length);
       out = gpr_realloc(out, capacity);
     }
-    memcpy(out + length, GPR_SLICE_START_PTR(slices[i]),
-           GPR_SLICE_LENGTH(slices[i]));
-    length += GPR_SLICE_LENGTH(slices[i]);
+    memcpy(out + length, GRPC_SLICE_START_PTR(slices[i]),
+           GRPC_SLICE_LENGTH(slices[i]));
+    length += GRPC_SLICE_LENGTH(slices[i]);
   }
 
-  return gpr_slice_new(out, length, gpr_free);
+  return grpc_slice_new(out, length, gpr_free);
 }