s/gpr_slice/grpc_slice, and move around tests, impls

5 files changed, 38 insertions, 38 deletions

diff --git a/include/grpc++/impl/codegen/core_codegen.h b/include/grpc++/impl/codegen/core_codegen.h
index 0ce009e69d..c2127a771a 100644
--- a/include/grpc++/impl/codegen/core_codegen.h
+++ b/include/grpc++/impl/codegen/core_codegen.h
@@ -73,17 +73,17 @@ class CoreCodegen : public CoreCodegenInterface {
   void grpc_byte_buffer_reader_destroy(grpc_byte_buffer_reader* reader)
       GRPC_OVERRIDE;
   int grpc_byte_buffer_reader_next(grpc_byte_buffer_reader* reader,
-                                   gpr_slice* slice) GRPC_OVERRIDE;
+                                   grpc_slice* slice) GRPC_OVERRIDE;
 
-  grpc_byte_buffer* grpc_raw_byte_buffer_create(gpr_slice* slice,
+  grpc_byte_buffer* grpc_raw_byte_buffer_create(grpc_slice* slice,
                                                 size_t nslices) GRPC_OVERRIDE;
 
-  gpr_slice gpr_slice_malloc(size_t length) GRPC_OVERRIDE;
-  void gpr_slice_unref(gpr_slice slice) GRPC_OVERRIDE;
-  gpr_slice gpr_slice_split_tail(gpr_slice* s, size_t split) GRPC_OVERRIDE;
-  void gpr_slice_buffer_add(gpr_slice_buffer* sb,
-                            gpr_slice slice) GRPC_OVERRIDE;
-  void gpr_slice_buffer_pop(gpr_slice_buffer* sb) GRPC_OVERRIDE;
+  grpc_slice grpc_slice_malloc(size_t length) GRPC_OVERRIDE;
+  void grpc_slice_unref(grpc_slice slice) GRPC_OVERRIDE;
+  grpc_slice grpc_slice_split_tail(grpc_slice* s, size_t split) GRPC_OVERRIDE;
+  void grpc_slice_buffer_add(grpc_slice_buffer* sb,
+                            grpc_slice slice) GRPC_OVERRIDE;
+  void grpc_slice_buffer_pop(grpc_slice_buffer* sb) GRPC_OVERRIDE;
 
   void grpc_metadata_array_init(grpc_metadata_array* array) GRPC_OVERRIDE;
   void grpc_metadata_array_destroy(grpc_metadata_array* array) GRPC_OVERRIDE;
diff --git a/include/grpc++/impl/codegen/core_codegen_interface.h b/include/grpc++/impl/codegen/core_codegen_interface.h
index 68851f15c6..743f528373 100644
--- a/include/grpc++/impl/codegen/core_codegen_interface.h
+++ b/include/grpc++/impl/codegen/core_codegen_interface.h
@@ -88,16 +88,16 @@ class CoreCodegenInterface {
   virtual void grpc_byte_buffer_reader_destroy(
       grpc_byte_buffer_reader* reader) = 0;
   virtual int grpc_byte_buffer_reader_next(grpc_byte_buffer_reader* reader,
-                                           gpr_slice* slice) = 0;
+                                           grpc_slice* slice) = 0;
 
-  virtual grpc_byte_buffer* grpc_raw_byte_buffer_create(gpr_slice* slice,
+  virtual grpc_byte_buffer* grpc_raw_byte_buffer_create(grpc_slice* slice,
                                                         size_t nslices) = 0;
 
-  virtual gpr_slice gpr_slice_malloc(size_t length) = 0;
-  virtual void gpr_slice_unref(gpr_slice slice) = 0;
-  virtual gpr_slice gpr_slice_split_tail(gpr_slice* s, size_t split) = 0;
-  virtual void gpr_slice_buffer_add(gpr_slice_buffer* sb, gpr_slice slice) = 0;
-  virtual void gpr_slice_buffer_pop(gpr_slice_buffer* sb) = 0;
+  virtual grpc_slice grpc_slice_malloc(size_t length) = 0;
+  virtual void grpc_slice_unref(grpc_slice slice) = 0;
+  virtual grpc_slice grpc_slice_split_tail(grpc_slice* s, size_t split) = 0;
+  virtual void grpc_slice_buffer_add(grpc_slice_buffer* sb, grpc_slice slice) = 0;
+  virtual void grpc_slice_buffer_pop(grpc_slice_buffer* sb) = 0;
 
   virtual void grpc_metadata_array_init(grpc_metadata_array* array) = 0;
   virtual void grpc_metadata_array_destroy(grpc_metadata_array* array) = 0;
diff --git a/include/grpc++/impl/codegen/proto_utils.h b/include/grpc++/impl/codegen/proto_utils.h
index 6f4786b87b..4885ea0ee7 100644
--- a/include/grpc++/impl/codegen/proto_utils.h
+++ b/include/grpc++/impl/codegen/proto_utils.h
@@ -63,7 +63,7 @@ class GrpcBufferWriter GRPC_FINAL
 
   ~GrpcBufferWriter() GRPC_OVERRIDE {
     if (have_backup_) {
-      g_core_codegen_interface->gpr_slice_unref(backup_slice_);
+      g_core_codegen_interface->grpc_slice_unref(backup_slice_);
     }
   }
 
@@ -72,24 +72,24 @@ class GrpcBufferWriter GRPC_FINAL
       slice_ = backup_slice_;
       have_backup_ = false;
     } else {
-      slice_ = g_core_codegen_interface->gpr_slice_malloc(block_size_);
+      slice_ = g_core_codegen_interface->grpc_slice_malloc(block_size_);
     }
     *data = GPR_SLICE_START_PTR(slice_);
     // On win x64, int is only 32bit
     GPR_CODEGEN_ASSERT(GPR_SLICE_LENGTH(slice_) <= INT_MAX);
     byte_count_ += * size = (int)GPR_SLICE_LENGTH(slice_);
-    g_core_codegen_interface->gpr_slice_buffer_add(slice_buffer_, slice_);
+    g_core_codegen_interface->grpc_slice_buffer_add(slice_buffer_, slice_);
     return true;
   }
 
   void BackUp(int count) GRPC_OVERRIDE {
-    g_core_codegen_interface->gpr_slice_buffer_pop(slice_buffer_);
+    g_core_codegen_interface->grpc_slice_buffer_pop(slice_buffer_);
     if (count == block_size_) {
       backup_slice_ = slice_;
     } else {
-      backup_slice_ = g_core_codegen_interface->gpr_slice_split_tail(
+      backup_slice_ = g_core_codegen_interface->grpc_slice_split_tail(
           &slice_, GPR_SLICE_LENGTH(slice_) - count);
-      g_core_codegen_interface->gpr_slice_buffer_add(slice_buffer_, slice_);
+      g_core_codegen_interface->grpc_slice_buffer_add(slice_buffer_, slice_);
     }
     have_backup_ = true;
     byte_count_ -= count;
@@ -100,10 +100,10 @@ class GrpcBufferWriter GRPC_FINAL
  private:
   const int block_size_;
   int64_t byte_count_;
-  gpr_slice_buffer* slice_buffer_;
+  grpc_slice_buffer* slice_buffer_;
   bool have_backup_;
-  gpr_slice backup_slice_;
-  gpr_slice slice_;
+  grpc_slice backup_slice_;
+  grpc_slice slice_;
 };
 
 class GrpcBufferReader GRPC_FINAL
@@ -137,7 +137,7 @@ class GrpcBufferReader GRPC_FINAL
                                                                 &slice_)) {
       return false;
     }
