grpc 1.50.0-x86_64-linux → 1.51.0-x86_64-linux

data/src/core/ext/filters/fault_injection/service_config_parser.cc

@@ -1,187 +0,0 @@
-//
-// Copyright 2021 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>
-
-#include "src/core/ext/filters/fault_injection/service_config_parser.h"
-
-#include <algorithm>
-#include <vector>
-
-#include "absl/memory/memory.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
-#include "absl/types/optional.h"
-
-#include "src/core/ext/filters/fault_injection/fault_injection_filter.h"
-#include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/status_util.h"
-#include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/json/json_util.h"
-
-namespace grpc_core {
-
-namespace {
-
-std::vector<FaultInjectionMethodParsedConfig::FaultInjectionPolicy>
-ParseFaultInjectionPolicy(const Json::Array& policies_json_array,
-                          std::vector<grpc_error_handle>* error_list) {
-  std::vector<FaultInjectionMethodParsedConfig::FaultInjectionPolicy> policies;
-  for (size_t i = 0; i < policies_json_array.size(); i++) {
-    FaultInjectionMethodParsedConfig::FaultInjectionPolicy
-        fault_injection_policy;
-    std::vector<grpc_error_handle> sub_error_list;
-    if (policies_json_array[i].type() != Json::Type::OBJECT) {
-      error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
-          "faultInjectionPolicy index ", i, " is not a JSON object")));
-      continue;
-    }
-    const Json::Object& json_object = policies_json_array[i].object_value();
-    // Parse abort_code
-    std::string abort_code_string;
-    if (ParseJsonObjectField(json_object, "abortCode", &abort_code_string,
-                             &sub_error_list, false)) {
-      if (!grpc_status_code_from_string(abort_code_string.c_str(),
-                                        &(fault_injection_policy.abort_code))) {
-        sub_error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:abortCode error:failed to parse status code"));
-      }
-    }
-    // Parse abort_message
-    if (!ParseJsonObjectField(json_object, "abortMessage",
-                              &fault_injection_policy.abort_message,
-                              &sub_error_list, false)) {
-      fault_injection_policy.abort_message = "Fault injected";
-    }
-    // Parse abort_code_header
-    ParseJsonObjectField(json_object, "abortCodeHeader",
-                         &fault_injection_policy.abort_code_header,
-                         &sub_error_list, false);
-    // Parse abort_percentage_header
-    ParseJsonObjectField(json_object, "abortPercentageHeader",
-                         &fault_injection_policy.abort_percentage_header,
-                         &sub_error_list, false);
-    // Parse abort_percentage_numerator
-    ParseJsonObjectField(json_object, "abortPercentageNumerator",
-                         &fault_injection_policy.abort_percentage_numerator,
-                         &sub_error_list, false);
-    // Parse abort_percentage_denominator
-    if (ParseJsonObjectField(
-            json_object, "abortPercentageDenominator",
-            &fault_injection_policy.abort_percentage_denominator,
-            &sub_error_list, false)) {
-      if (fault_injection_policy.abort_percentage_denominator != 100 &&
-          fault_injection_policy.abort_percentage_denominator != 10000 &&
-          fault_injection_policy.abort_percentage_denominator != 1000000) {
-        sub_error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:abortPercentageDenominator error:Denominator can only be "
-            "one of "
-            "100, 10000, 1000000"));
-      }
-    }
-    // Parse delay
-    ParseJsonObjectFieldAsDuration(json_object, "delay",
-                                   &fault_injection_policy.delay,
-                                   &sub_error_list, false);
-    // Parse delay_header
-    ParseJsonObjectField(json_object, "delayHeader",
-                         &fault_injection_policy.delay_header, &sub_error_list,
-                         false);
-    // Parse delay_percentage_header
-    ParseJsonObjectField(json_object, "delayPercentageHeader",
-                         &fault_injection_policy.delay_percentage_header,
-                         &sub_error_list, false);
-    // Parse delay_percentage_numerator
-    ParseJsonObjectField(json_object, "delayPercentageNumerator",
-                         &fault_injection_policy.delay_percentage_numerator,
-                         &sub_error_list, false);
-    // Parse delay_percentage_denominator
-    if (ParseJsonObjectField(
-            json_object, "delayPercentageDenominator",
-            &fault_injection_policy.delay_percentage_denominator,
-            &sub_error_list, false)) {
-      if (fault_injection_policy.delay_percentage_denominator != 100 &&
-          fault_injection_policy.delay_percentage_denominator != 10000 &&
-          fault_injection_policy.delay_percentage_denominator != 1000000) {
-        sub_error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:delayPercentageDenominator error:Denominator can only be "
-            "one of "
-            "100, 10000, 1000000"));
-      }
-    }
-    // Parse max_faults
-    static_assert(
-        std::is_unsigned<decltype(fault_injection_policy.max_faults)>::value,
-        "maxFaults should be unsigned");
-    ParseJsonObjectField(json_object, "maxFaults",
-                         &fault_injection_policy.max_faults, &sub_error_list,
-                         false);
-    if (!sub_error_list.empty()) {
-      error_list->push_back(GRPC_ERROR_CREATE_FROM_VECTOR_AND_CPP_STRING(
-          absl::StrCat("failed to parse faultInjectionPolicy index ", i),
-          &sub_error_list));
-    }
-    policies.push_back(std::move(fault_injection_policy));
-  }
-  return policies;
-}
-
-}  // namespace
-
-absl::StatusOr<std::unique_ptr<ServiceConfigParser::ParsedConfig>>
-FaultInjectionServiceConfigParser::ParsePerMethodParams(const ChannelArgs& args,
-                                                        const Json& json) {
-  // Only parse fault injection policy if the following channel arg is present.
-  if (!args.GetBool(GRPC_ARG_PARSE_FAULT_INJECTION_METHOD_CONFIG)
-           .value_or(false)) {
-    return nullptr;
-  }
-  // Parse fault injection policy from given Json
-  std::vector<FaultInjectionMethodParsedConfig::FaultInjectionPolicy>
-      fault_injection_policies;
-  std::vector<grpc_error_handle> error_list;
-  const Json::Array* policies_json_array;
-  if (ParseJsonObjectField(json.object_value(), "faultInjectionPolicy",
-                           &policies_json_array, &error_list)) {
-    fault_injection_policies =
-        ParseFaultInjectionPolicy(*policies_json_array, &error_list);
-  }
-  if (!error_list.empty()) {
-    grpc_error_handle error =
-        GRPC_ERROR_CREATE_FROM_VECTOR("Fault injection parser", &error_list);
-    absl::Status status = absl::InvalidArgumentError(
-        absl::StrCat("error parsing fault injection method parameters: ",
-                     grpc_error_std_string(error)));
-    GRPC_ERROR_UNREF(error);
-    return status;
-  }
-  if (fault_injection_policies.empty()) return nullptr;
-  return absl::make_unique<FaultInjectionMethodParsedConfig>(
-      std::move(fault_injection_policies));
-}
-
-void FaultInjectionServiceConfigParser::Register(
-    CoreConfiguration::Builder* builder) {
-  builder->service_config_parser()->RegisterParser(
-      absl::make_unique<FaultInjectionServiceConfigParser>());
-}
-
-size_t FaultInjectionServiceConfigParser::ParserIndex() {
-  return CoreConfiguration::Get().service_config_parser().GetParserIndex(
-      parser_name());
-}
-
-}  // namespace grpc_core

