grpc 1.40.0.pre1 → 1.42.0.pre1

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_ev_driver_libuv.cc

@@ -1,179 +0,0 @@
-/*
- *
- * Copyright 2019 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/iomgr/port.h"
-#if GRPC_ARES == 1 && defined(GRPC_UV)
-
-#include "absl/strings/str_format.h"
-
-#include <ares.h>
-#include <uv.h>
-
-#include "src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_ev_driver.h"
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
-#include <grpc/support/time.h>
-#include "src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/iomgr/work_serializer.h"
-
-namespace grpc_core {
-
-void ares_uv_poll_cb(uv_poll_t* handle, int status, int events);
-
-void ares_uv_poll_close_cb(uv_handle_t* handle) { delete handle; }
-
-class GrpcPolledFdLibuv : public GrpcPolledFd {
- public:
-  GrpcPolledFdLibuv(ares_socket_t as,
-                    std::shared_ptr<WorkSerializer> work_serializer)
-      : name_(absl::StrFormat("c-ares socket: %" PRIdPTR, (intptr_t)as)),
-        as_(as),
-        work_serializer_(std::move(work_serializer)) {
-    handle_ = new uv_poll_t();
-    uv_poll_init_socket(uv_default_loop(), handle_, as);
-    handle_->data = this;
-  }
-
-  void RegisterForOnReadableLocked(grpc_closure* read_closure) override {
-    GPR_ASSERT(read_closure_ == nullptr);
-    GPR_ASSERT((poll_events_ & UV_READABLE) == 0);
-    read_closure_ = read_closure;
-    poll_events_ |= UV_READABLE;
-    uv_poll_start(handle_, poll_events_, ares_uv_poll_cb);
-  }
-
-  void RegisterForOnWriteableLocked(grpc_closure* write_closure) override {
-    GPR_ASSERT(write_closure_ == nullptr);
-    GPR_ASSERT((poll_events_ & UV_WRITABLE) == 0);
-    write_closure_ = write_closure;
-    poll_events_ |= UV_WRITABLE;
-    uv_poll_start(handle_, poll_events_, ares_uv_poll_cb);
-  }
-
-  bool IsFdStillReadableLocked() override {
-    /* uv_poll_t is based on poll, which is level triggered. So, if cares
-     * leaves some data unread, the event will trigger again. */
-    return false;
-  }
-
-  void ShutdownInternalLocked(grpc_error_handle error) {
-    uv_poll_stop(handle_);
-    uv_close(reinterpret_cast<uv_handle_t*>(handle_), ares_uv_poll_close_cb);
-    if (read_closure_ != nullptr) {
-      grpc_core::ExecCtx::Run(DEBUG_LOCATION, read_closure_,
-                              GRPC_ERROR_CANCELLED);
-    }
-    if (write_closure_ != nullptr) {
-      grpc_core::ExecCtx::Run(DEBUG_LOCATION, write_closure_,
-                              GRPC_ERROR_CANCELLED);
-    }
-  }
-
-  void ShutdownLocked(grpc_error_handle error) override {
-    if (grpc_core::ExecCtx::Get() == nullptr) {
-      grpc_core::ExecCtx exec_ctx;
-      ShutdownInternalLocked(error);
-    } else {
-      ShutdownInternalLocked(error);
-    }
-  }
-
-  ares_socket_t GetWrappedAresSocketLocked() override { return as_; }
-
-  const char* GetName() override { return name_.c_str(); }
-
-  // TODO(apolcyn): Data members should be private.
-  std::string name_;
-  ares_socket_t as_;
-  uv_poll_t* handle_;
-  grpc_closure* read_closure_ = nullptr;
-  grpc_closure* write_closure_ = nullptr;
-  int poll_events_ = 0;
-  std::shared_ptr<WorkSerializer> work_serializer_;
-};
-
-struct AresUvPollCbArg {
-  AresUvPollCbArg(uv_poll_t* handle, int status, int events)
-      : handle(handle), status(status), events(events) {}
-
-  uv_poll_t* handle;
-  int status;
-  int events;
-};
-
-static void ares_uv_poll_cb_locked(AresUvPollCbArg* arg) {
-  std::unique_ptr<AresUvPollCbArg> arg_struct(arg);
-  uv_poll_t* handle = arg_struct->handle;
-  int status = arg_struct->status;
-  int events = arg_struct->events;
-  GrpcPolledFdLibuv* polled_fd =
-      reinterpret_cast<GrpcPolledFdLibuv*>(handle->data);
-  grpc_error_handle error = GRPC_ERROR_NONE;
-  if (status < 0) {
-    error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("cares polling error");
-    error =
-        grpc_error_set_str(error, GRPC_ERROR_STR_OS_ERROR,
-                           grpc_slice_from_static_string(uv_strerror(status)));
-  }
-  if (events & UV_READABLE) {
-    GPR_ASSERT(polled_fd->read_closure_ != nullptr);
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, polled_fd->read_closure_, error);
-    polled_fd->read_closure_ = nullptr;
-    polled_fd->poll_events_ &= ~UV_READABLE;
-  }
-  if (events & UV_WRITABLE) {
-    GPR_ASSERT(polled_fd->write_closure_ != nullptr);
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, polled_fd->write_closure_, error);
-    polled_fd->write_closure_ = nullptr;
-    polled_fd->poll_events_ &= ~UV_WRITABLE;
-  }
-  uv_poll_start(handle, polled_fd->poll_events_, ares_uv_poll_cb);
-}
-
-void ares_uv_poll_cb(uv_poll_t* handle, int status, int events) {
-  grpc_core::ExecCtx exec_ctx;
-  GrpcPolledFdLibuv* polled_fd =
-      reinterpret_cast<GrpcPolledFdLibuv*>(handle->data);
-  AresUvPollCbArg* arg = new AresUvPollCbArg(handle, status, events);
-  polled_fd->work_serializer_->Run([arg]() { ares_uv_poll_cb_locked(arg); },
-                                   DEBUG_LOCATION);
-}
-
-class GrpcPolledFdFactoryLibuv : public GrpcPolledFdFactory {
- public:
-  GrpcPolledFd* NewGrpcPolledFdLocked(
-      ares_socket_t as, grpc_pollset_set* driver_pollset_set,
-      std::shared_ptr<WorkSerializer> work_serializer) override {
-    return new GrpcPolledFdLibuv(as, std::move(work_serializer));
-  }
-
-  void ConfigureAresChannelLocked(ares_channel channel) override {}
-};
-
-std::unique_ptr<GrpcPolledFdFactory> NewGrpcPolledFdFactory(
-    std::shared_ptr<WorkSerializer> work_serializer) {
-  return absl::make_unique<GrpcPolledFdFactoryLibuv>();
-}
-
-}  // namespace grpc_core
-
-#endif /* GRPC_ARES == 1 && defined(GRPC_UV) */