-    g_core_codegen_interface->gpr_slice_unref(slice_);
+    g_core_codegen_interface->grpc_slice_unref(slice_);
     *data = GPR_SLICE_START_PTR(slice_);
     // On win x64, int is only 32bit
     GPR_CODEGEN_ASSERT(GPR_SLICE_LENGTH(slice_) <= INT_MAX);
@@ -172,7 +172,7 @@ class GrpcBufferReader GRPC_FINAL
   int64_t byte_count_;
   int64_t backup_count_;
   grpc_byte_buffer_reader reader_;
-  gpr_slice slice_;
+  grpc_slice slice_;
   Status status_;
 };
 }  // namespace internal
@@ -186,12 +186,12 @@ class SerializationTraits<T, typename std::enable_if<std::is_base_of<
     *own_buffer = true;
     int byte_size = msg.ByteSize();
     if (byte_size <= internal::kGrpcBufferWriterMaxBufferLength) {
-      gpr_slice slice = g_core_codegen_interface->gpr_slice_malloc(byte_size);
+      grpc_slice slice = g_core_codegen_interface->grpc_slice_malloc(byte_size);
       GPR_CODEGEN_ASSERT(
           GPR_SLICE_END_PTR(slice) ==
           msg.SerializeWithCachedSizesToArray(GPR_SLICE_START_PTR(slice)));
       *bp = g_core_codegen_interface->grpc_raw_byte_buffer_create(&slice, 1);
-      g_core_codegen_interface->gpr_slice_unref(slice);
+      g_core_codegen_interface->grpc_slice_unref(slice);
       return g_core_codegen_interface->ok();
     } else {
       internal::GrpcBufferWriter writer(
diff --git a/include/grpc++/impl/codegen/thrift_serializer.h b/include/grpc++/impl/codegen/thrift_serializer.h
index fd324a994f..691ce1af48 100644
--- a/include/grpc++/impl/codegen/thrift_serializer.h
+++ b/include/grpc++/impl/codegen/thrift_serializer.h
@@ -109,12 +109,12 @@ class ThriftSerializer {
 
     Serialize(fields, &byte_buffer, &byte_buffer_size);
 
-    gpr_slice slice = gpr_slice_from_copied_buffer(
+    grpc_slice slice = grpc_slice_from_copied_buffer(
         reinterpret_cast<const char*>(byte_buffer), byte_buffer_size);
 
     *bp = grpc_raw_byte_buffer_create(&slice, 1);
 
-    gpr_slice_unref(slice);
+    grpc_slice_unref(slice);
   }
 
   // Deserialize the passed char array into  the passed type, returns the number
@@ -156,12 +156,12 @@ class ThriftSerializer {
     grpc_byte_buffer_reader reader;
     grpc_byte_buffer_reader_init(&reader, buffer);
 
-    gpr_slice slice = grpc_byte_buffer_reader_readall(&reader);
+    grpc_slice slice = grpc_byte_buffer_reader_readall(&reader);
 
     uint32_t len =
         Deserialize(GPR_SLICE_START_PTR(slice), GPR_SLICE_LENGTH(slice), msg);
 
-    gpr_slice_unref(slice);
+    grpc_slice_unref(slice);
 
     grpc_byte_buffer_reader_destroy(&reader);
 
diff --git a/include/grpc++/support/slice.h b/include/grpc++/support/slice.h
index 5874b4f5ae..b06b1b69e5 100644
--- a/include/grpc++/support/slice.h
+++ b/include/grpc++/support/slice.h
@@ -39,7 +39,7 @@
 
 namespace grpc {
 
-/// A wrapper around \a gpr_slice.
+/// A wrapper around \a grpc_slice.
 ///
 /// A slice represents a contiguous reference counted array of bytes.
 /// It is cheap to take references to a slice, and it is cheap to create a
@@ -53,11 +53,11 @@ class Slice GRPC_FINAL {
 
   enum AddRef { ADD_REF };
   /// Construct a slice from \a slice, adding a reference.
-  Slice(gpr_slice slice, AddRef);
+  Slice(grpc_slice slice, AddRef);
 
   enum StealRef { STEAL_REF };
   /// Construct a slice from \a slice, stealing a reference.
-  Slice(gpr_slice slice, StealRef);
+  Slice(grpc_slice slice, StealRef);
 
   /// Copy constructor, adds a reference.
   Slice(const Slice& other);
@@ -77,13 +77,13 @@ class Slice GRPC_FINAL {
   /// Raw pointer to the end (one byte \em past the last element) of the slice.
   const uint8_t* end() const { return GPR_SLICE_END_PTR(slice_); }
 
-  /// Raw C slice. Caller needs to call gpr_slice_unref when done.
-  gpr_slice c_slice() const { return gpr_slice_ref(slice_); }
+  /// Raw C slice. Caller needs to call grpc_slice_unref when done.
+  grpc_slice c_slice() const { return grpc_slice_ref(slice_); }
 
  private:
   friend class ByteBuffer;
 
-  gpr_slice slice_;
+  grpc_slice slice_;
 };
 
 }  // namespace grpc