data/src/core/lib/event_engine/executor/threaded_executor.h

@@ -1,44 +0,0 @@
-// Copyright 2022 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_EVENT_ENGINE_EXECUTOR_THREADED_EXECUTOR_H
-#define GRPC_CORE_LIB_EVENT_ENGINE_EXECUTOR_THREADED_EXECUTOR_H
-
-#include <grpc/support/port_platform.h>
-
-#include "absl/functional/any_invocable.h"
-
-#include <grpc/event_engine/event_engine.h>
-
-#include "src/core/lib/event_engine/executor/executor.h"
-#include "src/core/lib/event_engine/thread_pool.h"
-
-namespace grpc_event_engine {
-namespace experimental {
-
-class ThreadedExecutor : public Executor {
- public:
-  explicit ThreadedExecutor(int reserve_threads);
-  ~ThreadedExecutor() override = default;
-  void Run(EventEngine::Closure* closure) override;
-  void Run(absl::AnyInvocable<void()> closure) override;
-
- private:
-  ThreadPool thread_pool_;
-};
-
-}  // namespace experimental
-}  // namespace grpc_event_engine
-
-#endif  // GRPC_CORE_LIB_EVENT_ENGINE_EXECUTOR_THREADED_EXECUTOR_H

data/src/core/lib/gpr/murmur_hash.cc