data/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper_libuv.cc

@@ -1,38 +0,0 @@
-/*
- *
- * 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>
-
-#include "src/core/lib/iomgr/port.h"
-#if GRPC_ARES == 1 && defined(GRPC_UV)
-
-#include <grpc/support/string_util.h>
-
-#include "src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.h"
-#include "src/core/ext/filters/client_channel/server_address.h"
-#include "src/core/lib/address_utils/parse_address.h"
-#include "src/core/lib/gpr/string.h"
-
-bool grpc_ares_query_ipv6() {
-  /* The libuv grpc code currently does not have the code to probe for this,
-   * so we assume for now that IPv6 is always available in contexts where this
-   * code will be used. */
-  return true;
-}
-
-#endif /* GRPC_ARES == 1 && defined(GRPC_UV) */

data/src/core/ext/filters/client_channel/service_config_call_data.h

@@ -1,126 +0,0 @@
-//
-// 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_EXT_FILTERS_CLIENT_CHANNEL_SERVICE_CONFIG_CALL_DATA_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SERVICE_CONFIG_CALL_DATA_H
-
-#include <grpc/support/port_platform.h>
-
-#include <map>
-
-#include "absl/strings/string_view.h"
-
-#include "src/core/ext/filters/client_channel/config_selector.h"
-#include "src/core/ext/filters/client_channel/service_config.h"
-#include "src/core/ext/filters/client_channel/service_config_parser.h"
-#include "src/core/lib/channel/context.h"
-#include "src/core/lib/gprpp/ref_counted_ptr.h"
-
-namespace grpc_core {
-
-/// When a service config is applied to a call in the client_channel_filter,
-/// we create an instance of this object on the arena.  A pointer to this
-/// object is also stored in the call_context, so that future filters can
-/// easily access method and global parameters for the call.
-class ServiceConfigCallData {
- public:
-  ServiceConfigCallData(
-      RefCountedPtr<ServiceConfig> service_config,
-      const ServiceConfigParser::ParsedConfigVector* method_configs,
-      ConfigSelector::CallAttributes call_attributes,
-      ConfigSelector::CallDispatchController* call_dispatch_controller,
-      grpc_call_context_element* call_context)
-      : service_config_(std::move(service_config)),
-        method_configs_(method_configs),
-        call_attributes_(std::move(call_attributes)),
-        call_dispatch_controller_(call_dispatch_controller) {
-    call_context[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].value = this;
-    call_context[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].destroy = Destroy;
-  }
-
-  ServiceConfigCallData(
-      RefCountedPtr<ServiceConfig> service_config,
-      const ServiceConfigParser::ParsedConfigVector* method_configs,
-      grpc_call_context_element* call_context)
-      : ServiceConfigCallData(std::move(service_config), method_configs, {},
-                              nullptr, call_context) {}
-
-  ServiceConfig* service_config() { return service_config_.get(); }
-
-  ServiceConfigParser::ParsedConfig* GetMethodParsedConfig(size_t index) const {
-    return method_configs_ != nullptr ? (*method_configs_)[index].get()
-                                      : nullptr;
-  }
-
-  ServiceConfigParser::ParsedConfig* GetGlobalParsedConfig(size_t index) const {
-    return service_config_->GetGlobalParsedConfig(index);
-  }
-
-  const std::map<const char*, absl::string_view>& call_attributes() const {
-    return call_attributes_;
-  }
-
-  ConfigSelector::CallDispatchController* call_dispatch_controller() {
-    return &call_dispatch_controller_;
-  }
-
- private:
-  // A wrapper for the CallDispatchController returned by the ConfigSelector.
-  // Handles the case where the ConfigSelector doees not return any
-  // CallDispatchController.
-  // Also ensures that we call Commit() at most once, which allows the
-  // client channel code to call Commit() when the call is complete in case
-  // it wasn't called earlier, without needing to know whether or not it was.
-  class SingleCommitCallDispatchController
-      : public ConfigSelector::CallDispatchController {
-   public:
-    explicit SingleCommitCallDispatchController(
-        ConfigSelector::CallDispatchController* call_dispatch_controller)
-        : call_dispatch_controller_(call_dispatch_controller) {}
-
-    bool ShouldRetry() override {
-      if (call_dispatch_controller_ != nullptr) {
-        return call_dispatch_controller_->ShouldRetry();
-      }
-      return true;
-    }
-
-    void Commit() override {
-      if (call_dispatch_controller_ != nullptr && !commit_called_) {
-        call_dispatch_controller_->Commit();
-        commit_called_ = true;
-      }
-    }
-
-   private:
-    ConfigSelector::CallDispatchController* call_dispatch_controller_;
-    bool commit_called_ = false;
-  };
-
-  static void Destroy(void* ptr) {
-    ServiceConfigCallData* self = static_cast<ServiceConfigCallData*>(ptr);
-    self->~ServiceConfigCallData();
-  }
-
-  RefCountedPtr<ServiceConfig> service_config_;
-  const ServiceConfigParser::ParsedConfigVector* method_configs_;
-  ConfigSelector::CallAttributes call_attributes_;
-  SingleCommitCallDispatchController call_dispatch_controller_;
-};
-
-}  // namespace grpc_core
-
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SERVICE_CONFIG_CALL_DATA_H */

