grpc 1.25.0 → 1.26.0.pre1

data/src/core/ext/filters/client_channel/http_proxy.cc

@@ -36,13 +36,16 @@
 #include "src/core/lib/slice/b64.h"
 #include "src/core/lib/uri/uri_parser.h"
 
+namespace grpc_core {
+namespace {
+
 /**
  * Parses the 'https_proxy' env var (fallback on 'http_proxy') and returns the
  * proxy hostname to resolve or nullptr on error. Also sets 'user_cred' to user
  * credentials if present in the 'http_proxy' env var, otherwise leaves it
  * unchanged. It is caller's responsibility to gpr_free user_cred.
  */
-static char* get_http_proxy_server(char** user_cred) {
+char* GetHttpProxyServer(char** user_cred) {
   GPR_ASSERT(user_cred != nullptr);
   char* proxy_name = nullptr;
   char** authority_strs = nullptr;
@@ -89,127 +92,115 @@ done:
   return proxy_name;
 }
 
-/**
- * Checks the value of GRPC_ARG_ENABLE_HTTP_PROXY to determine if http_proxy
- * should be used.
- */
-bool http_proxy_enabled(const grpc_channel_args* args) {
-  const grpc_arg* arg =
-      grpc_channel_args_find(args, GRPC_ARG_ENABLE_HTTP_PROXY);
-  return grpc_channel_arg_get_bool(arg, true);
-}
-
-static bool proxy_mapper_map_name(grpc_proxy_mapper* mapper,
-                                  const char* server_uri,
-                                  const grpc_channel_args* args,
-                                  char** name_to_resolve,
-                                  grpc_channel_args** new_args) {
-  if (!http_proxy_enabled(args)) {
-    return false;
-  }
-  char* user_cred = nullptr;
-  *name_to_resolve = get_http_proxy_server(&user_cred);
-  if (*name_to_resolve == nullptr) return false;
-  char* no_proxy_str = nullptr;
-  grpc_uri* uri = grpc_uri_parse(server_uri, false /* suppress_errors */);
-  if (uri == nullptr || uri->path[0] == '\0') {
-    gpr_log(GPR_ERROR,
-            "'http_proxy' environment variable set, but cannot "
-            "parse server URI '%s' -- not using proxy",
-            server_uri);
-    goto no_use_proxy;
-  }
-  if (strcmp(uri->scheme, "unix") == 0) {
-    gpr_log(GPR_INFO, "not using proxy for Unix domain socket '%s'",
-            server_uri);
-    goto no_use_proxy;
-  }
-  /* Prefer using 'no_grpc_proxy'. Fallback on 'no_proxy' if it is not set. */
-  no_proxy_str = gpr_getenv("no_grpc_proxy");
-  if (no_proxy_str == nullptr) no_proxy_str = gpr_getenv("no_proxy");
-  if (no_proxy_str != nullptr) {
-    static const char* NO_PROXY_SEPARATOR = ",";
-    bool use_proxy = true;
-    grpc_core::UniquePtr<char> server_host;
-    grpc_core::UniquePtr<char> server_port;
-    if (!grpc_core::SplitHostPort(
-            uri->path[0] == '/' ? uri->path + 1 : uri->path, &server_host,
-            &server_port)) {
-      gpr_log(GPR_INFO,
-              "unable to split host and port, not checking no_proxy list for "
-              "host '%s'",
+class HttpProxyMapper : public ProxyMapperInterface {
+ public:
+  bool MapName(const char* server_uri, const grpc_channel_args* args,
+               char** name_to_resolve, grpc_channel_args** new_args) override {
+    if (!grpc_channel_args_find_bool(args, GRPC_ARG_ENABLE_HTTP_PROXY, true)) {
+      return false;
+    }
+    char* user_cred = nullptr;
+    *name_to_resolve = GetHttpProxyServer(&user_cred);
+    if (*name_to_resolve == nullptr) return false;
+    char* no_proxy_str = nullptr;
+    grpc_uri* uri = grpc_uri_parse(server_uri, false /* suppress_errors */);
+    if (uri == nullptr || uri->path[0] == '\0') {
+      gpr_log(GPR_ERROR,
+              "'http_proxy' environment variable set, but cannot "
+              "parse server URI '%s' -- not using proxy",
               server_uri);
-      gpr_free(no_proxy_str);
-    } else {
-      size_t uri_len = strlen(server_host.get());
-      char** no_proxy_hosts;
-      size_t num_no_proxy_hosts;
-      gpr_string_split(no_proxy_str, NO_PROXY_SEPARATOR, &no_proxy_hosts,
-                       &num_no_proxy_hosts);
-      for (size_t i = 0; i < num_no_proxy_hosts; i++) {
-        char* no_proxy_entry = no_proxy_hosts[i];
-        size_t no_proxy_len = strlen(no_proxy_entry);
-        if (no_proxy_len <= uri_len &&
-            gpr_stricmp(no_proxy_entry,
-                        &(server_host.get()[uri_len - no_proxy_len])) == 0) {
-          gpr_log(GPR_INFO, "not using proxy for host in no_proxy list '%s'",
-                  server_uri);
-          use_proxy = false;
-          break;
+      goto no_use_proxy;
+    }
+    if (strcmp(uri->scheme, "unix") == 0) {
+      gpr_log(GPR_INFO, "not using proxy for Unix domain socket '%s'",
+              server_uri);
+      goto no_use_proxy;
+    }
+    /* Prefer using 'no_grpc_proxy'. Fallback on 'no_proxy' if it is not set. */
+    no_proxy_str = gpr_getenv("no_grpc_proxy");
+    if (no_proxy_str == nullptr) no_proxy_str = gpr_getenv("no_proxy");
+    if (no_proxy_str != nullptr) {
+      static const char* NO_PROXY_SEPARATOR = ",";
+      bool use_proxy = true;
+      grpc_core::UniquePtr<char> server_host;
+      grpc_core::UniquePtr<char> server_port;
+      if (!grpc_core::SplitHostPort(
+              uri->path[0] == '/' ? uri->path + 1 : uri->path, &server_host,
+              &server_port)) {
+        gpr_log(GPR_INFO,
+                "unable to split host and port, not checking no_proxy list for "
+                "host '%s'",
+                server_uri);
+        gpr_free(no_proxy_str);
+      } else {
+        size_t uri_len = strlen(server_host.get());
+        char** no_proxy_hosts;
+        size_t num_no_proxy_hosts;
+        gpr_string_split(no_proxy_str, NO_PROXY_SEPARATOR, &no_proxy_hosts,
+                         &num_no_proxy_hosts);
+        for (size_t i = 0; i < num_no_proxy_hosts; i++) {
+          char* no_proxy_entry = no_proxy_hosts[i];
+          size_t no_proxy_len = strlen(no_proxy_entry);
+          if (no_proxy_len <= uri_len &&
+              gpr_stricmp(no_proxy_entry,
+                          &(server_host.get()[uri_len - no_proxy_len])) == 0) {
+            gpr_log(GPR_INFO, "not using proxy for host in no_proxy list '%s'",
+                    server_uri);
+            use_proxy = false;
+            break;
+          }
         }
+        for (size_t i = 0; i < num_no_proxy_hosts; i++) {
+          gpr_free(no_proxy_hosts[i]);
+        }
+        gpr_free(no_proxy_hosts);
+        gpr_free(no_proxy_str);
+        if (!use_proxy) goto no_use_proxy;
       }
-      for (size_t i = 0; i < num_no_proxy_hosts; i++) {
-        gpr_free(no_proxy_hosts[i]);
-      }
-      gpr_free(no_proxy_hosts);
-      gpr_free(no_proxy_str);
-      if (!use_proxy) goto no_use_proxy;
     }
+    grpc_arg args_to_add[2];
+    args_to_add[0] = grpc_channel_arg_string_create(
+        (char*)GRPC_ARG_HTTP_CONNECT_SERVER,
+        uri->path[0] == '/' ? uri->path + 1 : uri->path);
+    if (user_cred != nullptr) {
+      /* Use base64 encoding for user credentials as stated in RFC 7617 */
+      char* encoded_user_cred =
+          grpc_base64_encode(user_cred, strlen(user_cred), 0, 0);
+      char* header;
+      gpr_asprintf(&header, "Proxy-Authorization:Basic %s", encoded_user_cred);
+      gpr_free(encoded_user_cred);
+      args_to_add[1] = grpc_channel_arg_string_create(
+          (char*)GRPC_ARG_HTTP_CONNECT_HEADERS, header);
+      *new_args = grpc_channel_args_copy_and_add(args, args_to_add, 2);
+      gpr_free(header);
+    } else {
+      *new_args = grpc_channel_args_copy_and_add(args, args_to_add, 1);
+    }
+    grpc_uri_destroy(uri);
+    gpr_free(user_cred);
+    return true;
+  no_use_proxy:
+    if (uri != nullptr) grpc_uri_destroy(uri);
+    gpr_free(*name_to_resolve);
+    *name_to_resolve = nullptr;
+    gpr_free(user_cred);
+    return false;
   }
-  grpc_arg args_to_add[2];
-  args_to_add[0] = grpc_channel_arg_string_create(
-      (char*)GRPC_ARG_HTTP_CONNECT_SERVER,
-      uri->path[0] == '/' ? uri->path + 1 : uri->path);
-  if (user_cred != nullptr) {
-    /* Use base64 encoding for user credentials as stated in RFC 7617 */
-    char* encoded_user_cred =
-        grpc_base64_encode(user_cred, strlen(user_cred), 0, 0);
-    char* header;
-    gpr_asprintf(&header, "Proxy-Authorization:Basic %s", encoded_user_cred);
-    gpr_free(encoded_user_cred);
-    args_to_add[1] = grpc_channel_arg_string_create(
-        (char*)GRPC_ARG_HTTP_CONNECT_HEADERS, header);
-    *new_args = grpc_channel_args_copy_and_add(args, args_to_add, 2);
-    gpr_free(header);
-  } else {
-    *new_args = grpc_channel_args_copy_and_add(args, args_to_add, 1);
-  }
-  grpc_uri_destroy(uri);
-  gpr_free(user_cred);
-  return true;
-no_use_proxy:
-  if (uri != nullptr) grpc_uri_destroy(uri);
-  gpr_free(*name_to_resolve);
-  *name_to_resolve = nullptr;
-  gpr_free(user_cred);
-  return false;
-}
-
-static bool proxy_mapper_map_address(grpc_proxy_mapper* mapper,
-                                     const grpc_resolved_address* address,
-                                     const grpc_channel_args* args,
-                                     grpc_resolved_address** new_address,
-                                     grpc_channel_args** new_args) {
-  return false;
-}
-
-static void proxy_mapper_destroy(grpc_proxy_mapper* mapper) {}
 
-static const grpc_proxy_mapper_vtable proxy_mapper_vtable = {
-    proxy_mapper_map_name, proxy_mapper_map_address, proxy_mapper_destroy};
+  bool MapAddress(const grpc_resolved_address& address,
+                  const grpc_channel_args* args,
+                  grpc_resolved_address** new_address,
+                  grpc_channel_args** new_args) override {
+    return false;
+  }
+};
 
-static grpc_proxy_mapper proxy_mapper = {&proxy_mapper_vtable};
+}  // namespace
 
-void grpc_register_http_proxy_mapper() {
-  grpc_proxy_mapper_register(true /* at_start */, &proxy_mapper);
+void RegisterHttpProxyMapper() {
+  ProxyMapperRegistry::Register(
+      true /* at_start */,
+      std::unique_ptr<ProxyMapperInterface>(new HttpProxyMapper()));
 }
+
+}  // namespace grpc_core

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

@@ -19,6 +19,10 @@
 #ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HTTP_PROXY_H
 #define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HTTP_PROXY_H
 
-void grpc_register_http_proxy_mapper();
+namespace grpc_core {
+
+void RegisterHttpProxyMapper();
+
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HTTP_PROXY_H */

data/src/core/ext/filters/client_channel/lb_policy.cc

@@ -90,7 +90,7 @@ LoadBalancingPolicy::UpdateArgs& LoadBalancingPolicy::UpdateArgs::operator=(
 //
 
 LoadBalancingPolicy::PickResult LoadBalancingPolicy::QueuePicker::Pick(
-    PickArgs args) {
+    PickArgs /*args*/) {
   // We invoke the parent's ExitIdleLocked() via a closure instead
   // of doing it directly here, for two reasons:
   // 1. ExitIdleLocked() may cause the policy's state to change and
@@ -115,7 +115,7 @@ LoadBalancingPolicy::PickResult LoadBalancingPolicy::QueuePicker::Pick(
 }
 
 void LoadBalancingPolicy::QueuePicker::CallExitIdle(void* arg,
-                                                    grpc_error* error) {
+                                                    grpc_error* /*error*/) {
   LoadBalancingPolicy* parent = static_cast<LoadBalancingPolicy*>(arg);
   parent->ExitIdleLocked();
   parent->Unref();
@@ -126,7 +126,7 @@ void LoadBalancingPolicy::QueuePicker::CallExitIdle(void* arg,
 //
 
 LoadBalancingPolicy::PickResult
-LoadBalancingPolicy::TransientFailurePicker::Pick(PickArgs args) {
+LoadBalancingPolicy::TransientFailurePicker::Pick(PickArgs /*args*/) {
   PickResult result;
   result.type = PickResult::PICK_FAILED;
   result.error = GRPC_ERROR_REF(error_);

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

@@ -21,6 +21,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <functional>
 #include <iterator>
 
 #include "src/core/ext/filters/client_channel/server_address.h"
@@ -92,11 +93,11 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     /// Application-specific requests cost metrics.  Metric names are
     /// determined by the application.  Each value is an absolute cost
     /// (e.g. 3487 bytes of storage) associated with the request.
-    Map<StringView, double, StringLess> request_cost;
+    std::map<StringView, double, StringLess> request_cost;
     /// Application-specific resource utilization metrics.  Metric names
     /// are determined by the application.  Each value is expressed as a
     /// fraction of total resources available.
-    Map<StringView, double, StringLess> utilization;
+    std::map<StringView, double, StringLess> utilization;
   };
 
   /// Interface for accessing per-call state.
@@ -268,7 +269,7 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     /// Sets the connectivity state and returns a new picker to be used
     /// by the client channel.
     virtual void UpdateState(grpc_connectivity_state state,
-                             UniquePtr<SubchannelPicker>) = 0;
+                             std::unique_ptr<SubchannelPicker>) = 0;
 
     /// Requests that the resolver re-resolve.
     virtual void RequestReresolution() = 0;
@@ -317,9 +318,12 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     /// Channel control helper.
     /// Note: LB policies MUST NOT call any method on the helper from
     /// their constructor.
-    UniquePtr<ChannelControlHelper> channel_control_helper;
+    std::unique_ptr<ChannelControlHelper> channel_control_helper;
     /// Channel args.
     // TODO(roth): Find a better channel args representation for this API.
+    // TODO(roth): Clarify ownership semantics here -- currently, this
+    // does not take ownership of args, which is the opposite of how we
+    // handle them in UpdateArgs.
     const grpc_channel_args* args = nullptr;
   };
 
@@ -400,7 +404,7 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
   /// Owned pointer to interested parties in load balancing decisions.
   grpc_pollset_set* interested_parties_;
   /// Channel control helper.
-  UniquePtr<ChannelControlHelper> channel_control_helper_;
+  std::unique_ptr<ChannelControlHelper> channel_control_helper_;
 };
 
 }  // namespace grpc_core

data/src/core/ext/filters/client_channel/lb_policy/grpclb/client_load_reporting_filter.cc

@@ -30,12 +30,12 @@
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/profiling/timers.h"
 
-static grpc_error* clr_init_channel_elem(grpc_channel_element* elem,
-                                         grpc_channel_element_args* args) {
+static grpc_error* clr_init_channel_elem(grpc_channel_element* /*elem*/,
+                                         grpc_channel_element_args* /*args*/) {
   return GRPC_ERROR_NONE;
 }
 
-static void clr_destroy_channel_elem(grpc_channel_element* elem) {}
+static void clr_destroy_channel_elem(grpc_channel_element* /*elem*/) {}
 
 namespace {
 
@@ -59,7 +59,8 @@ static void on_complete_for_send(void* arg, grpc_error* error) {
   if (error == GRPC_ERROR_NONE) {
     calld->send_initial_metadata_succeeded = true;
   }
-  GRPC_CLOSURE_RUN(calld->original_on_complete_for_send, GRPC_ERROR_REF(error));
+  grpc_core::Closure::Run(DEBUG_LOCATION, calld->original_on_complete_for_send,
+                          GRPC_ERROR_REF(error));
 }
 
 static void recv_initial_metadata_ready(void* arg, grpc_error* error) {
@@ -67,8 +68,9 @@ static void recv_initial_metadata_ready(void* arg, grpc_error* error) {
   if (error == GRPC_ERROR_NONE) {
     calld->recv_initial_metadata_succeeded = true;
   }
-  GRPC_CLOSURE_RUN(calld->original_recv_initial_metadata_ready,
-                   GRPC_ERROR_REF(error));
+  grpc_core::Closure::Run(DEBUG_LOCATION,
+                          calld->original_recv_initial_metadata_ready,
+                          GRPC_ERROR_REF(error));
 }
 
 static grpc_error* clr_init_call_elem(grpc_call_element* elem,
@@ -79,8 +81,8 @@ static grpc_error* clr_init_call_elem(grpc_call_element* elem,
 }
 
 static void clr_destroy_call_elem(grpc_call_element* elem,
-                                  const grpc_call_final_info* final_info,
-                                  grpc_closure* ignored) {
+                                  const grpc_call_final_info* /*final_info*/,
+                                  grpc_closure* /*ignored*/) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
   if (calld->client_stats != nullptr) {
     // Record call finished, optionally setting client_failed_to_send and

data/src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb.cc

@@ -237,7 +237,7 @@ class GrpcLb : public LoadBalancingPolicy {
     const grpc_grpclb_serverlist* serverlist() const { return serverlist_; }
 
     // Returns a text representation suitable for logging.
-    UniquePtr<char> AsText() const;
+    grpc_core::UniquePtr<char> AsText() const;
 
     // Extracts all non-drop entries into a ServerAddressList.
     ServerAddressList GetServerAddressList(
@@ -268,7 +268,7 @@ class GrpcLb : public LoadBalancingPolicy {
   class Picker : public SubchannelPicker {
    public:
     Picker(GrpcLb* parent, RefCountedPtr<Serverlist> serverlist,
-           UniquePtr<SubchannelPicker> child_picker,
+           std::unique_ptr<SubchannelPicker> child_picker,
            RefCountedPtr<GrpcLbClientStats> client_stats)
         : parent_(parent),
           serverlist_(std::move(serverlist)),
@@ -285,7 +285,7 @@ class GrpcLb : public LoadBalancingPolicy {
     // Serverlist to be used for determining drops.
     RefCountedPtr<Serverlist> serverlist_;
 
-    UniquePtr<SubchannelPicker> child_picker_;
+    std::unique_ptr<SubchannelPicker> child_picker_;
     RefCountedPtr<GrpcLbClientStats> client_stats_;
   };
 
@@ -297,7 +297,7 @@ class GrpcLb : public LoadBalancingPolicy {
     RefCountedPtr<SubchannelInterface> CreateSubchannel(
         const grpc_channel_args& args) override;
     void UpdateState(grpc_connectivity_state state,
-                     UniquePtr<SubchannelPicker> picker) override;
+                     std::unique_ptr<SubchannelPicker> picker) override;
     void RequestReresolution() override;
     void AddTraceEvent(TraceSeverity severity, StringView message) override;
 
@@ -430,7 +430,7 @@ void ParseServer(const grpc_grpclb_server* server,
   }
 }
 
-UniquePtr<char> GrpcLb::Serverlist::AsText() const {
+grpc_core::UniquePtr<char> GrpcLb::Serverlist::AsText() const {
   gpr_strvec entries;
   gpr_strvec_init(&entries);
   for (size_t i = 0; i < serverlist_->num_servers; ++i) {
@@ -449,7 +449,7 @@ UniquePtr<char> GrpcLb::Serverlist::AsText() const {
     gpr_free(ipport);
     gpr_strvec_add(&entries, entry);
   }
-  UniquePtr<char> result(gpr_strvec_flatten(&entries, nullptr));
+  grpc_core::UniquePtr<char> result(gpr_strvec_flatten(&entries, nullptr));
   gpr_strvec_destroy(&entries);
   return result;
 }
@@ -468,7 +468,7 @@ void client_stats_destroy(void* p) {
   GrpcLbClientStats* client_stats = static_cast<GrpcLbClientStats*>(p);
   client_stats->Unref();
 }
-int equal_cmp(void* p1, void* p2) {
+int equal_cmp(void* /*p1*/, void* /*p2*/) {
   // Always indicate a match, since we don't want this channel arg to
   // affect the subchannel's key in the index.
   // TODO(roth): Is this right?  This does prevent us from needlessly
@@ -479,8 +479,7 @@ int equal_cmp(void* p1, void* p2) {
   // token or client stats.  A better approach might be to find somewhere
   // other than the subchannel args to store the LB token and client
   // stats.  They could be stored in a map and then looked up for each
-  // call (although we'd need to make sure our Map<> implementation is
-  // performant enough).  Or we could do something more complicated whereby
+  // call. Or we could do something more complicated whereby
   // we create our own subchannel wrapper to store them, although that would
   // involve a lot of refcounting overhead.
   // Given that we're trying to move from grpclb to xds at this point,
@@ -658,7 +657,7 @@ RefCountedPtr<SubchannelInterface> GrpcLb::Helper::CreateSubchannel(
 }
 
 void GrpcLb::Helper::UpdateState(grpc_connectivity_state state,
-                                 UniquePtr<SubchannelPicker> picker) {
+                                 std::unique_ptr<SubchannelPicker> picker) {
   if (parent_->shutting_down_) return;
   // If this request is from the pending child policy, ignore it until
   // it reports READY, at which point we swap it into place.
@@ -1025,8 +1024,8 @@ void GrpcLb::BalancerCallState::OnInitialRequestSent(void* arg,
       GRPC_ERROR_REF(error));
 }
 
-void GrpcLb::BalancerCallState::OnInitialRequestSentLocked(void* arg,
-                                                           grpc_error* error) {
+void GrpcLb::BalancerCallState::OnInitialRequestSentLocked(
+    void* arg, grpc_error* /*error*/) {
   BalancerCallState* lb_calld = static_cast<BalancerCallState*>(arg);
   grpc_byte_buffer_destroy(lb_calld->send_message_payload_);
   lb_calld->send_message_payload_ = nullptr;
@@ -1050,7 +1049,7 @@ void GrpcLb::BalancerCallState::OnBalancerMessageReceived(void* arg,
 }
 
 void GrpcLb::BalancerCallState::OnBalancerMessageReceivedLocked(
-    void* arg, grpc_error* error) {
+    void* arg, grpc_error* /*error*/) {
   BalancerCallState* lb_calld = static_cast<BalancerCallState*>(arg);
   GrpcLb* grpclb_policy = lb_calld->grpclb_policy();
   // Null payload means the LB call was cancelled.
@@ -1100,7 +1099,7 @@ void GrpcLb::BalancerCallState::OnBalancerMessageReceivedLocked(
     GPR_ASSERT(lb_calld->lb_call_ != nullptr);
     auto serverlist_wrapper = MakeRefCounted<Serverlist>(serverlist);
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_glb_trace)) {
-      UniquePtr<char> serverlist_text = serverlist_wrapper->AsText();
+      grpc_core::UniquePtr<char> serverlist_text = serverlist_wrapper->AsText();
       gpr_log(GPR_INFO,
               "[grpclb %p] lb_calld=%p: Serverlist with %" PRIuPTR
               " servers received:\n%s",
@@ -1547,7 +1546,7 @@ void GrpcLb::OnBalancerChannelConnectivityChanged(void* arg,
 }
 
 void GrpcLb::OnBalancerChannelConnectivityChangedLocked(void* arg,
-                                                        grpc_error* error) {
+                                                        grpc_error* /*error*/) {
   GrpcLb* self = static_cast<GrpcLb*>(arg);
   if (!self->shutting_down_ && self->fallback_at_startup_checks_pending_) {
     if (self->lb_channel_connectivity_ != GRPC_CHANNEL_TRANSIENT_FAILURE) {
@@ -1725,12 +1724,12 @@ grpc_channel_args* GrpcLb::CreateChildPolicyArgsLocked(
 
 OrphanablePtr<LoadBalancingPolicy> GrpcLb::CreateChildPolicyLocked(
     const char* name, const grpc_channel_args* args) {
-  Helper* helper = New<Helper>(Ref());
+  Helper* helper = new Helper(Ref());
   LoadBalancingPolicy::Args lb_policy_args;
   lb_policy_args.combiner = combiner();
   lb_policy_args.args = args;
   lb_policy_args.channel_control_helper =
-      UniquePtr<ChannelControlHelper>(helper);
+      std::unique_ptr<ChannelControlHelper>(helper);
   OrphanablePtr<LoadBalancingPolicy> lb_policy =
       LoadBalancingPolicyRegistry::CreateLoadBalancingPolicy(
           name, std::move(lb_policy_args));
@@ -1884,7 +1883,7 @@ class GrpcLbFactory : public LoadBalancingPolicyFactory {
     GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
     if (json == nullptr) {
       return RefCountedPtr<LoadBalancingPolicy::Config>(
-          New<ParsedGrpcLbConfig>(nullptr));
+          new ParsedGrpcLbConfig(nullptr));
     }
     InlinedVector<grpc_error*, 2> error_list;
     RefCountedPtr<LoadBalancingPolicy::Config> child_policy;
@@ -1906,7 +1905,7 @@ class GrpcLbFactory : public LoadBalancingPolicyFactory {
     }
     if (error_list.empty()) {
       return RefCountedPtr<LoadBalancingPolicy::Config>(
-          New<ParsedGrpcLbConfig>(std::move(child_policy)));
+          new ParsedGrpcLbConfig(std::move(child_policy)));
     } else {
       *error = GRPC_ERROR_CREATE_FROM_VECTOR("GrpcLb Parser", &error_list);
       return nullptr;