@@ -1,82 +0,0 @@
-/*
- *
- * 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>
-
-#include "src/core/lib/gpr/murmur_hash.h"
-
-#include <string.h>
-
-#include "absl/base/attributes.h"
-
-#define ROTL32(x, r) (((x) << (r)) | ((x) >> (32 - (r))))
-
-#define FMIX32(h)    \
-  (h) ^= (h) >> 16;  \
-  (h) *= 0x85ebca6b; \
-  (h) ^= (h) >> 13;  \
-  (h) *= 0xc2b2ae35; \
-  (h) ^= (h) >> 16;
-
-uint32_t gpr_murmur_hash3(const void* key, size_t len, uint32_t seed) {
-  uint32_t h1 = seed;
-  uint32_t k1;
-
-  const uint32_t c1 = 0xcc9e2d51;
-  const uint32_t c2 = 0x1b873593;
-
-  const uint8_t* keyptr = static_cast<const uint8_t*>(key);
-  const size_t bsize = sizeof(k1);
-  const size_t nblocks = len / bsize;
-
-  /* body */
-  for (size_t i = 0; i < nblocks; i++, keyptr += bsize) {
-    memcpy(&k1, keyptr, bsize);
-
-    k1 *= c1;
-    k1 = ROTL32(k1, 15);
-    k1 *= c2;
-
-    h1 ^= k1;
-    h1 = ROTL32(h1, 13);
-    h1 = h1 * 5 + 0xe6546b64;
-  }
-
-  k1 = 0;
-
-  /* tail */
-  switch (len & 3) {
-    case 3:
-      k1 ^= (static_cast<uint32_t>(keyptr[2])) << 16;
-      ABSL_FALLTHROUGH_INTENDED;
-    case 2:
-      k1 ^= (static_cast<uint32_t>(keyptr[1])) << 8;
-      ABSL_FALLTHROUGH_INTENDED;
-    case 1:
-      k1 ^= keyptr[0];
-      k1 *= c1;
-      k1 = ROTL32(k1, 15);
-      k1 *= c2;
-      h1 ^= k1;
-  };
-
-  /* finalization */
-  h1 ^= static_cast<uint32_t>(len);
-  FMIX32(h1);
-  return h1;
-}

data/src/core/lib/gpr/murmur_hash.h

@@ -1,29 +0,0 @@
-/*
- *
- * 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_GPR_MURMUR_HASH_H
-#define GRPC_CORE_LIB_GPR_MURMUR_HASH_H
-
-#include <grpc/support/port_platform.h>
-
-#include <stddef.h>
-
-/* compute the hash of key (length len) */
-uint32_t gpr_murmur_hash3(const void* key, size_t len, uint32_t seed);
-
-#endif /* GRPC_CORE_LIB_GPR_MURMUR_HASH_H */

data/src/core/lib/gpr/tls.h