data/src/core/ext/filters/workarounds/workaround_cronet_compression_filter.cc

@@ -1,211 +0,0 @@
-//
-// Copyright 2017 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/workarounds/workaround_cronet_compression_filter.h"
-
-#include <string.h>
-
-#include <grpc/support/alloc.h>
-
-#include "src/core/ext/filters/workarounds/workaround_utils.h"
-#include "src/core/lib/channel/channel_stack_builder.h"
-#include "src/core/lib/surface/channel_init.h"
-#include "src/core/lib/transport/metadata.h"
-
-namespace {
-struct call_data {
-  // Receive closures are chained: we inject this closure as the
-  // recv_initial_metadata_ready up-call on transport_stream_op, and remember to
-  // call our next_recv_initial_metadata_ready member after handling it.
-  grpc_closure recv_initial_metadata_ready;
-  // Used by recv_initial_metadata_ready.
-  grpc_metadata_batch* recv_initial_metadata;
-  // Original recv_initial_metadata_ready callback, invoked after our own.
-  grpc_closure* next_recv_initial_metadata_ready;
-
-  // Marks whether the workaround is active
-  bool workaround_active;
-};
-}  // namespace
-
-// Find the user agent metadata element in the batch
-static bool get_user_agent_mdelem(const grpc_metadata_batch* batch,
-                                  grpc_mdelem* md) {
-  if (batch->idx.named.user_agent != nullptr) {
-    *md = batch->idx.named.user_agent->md;
-    return true;
-  }
-  return false;
-}
-
-// Callback invoked when we receive an initial metadata.
-static void recv_initial_metadata_ready(void* user_data,
-                                        grpc_error_handle error) {
-  grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-
-  if (GRPC_ERROR_NONE == error) {
-    grpc_mdelem md;
-    if (get_user_agent_mdelem(calld->recv_initial_metadata, &md)) {
-      grpc_workaround_user_agent_md* user_agent_md = grpc_parse_user_agent(md);
-      if (user_agent_md
-              ->workaround_active[GRPC_WORKAROUND_ID_CRONET_COMPRESSION]) {
-        calld->workaround_active = true;
-      }
-    }
-  }
-
-  // Invoke the next callback.
-  grpc_core::Closure::Run(DEBUG_LOCATION,
-                          calld->next_recv_initial_metadata_ready,
-                          GRPC_ERROR_REF(error));
-}
-
-// Start transport stream op.
-static void cronet_compression_start_transport_stream_op_batch(
-    grpc_call_element* elem, grpc_transport_stream_op_batch* op) {
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-
-  // Inject callback for receiving initial metadata
-  if (op->recv_initial_metadata) {
-    calld->next_recv_initial_metadata_ready =
-        op->payload->recv_initial_metadata.recv_initial_metadata_ready;
-    op->payload->recv_initial_metadata.recv_initial_metadata_ready =
-        &calld->recv_initial_metadata_ready;
-    calld->recv_initial_metadata =
-        op->payload->recv_initial_metadata.recv_initial_metadata;
-  }
-
-  if (op->send_message) {
-    /* Send message happens after client's user-agent (initial metadata) is
-     * received, so workaround_active must be set already */
-    if (calld->workaround_active) {
-      op->payload->send_message.send_message->set_flags(
-          op->payload->send_message.send_message->flags() |
-          GRPC_WRITE_NO_COMPRESS);
-    }
-  }
-
-  // Chain to the next filter.
-  grpc_call_next_op(elem, op);
-}
-
-// Constructor for call_data.
-static grpc_error_handle cronet_compression_init_call_elem(
-    grpc_call_element* elem, const grpc_call_element_args* /*args*/) {
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  calld->next_recv_initial_metadata_ready = nullptr;
-  calld->workaround_active = false;
-  GRPC_CLOSURE_INIT(&calld->recv_initial_metadata_ready,
-                    recv_initial_metadata_ready, elem,
-                    grpc_schedule_on_exec_ctx);
-  return GRPC_ERROR_NONE;
-}
-
-// Destructor for call_data.
-static void cronet_compression_destroy_call_elem(
-    grpc_call_element* /*elem*/, const grpc_call_final_info* /*final_info*/,
-    grpc_closure* /*ignored*/) {}
-
-// Constructor for channel_data.
-static grpc_error_handle cronet_compression_init_channel_elem(
-    grpc_channel_element* /*elem*/, grpc_channel_element_args* /*args*/) {
-  return GRPC_ERROR_NONE;
-}
-
-// Destructor for channel_data.
-static void cronet_compression_destroy_channel_elem(
-    grpc_channel_element* /*elem*/) {}
-
-// Parse the user agent
-static bool parse_user_agent(grpc_mdelem md) {
-  const char grpc_objc_specifier[] = "grpc-objc/";
-  const size_t grpc_objc_specifier_len = sizeof(grpc_objc_specifier) - 1;
-  const char cronet_specifier[] = "cronet_http";
-  const size_t cronet_specifier_len = sizeof(cronet_specifier) - 1;
-
-  char* user_agent_str = grpc_slice_to_c_string(GRPC_MDVALUE(md));
-  bool grpc_objc_specifier_seen = false;
-  bool cronet_specifier_seen = false;
-  char *major_version_str = user_agent_str, *minor_version_str;
-  long major_version = 0, minor_version = 0;
-
-  char* head = strtok(user_agent_str, " ");
-  while (head != nullptr) {
-    if (!grpc_objc_specifier_seen &&
-        0 == strncmp(head, grpc_objc_specifier, grpc_objc_specifier_len)) {
-      major_version_str = head + grpc_objc_specifier_len;
-      grpc_objc_specifier_seen = true;
-    } else if (grpc_objc_specifier_seen &&
-               0 == strncmp(head, cronet_specifier, cronet_specifier_len)) {
-      cronet_specifier_seen = true;
-      break;
-    }
-
-    head = strtok(nullptr, " ");
-  }
-  if (grpc_objc_specifier_seen) {
-    major_version_str = strtok(major_version_str, ".");
-    minor_version_str = strtok(nullptr, ".");
-    major_version = atol(major_version_str);
-    minor_version = atol(minor_version_str);
-  }
-
-  gpr_free(user_agent_str);
-  return (grpc_objc_specifier_seen && cronet_specifier_seen &&
-          (major_version < 1 || (major_version == 1 && minor_version <= 3)));
-}
-
-const grpc_channel_filter grpc_workaround_cronet_compression_filter = {
-    cronet_compression_start_transport_stream_op_batch,
-    grpc_channel_next_op,
-    sizeof(call_data),
-    cronet_compression_init_call_elem,
-    grpc_call_stack_ignore_set_pollset_or_pollset_set,
-    cronet_compression_destroy_call_elem,
-    0,
-    cronet_compression_init_channel_elem,
-    cronet_compression_destroy_channel_elem,
-    grpc_channel_next_get_info,
-    "workaround_cronet_compression"};
-
-static bool register_workaround_cronet_compression(
-    grpc_channel_stack_builder* builder, void* /*arg*/) {
-  const grpc_channel_args* channel_args =
-      grpc_channel_stack_builder_get_channel_arguments(builder);
-  const grpc_arg* a = grpc_channel_args_find(
-      channel_args, GRPC_ARG_WORKAROUND_CRONET_COMPRESSION);
-  if (a == nullptr) {
-    return true;
-  }
-  if (!grpc_channel_arg_get_bool(a, false)) {
-    return true;
-  }
-  return grpc_channel_stack_builder_prepend_filter(
-      builder, &grpc_workaround_cronet_compression_filter, nullptr, nullptr);
-}
-
-void grpc_workaround_cronet_compression_filter_init(void) {
-  grpc_channel_init_register_stage(
-      GRPC_SERVER_CHANNEL, GRPC_WORKAROUND_PRIORITY_HIGH,
-      register_workaround_cronet_compression, nullptr);
-  grpc_register_workaround(GRPC_WORKAROUND_ID_CRONET_COMPRESSION,
-                           parse_user_agent);
-}
-
-void grpc_workaround_cronet_compression_filter_shutdown(void) {}

