grpc 1.50.0 → 1.52.0.pre2

data/src/core/lib/slice/b64.h

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #ifndef GRPC_CORE_LIB_SLICE_B64_H
 #define GRPC_CORE_LIB_SLICE_B64_H
@@ -25,28 +25,28 @@
 
 #include <grpc/slice.h>
 
-/* Encodes data using base64. It is the caller's responsibility to free
-   the returned char * using gpr_free. Returns NULL on NULL input.
-   TODO(makdharma) : change the flags to bool from int */
+// Encodes data using base64. It is the caller's responsibility to free
+// the returned char * using gpr_free. Returns NULL on NULL input.
+// TODO(makdharma) : change the flags to bool from int
 char* grpc_base64_encode(const void* data, size_t data_size, int url_safe,
                          int multiline);
 
-/* estimate the upper bound on size of base64 encoded data. The actual size
- * is guaranteed to be less than or equal to the size returned here. */
+// estimate the upper bound on size of base64 encoded data. The actual size
+// is guaranteed to be less than or equal to the size returned here.
 size_t grpc_base64_estimate_encoded_size(size_t data_size, int multiline);
 
-/* Encodes data using base64 and write it to memory pointed to by result. It is
- * the caller's responsibility to allocate enough memory in |result| to fit the
- * encoded data. */
+// Encodes data using base64 and write it to memory pointed to by result. It is
+// the caller's responsibility to allocate enough memory in |result| to fit the
+// encoded data.
 void grpc_base64_encode_core(char* result, const void* vdata, size_t data_size,
                              int url_safe, int multiline);
 
-/* Decodes data according to the base64 specification. Returns an empty
-   slice in case of failure. */
+// Decodes data according to the base64 specification. Returns an empty
+// slice in case of failure.
 grpc_slice grpc_base64_decode(const char* b64, int url_safe);
 
-/* Same as above except that the length is provided by the caller. */
+// Same as above except that the length is provided by the caller.
 grpc_slice grpc_base64_decode_with_len(const char* b64, size_t b64_len,
                                        int url_safe);
 
-#endif /* GRPC_CORE_LIB_SLICE_B64_H */
+#endif  // GRPC_CORE_LIB_SLICE_B64_H

data/src/core/lib/slice/percent_encoding.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2016 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2016 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #include <grpc/support/port_platform.h>
 

data/src/core/lib/slice/percent_encoding.h

@@ -1,30 +1,30 @@
-/*
- *
- * Copyright 2016 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2016 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #ifndef GRPC_CORE_LIB_SLICE_PERCENT_ENCODING_H
 #define GRPC_CORE_LIB_SLICE_PERCENT_ENCODING_H
 
-/* Percent encoding and decoding of slices.
-   Transforms arbitrary strings into safe-for-transmission strings by using
-   variants of percent encoding (RFC 3986).
-   Two major variants are supplied: one that strictly matches URL encoding,
-     and another which applies percent encoding only to non-http2 header
-     bytes (the 'compatible' variant) */
+// Percent encoding and decoding of slices.
+// Transforms arbitrary strings into safe-for-transmission strings by using
+// variants of percent encoding (RFC 3986).
+// Two major variants are supplied: one that strictly matches URL encoding,
+//   and another which applies percent encoding only to non-http2 header
+//   bytes (the 'compatible' variant)
 
 #include <grpc/support/port_platform.h>
 
@@ -51,4 +51,4 @@ Slice PermissivePercentDecodeSlice(Slice slice_in);
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_SLICE_PERCENT_ENCODING_H */
+#endif  // GRPC_CORE_LIB_SLICE_PERCENT_ENCODING_H

data/src/core/lib/slice/slice.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #include <grpc/support/port_platform.h>
 