@@ -1,156 +0,0 @@
-/*
- *
- * 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_GPR_TLS_H
-#define GRPC_CORE_LIB_GPR_TLS_H
-
-#include <grpc/support/port_platform.h>
-
-#include <type_traits>
-
-/** Thread local storage.
-
-   Usage is the same as C++ thread_local. Declaring a thread local:
-     static GPR_THREAD_LOCAL(uint32_t) foo;
-
-   ALL functions here may be implemented as macros. */
-
-namespace grpc_core {
-
-// This class is never instantiated. It exists to statically ensure that all
-// TLS usage is compatible with the most restrictive implementation, allowing
-// developers to write correct code regardless of the platform they develop on.
-template <typename T>
-class TlsTypeConstrainer {
-  static_assert(std::is_trivial<T>::value,
-                "TLS support is limited to trivial types");
-
- public:
-  using Type = T;
-};
-
-}  // namespace grpc_core
-
-#if defined(GPR_PTHREAD_TLS)
-
-#include <pthread.h>
-
-#include <algorithm>
-#include <array>
-#include <cstring>
-
-namespace grpc_core {
-
-template <typename T>
-class PthreadTlsImpl : TlsTypeConstrainer<T> {
- public:
-  PthreadTlsImpl(const PthreadTlsImpl&) = delete;
-  PthreadTlsImpl& operator=(const PthreadTlsImpl&) = delete;
-
-  // Achtung! This class emulates C++ `thread_local` using pthread keys. Each
-  // instance of this class is a stand in for a C++ `thread_local`. Think of
-  // each `thread_local` as a *global* pthread_key_t and a type tag. An
-  // important consequence of this is that the lifetime of a `pthread_key_t`
-  // is precisely the lifetime of an instance of this class. To understand why
-  // this is, consider the following scenario given a fictional implementation
-  // of this class which creates and destroys its `pthread_key_t` each time
-  // a given block of code runs (all actions take place on a single thread):
-  //
-  // - instance 1 (type tag = T*) is initialized, is assigned `pthread_key_t` 1
-  // - instance 2 (type tag = int) is initialized, is assigned `pthread_key_t` 2
-  // - instances 1 and 2 store and retrieve values; all is well
-  // - instances 1 and 2 are de-initialized; their keys are released to the pool
-  //
-  // - another run commences
-  // - instance 1 receives key 2
-  // - a value is read from instance 1, it observes a value of type int, but
-  //   interprets it as T*; undefined behavior, kaboom
-  //
-  // To properly ensure these invariants are upheld the `pthread_key_t` must be
-  // `const`, which means it can only be released in the destructor. This is a
-  // a violation of the style guide, since these objects are always static (see
-  // footnote) but this code is used in sufficiently narrow circumstances to
-  // justify the deviation.
-  //
-  // https://google.github.io/styleguide/cppguide.html#Static_and_Global_Variables
-  PthreadTlsImpl()
-      : keys_([]() {
-          typename std::remove_const<decltype(PthreadTlsImpl::keys_)>::type
-              keys;
-          for (pthread_key_t& key : keys) {
-            if (0 != pthread_key_create(&key, nullptr)) abort();
-          }
-          return keys;
-        }()) {}
-  PthreadTlsImpl(T t) : PthreadTlsImpl() { *this = t; }
-  ~PthreadTlsImpl() {
-    for (pthread_key_t key : keys_) {
-      if (0 != pthread_key_delete(key)) abort();
-    }
-  }
-
-  operator T() const {
-    T t;
-    char* dst = reinterpret_cast<char*>(&t);
-    for (pthread_key_t key : keys_) {
-      uintptr_t src = uintptr_t(pthread_getspecific(key));
-      size_t remaining = reinterpret_cast<char*>(&t + 1) - dst;
-      size_t step = std::min(sizeof(src), remaining);
-      memcpy(dst, &src, step);
-      dst += step;
-    }
-    return t;
-  }
-
-  T operator->() const {
-    static_assert(std::is_pointer<T>::value,
-                  "operator-> only usable on pointers");
-    return this->operator T();
-  }
-
-  T operator=(T t) {
-    char* src = reinterpret_cast<char*>(&t);
-    for (pthread_key_t key : keys_) {
-      uintptr_t dst;
-      size_t remaining = reinterpret_cast<char*>(&t + 1) - src;
-      size_t step = std::min(sizeof(dst), remaining);
-      memcpy(&dst, src, step);
-      if (0 != pthread_setspecific(key, reinterpret_cast<void*>(dst))) abort();
-      src += step;
-    }
-    return t;
-  }
-
- private:
-  const std::array<pthread_key_t,
-                   (sizeof(T) + sizeof(void*) - 1) / sizeof(void*)>
-      keys_;
-};
-
-}  // namespace grpc_core
-
-#define GPR_THREAD_LOCAL(type) grpc_core::PthreadTlsImpl<type>
-
-#else
-
-#define GPR_THREAD_LOCAL(type) \
-  thread_local typename grpc_core::TlsTypeConstrainer<type>::Type
-
-#endif
-
-#endif /* GRPC_CORE_LIB_GPR_TLS_H */

data/src/core/lib/promise/call_push_pull.h