data/src/core/ext/filters/workarounds/workaround_utils.cc

@@ -1,53 +0,0 @@
-//
-// Copyright 2017 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/workarounds/workaround_utils.h"
-
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-
-user_agent_parser ua_parser[GRPC_MAX_WORKAROUND_ID];
-
-static void destroy_user_agent_md(void* user_agent_md) {
-  gpr_free(user_agent_md);
-}
-
-grpc_workaround_user_agent_md* grpc_parse_user_agent(grpc_mdelem md) {
-  grpc_workaround_user_agent_md* user_agent_md =
-      static_cast<grpc_workaround_user_agent_md*>(
-          grpc_mdelem_get_user_data(md, destroy_user_agent_md));
-
-  if (nullptr != user_agent_md) {
-    return user_agent_md;
-  }
-  user_agent_md = static_cast<grpc_workaround_user_agent_md*>(
-      gpr_malloc(sizeof(grpc_workaround_user_agent_md)));
-  for (int i = 0; i < GRPC_MAX_WORKAROUND_ID; i++) {
-    if (ua_parser[i]) {
-      user_agent_md->workaround_active[i] = ua_parser[i](md);
-    }
-  }
-  grpc_mdelem_set_user_data(md, destroy_user_agent_md, user_agent_md);
-
-  return user_agent_md;
-}
-
-void grpc_register_workaround(uint32_t id, user_agent_parser parser) {
-  GPR_ASSERT(id < GRPC_MAX_WORKAROUND_ID);
-  ua_parser[id] = parser;
-}