@@ -30,7 +30,7 @@
 
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/slice/slice_refcount_base.h"
+#include "src/core/lib/slice/slice_refcount.h"
 
 char* grpc_slice_to_c_string(grpc_slice slice) {
   char* out = static_cast<char*>(gpr_malloc(GRPC_SLICE_LENGTH(slice) + 1));
@@ -52,8 +52,8 @@ grpc_slice grpc_slice_copy(grpc_slice s) {
 
 namespace grpc_core {
 
-/* grpc_slice_new support structures - we create a refcount object extended
-   with the user provided data pointer & destroy function */
+// grpc_slice_new support structures - we create a refcount object extended
+// with the user provided data pointer & destroy function
 class NewSliceRefcount : public grpc_slice_refcount {
  public:
   NewSliceRefcount(void (*destroy)(void*), void* user_data)
@@ -101,13 +101,13 @@ grpc_slice grpc_slice_new_with_user_data(void* p, size_t len,
 }
 
 grpc_slice grpc_slice_new(void* p, size_t len, void (*destroy)(void*)) {
-  /* Pass "p" to *destroy when the slice is no longer needed. */
+  // Pass "p" to *destroy when the slice is no longer needed.
   return grpc_slice_new_with_user_data(p, len, destroy, p);
 }
 
 namespace grpc_core {
-/* grpc_slice_new_with_len support structures - we create a refcount object
-   extended with the user provided data pointer & destroy function */
+// grpc_slice_new_with_len support structures - we create a refcount object
+// extended with the user provided data pointer & destroy function
 class NewWithLenSliceRefcount : public grpc_slice_refcount {
  public:
   NewWithLenSliceRefcount(void (*destroy)(void*, size_t), void* user_data,
@@ -128,7 +128,7 @@ class NewWithLenSliceRefcount : public grpc_slice_refcount {
   void (*user_destroy_)(void*, size_t);
 };
 
-/** grpc_slice_from_moved_(string|buffer) ref count .*/
+/// grpc_slice_from_moved_(string|buffer) ref count .
 class MovedStringSliceRefCount : public grpc_slice_refcount {
  public:
   explicit MovedStringSliceRefCount(UniquePtr<char>&& str)
@@ -248,16 +248,16 @@ static grpc_slice sub_no_ref(const grpc_slice& source, size_t begin,
   GPR_ASSERT(end >= begin);
 
   if (source.refcount != nullptr) {
-    /* Enforce preconditions */
+    // Enforce preconditions
     GPR_ASSERT(source.data.refcounted.length >= end);
 
-    /* Build the result */
+    // Build the result
     subset.refcount = source.refcount;
-    /* Point into the source array */
+    // Point into the source array
     subset.data.refcounted.bytes = source.data.refcounted.bytes + begin;
     subset.data.refcounted.length = end - begin;
   } else {
-    /* Enforce preconditions */
+    // Enforce preconditions
     GPR_ASSERT(source.data.inlined.length >= end);
     subset.refcount = nullptr;
     subset.data.inlined.length = static_cast<uint8_t>(end - begin);
@@ -281,7 +281,7 @@ grpc_slice grpc_slice_sub(grpc_slice source, size_t begin, size_t end) {
            end - begin);
   } else {
     subset = grpc_slice_sub_no_ref(source, begin, end);
-    /* Bump the refcount */
+    // Bump the refcount
     if (subset.refcount != grpc_slice_refcount::NoopRefcount()) {
       subset.refcount->Ref();
     }
@@ -294,7 +294,7 @@ grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice* source, size_t split,
   grpc_slice tail;
 
   if (source->refcount == nullptr) {
-    /* inlined data, copy it out */
+    // inlined data, copy it out
     GPR_ASSERT(source->data.inlined.length >= split);
     tail.refcount = nullptr;
     tail.data.inlined.length =
@@ -303,7 +303,7 @@ grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice* source, size_t split,
            tail.data.inlined.length);
     source->data.inlined.length = static_cast<uint8_t>(split);
   } else if (source->refcount == grpc_slice_refcount::NoopRefcount()) {
-    /* refcount == NoopRefcount(), so we can just split in-place */
+    // refcount == NoopRefcount(), so we can just split in-place
     tail.refcount = grpc_slice_refcount::NoopRefcount();
     tail.data.refcounted.bytes = source->data.refcounted.bytes + split;
     tail.data.refcounted.length = source->data.refcounted.length - split;
@@ -313,13 +313,13 @@ grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice* source, size_t split,
     GPR_ASSERT(source->data.refcounted.length >= split);
     if (tail_length < sizeof(tail.data.inlined.bytes) &&
         ref_whom != GRPC_SLICE_REF_TAIL) {
-      /* Copy out the bytes - it'll be cheaper than refcounting */
+      // Copy out the bytes - it'll be cheaper than refcounting
       tail.refcount = nullptr;
       tail.data.inlined.length = static_cast<uint8_t>(tail_length);
       memcpy(tail.data.inlined.bytes, source->data.refcounted.bytes + split,
              tail_length);
     } else {
-      /* Build the result */
+      // Build the result
       switch (ref_whom) {
         case GRPC_SLICE_REF_TAIL:
           tail.refcount = source->refcount;
@@ -330,13 +330,13 @@ grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice* source, size_t split,
           break;
         case GRPC_SLICE_REF_BOTH:
           tail.refcount = source->refcount;
-          /* Bump the refcount */
+          // Bump the refcount
           if (tail.refcount != grpc_slice_refcount::NoopRefcount()) {
             tail.refcount->Ref();
           }
           break;
       }
-      /* Point into the source array */
+      // Point into the source array
       tail.data.refcounted.bytes = source->data.refcounted.bytes + split;
       tail.data.refcounted.length = tail_length;
     }
@@ -374,13 +374,13 @@ grpc_slice grpc_slice_split_head(grpc_slice* source, size_t split) {
   } else {
     GPR_ASSERT(source->data.refcounted.length >= split);
 
-    /* Build the result */
+    // Build the result
     head.refcount = source->refcount;
-    /* Bump the refcount */
+    // Bump the refcount
     if (head.refcount != grpc_slice_refcount::NoopRefcount()) {
       head.refcount->Ref();
     }
-    /* Point into the source array */
+    // Point into the source array
     head.data.refcounted.bytes = source->data.refcounted.bytes;
     head.data.refcounted.length = split;
     source->data.refcounted.bytes += split;
@@ -494,3 +494,9 @@ grpc_slice grpc_slice_dup(grpc_slice a) {
          GRPC_SLICE_LENGTH(a));
   return copy;
 }
+
+grpc_slice grpc_slice_ref(grpc_slice slice) {
+  return grpc_core::CSliceRef(slice);
+}
+
+void grpc_slice_unref(grpc_slice slice) { grpc_core::CSliceUnref(slice); }

data/src/core/lib/slice/slice.h

@@ -25,13 +25,14 @@
 
 #include "absl/strings/string_view.h"
 
+#include <grpc/event_engine/internal/slice_cast.h>
+#include <grpc/event_engine/slice.h>
 #include <grpc/slice.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_refcount.h"
-#include "src/core/lib/slice/slice_refcount_base.h"
 
 // Herein lies grpc_core::Slice and its team of thin wrappers around grpc_slice.
 // They aim to keep you safe by providing strong guarantees around lifetime and
@@ -53,6 +54,19 @@
 
 namespace grpc_core {
 
+inline const grpc_slice& CSliceRef(const grpc_slice& slice) {
+  if (reinterpret_cast<uintptr_t>(slice.refcount) > 1) {
+    slice.refcount->Ref();
+  }
+  return slice;
+}
+
+inline void CSliceUnref(const grpc_slice& slice) {
+  if (reinterpret_cast<uintptr_t>(slice.refcount) > 1) {
+    slice.refcount->Unref();
+  }
+}
+
 namespace slice_detail {
 
 // Returns an empty slice.
@@ -110,7 +124,7 @@ class BaseSlice {
     return grpc_slice_is_equivalent(slice_, other.slice_);
   }
 
-  uint32_t Hash() const { return grpc_slice_hash_internal(slice_); }
+  uint32_t Hash() const { return grpc_slice_hash(slice_); }
 
  protected:
   BaseSlice() : slice_(EmptySlice()) {}
@@ -182,6 +196,10 @@ struct CopyConstructors {
   static Out FromCopiedBuffer(const char* p, size_t len) {
     return Out(grpc_slice_from_copied_buffer(p, len));
   }
+  static Out FromCopiedBuffer(const uint8_t* p, size_t len) {
+    return Out(
+        grpc_slice_from_copied_buffer(reinterpret_cast<const char*>(p), len));
+  }
 
   template <typename Buffer>
   static Out FromCopiedBuffer(const Buffer& buffer) {
@@ -241,15 +259,16 @@ class StaticSlice : public slice_detail::BaseSlice,
   }
 };
 
-class MutableSlice : public slice_detail::BaseSlice,
-                     public slice_detail::CopyConstructors<MutableSlice> {
+class GPR_MSVC_EMPTY_BASE_CLASS_WORKAROUND MutableSlice
+    : public slice_detail::BaseSlice,
+      public slice_detail::CopyConstructors<MutableSlice> {
  public:
   MutableSlice() = default;
   explicit MutableSlice(const grpc_slice& slice)
       : slice_detail::BaseSlice(slice) {
     GPR_DEBUG_ASSERT(slice.refcount == nullptr || slice.refcount->IsUnique());
   }
-  ~MutableSlice() { grpc_slice_unref_internal(c_slice()); }
+  ~MutableSlice() { CSliceUnref(c_slice()); }
 
   MutableSlice(const MutableSlice&) = delete;
   MutableSlice& operator=(const MutableSlice&) = delete;
@@ -279,12 +298,14 @@ class MutableSlice : public slice_detail::BaseSlice,
   uint8_t& operator[](size_t i) { return mutable_data()[i]; }
 };
 
-class Slice : public slice_detail::BaseSlice,
-              public slice_detail::CopyConstructors<Slice>,
-              public slice_detail::StaticConstructors<Slice> {
+class GPR_MSVC_EMPTY_BASE_CLASS_WORKAROUND Slice
+    : public slice_detail::BaseSlice,
+      public slice_detail::CopyConstructors<Slice>,
+      public slice_detail::StaticConstructors<Slice> {
  public:
   Slice() = default;
-  ~Slice() { grpc_slice_unref_internal(c_slice()); }
+  ~Slice() { CSliceUnref(c_slice()); }
+
   explicit Slice(const grpc_slice& slice) : slice_detail::BaseSlice(slice) {}
   explicit Slice(slice_detail::BaseSlice&& other)
       : slice_detail::BaseSlice(other.TakeCSlice()) {}
@@ -326,7 +347,7 @@ class Slice : public slice_detail::BaseSlice,
     if (c_slice().refcount == grpc_slice_refcount::NoopRefcount()) {
       return Slice(grpc_slice_copy(c_slice()));
     }
-    return Slice(grpc_slice_ref_internal(c_slice()));
+    return Ref();
   }
 
   // TakeMutable returns a MutableSlice, and leaves the current slice in an
@@ -365,7 +386,7 @@ class Slice : public slice_detail::BaseSlice,
     return Slice(grpc_slice_split_tail(c_slice_ptr(), split));
   }
 
-  Slice Ref() const { return Slice(grpc_slice_ref_internal(c_slice())); }
+  Slice Ref() const { return Slice(CSliceRef(c_slice())); }
 
   Slice Copy() const { return Slice(grpc_slice_copy(c_slice())); }
 
@@ -386,4 +407,29 @@ class Slice : public slice_detail::BaseSlice,
 
 }  // namespace grpc_core
 
+namespace grpc_event_engine {
+namespace experimental {
+namespace internal {
+template <>
+struct SliceCastable<grpc_core::Slice, grpc_slice> {};
+template <>
+struct SliceCastable<grpc_slice, grpc_core::Slice> {};
+template <>
+struct SliceCastable<grpc_core::Slice, Slice> {};
+template <>
+struct SliceCastable<Slice, grpc_core::Slice> {};
+
+template <>
+struct SliceCastable<grpc_core::MutableSlice, grpc_slice> {};
+template <>
+struct SliceCastable<grpc_slice, grpc_core::MutableSlice> {};
+
+template <>
+struct SliceCastable<grpc_core::MutableSlice, grpc_core::Slice> {};
+template <>
+struct SliceCastable<grpc_core::Slice, grpc_core::MutableSlice> {};
+}  // namespace internal
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
 #endif  // GRPC_CORE_LIB_SLICE_SLICE_H