@@ -1,148 +0,0 @@
-// Copyright 2022 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_PROMISE_CALL_PUSH_PULL_H
-#define GRPC_CORE_LIB_PROMISE_CALL_PUSH_PULL_H
-
-#include <grpc/support/port_platform.h>
-
-#include <assert.h>
-
-#include <type_traits>
-
-#include "absl/types/variant.h"
-
-#include "src/core/lib/gprpp/bitset.h"
-#include "src/core/lib/gprpp/construct_destruct.h"
-#include "src/core/lib/promise/detail/promise_like.h"
-#include "src/core/lib/promise/detail/status.h"
-#include "src/core/lib/promise/poll.h"
-
-namespace grpc_core {
-
-namespace promise_detail {
-
-template <typename FMain, typename FPush, typename FPull>
-class CallPushPull {
- public:
-  CallPushPull(FMain f_main, FPush f_push, FPull f_pull)
-      : push_(std::move(f_push)), pull_(std::move(f_pull)) {
-    Construct(&main_, std::move(f_main));
-  }
-
-  CallPushPull(const CallPushPull&) = delete;
-  CallPushPull& operator=(const CallPushPull&) = delete;
-  CallPushPull(CallPushPull&& other) noexcept
-      : done_(other.done_),
-        push_(std::move(other.push_)),
-        pull_(std::move(other.pull_)) {
-    assert(!done_.is_set(kDoneMain));
-    Construct(&main_, std::move(other.main_));
-  }
-
-  CallPushPull& operator=(CallPushPull&& other) noexcept {
-    assert(!done_.is_set(kDoneMain));
-    done_ = other.done_;
-    assert(!done_.is_set(kDoneMain));
-    push_ = std::move(other.push_);
-    main_ = std::move(other.main_);
-    pull_ = std::move(other.pull_);
-    return *this;
-  }
-
-  ~CallPushPull() {
-    if (done_.is_set(kDoneMain)) {
-      Destruct(&result_);
-    } else {
-      Destruct(&main_);
-    }
-  }
-
-  using Result =
-      typename PollTraits<decltype(std::declval<PromiseLike<FMain>>()())>::Type;
-
-  Poll<Result> operator()() {
-    if (!done_.is_set(kDonePush)) {
-      auto p = push_();
-      if (auto* status = absl::get_if<kPollReadyIdx>(&p)) {
-        if (IsStatusOk(*status)) {
-          done_.set(kDonePush);
-        } else {
-          return Result(std::move(*status));
-        }
-      }
-    }
-    if (!done_.is_set(kDoneMain)) {
-      auto p = main_();
-      if (auto* status = absl::get_if<kPollReadyIdx>(&p)) {
-        if (IsStatusOk(*status)) {
-          done_.set(kDoneMain);
-          Destruct(&main_);
-          Construct(&result_, std::move(*status));
-        } else {
-          return std::move(*status);
-        }
-      }
-    }
-    if (!done_.is_set(kDonePull)) {
-      auto p = pull_();
-      if (auto* status = absl::get_if<kPollReadyIdx>(&p)) {
-        if (IsStatusOk(*status)) {
-          done_.set(kDonePull);
-        } else {
-          return Result(std::move(*status));
-        }
-      }
-    }
-    if (done_.all()) return std::move(result_);
-    return Pending{};
-  }
-
- private:
-  enum { kDonePull = 0, kDoneMain = 1, kDonePush = 2 };
-  BitSet<3> done_;
-  GPR_NO_UNIQUE_ADDRESS PromiseLike<FPush> push_;
-  union {
-    PromiseLike<FMain> main_;
-    Result result_;
-  };
-  GPR_NO_UNIQUE_ADDRESS PromiseLike<FPull> pull_;
-};
-
-}  // namespace promise_detail
-
-// For promises representing calls a common pattern emerges:
-// There's a process pushing data down the stack, a process handling the main
-// call part, and a process pulling data back up the stack.
-//
-// This can reasonably be represented by the right combinations of TryJoins and
-// Maps, but since the structure is fundamental to the domain we introduce
-// this simple helper to make it easier to write the common case.
-//
-// It takes three promises: the main call, the push and the pull.
-// When polling, the push is polled first, then the main call (descending the
-// stack), then the pull (as we ascend once more).
-//
-// This strategy minimizes repolls.
-template <typename FMain, typename FPush, typename FPull>
-promise_detail::CallPushPull<FMain, FPush, FPull> CallPushPull(FMain f_main,
-                                                               FPush f_push,
-                                                               FPull f_pull) {
-  return promise_detail::CallPushPull<FMain, FPush, FPull>(
-      std::move(f_main), std::move(f_push), std::move(f_pull));
-}
-
-}  // namespace grpc_core
-
-#endif  // GRPC_CORE_LIB_PROMISE_CALL_PUSH_PULL_H

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

@@ -1,39 +0,0 @@
-/*
- *
- * 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>
-
-#include <grpc/slice.h>
-
-#include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/slice/slice_refcount.h"
-
-/* Public API */
-grpc_slice grpc_slice_ref(grpc_slice slice) {
-  return grpc_slice_ref_internal(slice);
-}
-
-/* Public API */
-void grpc_slice_unref(grpc_slice slice) {
-  if (grpc_core::ExecCtx::Get() == nullptr) {
-    grpc_core::ExecCtx exec_ctx;
-    grpc_slice_unref_internal(slice);
-  } else {
-    grpc_slice_unref_internal(slice);
-  }
-}