data/src/core/ext/filters/workarounds/workaround_utils.h

@@ -1,39 +0,0 @@
-//
-// Copyright 2017 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_EXT_FILTERS_WORKAROUNDS_WORKAROUND_UTILS_H
-#define GRPC_CORE_EXT_FILTERS_WORKAROUNDS_WORKAROUND_UTILS_H
-
-#include <grpc/support/port_platform.h>
-
-#include <grpc/support/workaround_list.h>
-
-#include "src/core/lib/transport/metadata.h"
-
-#define GRPC_WORKAROUND_PRIORITY_HIGH 10001
-#define GRPC_WORKAROUND_PROIRITY_LOW 9999
-
-typedef struct grpc_workaround_user_agent_md {
-  bool workaround_active[GRPC_MAX_WORKAROUND_ID];
-} grpc_workaround_user_agent_md;
-
-grpc_workaround_user_agent_md* grpc_parse_user_agent(grpc_mdelem md);
-
-typedef bool (*user_agent_parser)(grpc_mdelem);
-
-void grpc_register_workaround(uint32_t id, user_agent_parser parser);
-
-#endif /* GRPC_CORE_EXT_FILTERS_WORKAROUNDS_WORKAROUND_UTILS_H */

data/src/core/ext/transport/chttp2/client/authority.cc

@@ -1,42 +0,0 @@
-/*
- *
- * Copyright 2018 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/transport/chttp2/client/authority.h"
-
-grpc_channel_args* grpc_default_authority_add_if_not_present(
-    const grpc_channel_args* args) {
-  const bool has_default_authority =
-      grpc_channel_args_find(args, GRPC_ARG_DEFAULT_AUTHORITY) != nullptr;
-  grpc_arg new_args[1];
-  size_t num_new_args = 0;
-  std::string default_authority;
-  if (!has_default_authority) {
-    const grpc_arg* server_uri_arg =
-        grpc_channel_args_find(args, GRPC_ARG_SERVER_URI);
-    const char* server_uri_str = grpc_channel_arg_get_string(server_uri_arg);
-    GPR_ASSERT(server_uri_str != nullptr);
-    default_authority =
-        grpc_core::ResolverRegistry::GetDefaultAuthority(server_uri_str);
-    new_args[num_new_args++] = grpc_channel_arg_string_create(
-        const_cast<char*>(GRPC_ARG_DEFAULT_AUTHORITY),
-        const_cast<char*>(default_authority.c_str()));
-  }
-  return grpc_channel_args_copy_and_add(args, new_args, num_new_args);
-}