grpc 1.50.0.pre1 → 1.52.0.pre2

data/src/core/lib/iomgr/wakeup_fd_pipe.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>
 
@@ -28,6 +28,8 @@
 
 #include <grpc/support/log.h>
 
+#include "src/core/lib/gprpp/crash.h"
+#include "src/core/lib/gprpp/strerror.h"
 #include "src/core/lib/iomgr/socket_utils_posix.h"
 #include "src/core/lib/iomgr/wakeup_fd_pipe.h"
 #include "src/core/lib/iomgr/wakeup_fd_posix.h"
@@ -36,17 +38,18 @@ static grpc_error_handle pipe_init(grpc_wakeup_fd* fd_info) {
   int pipefd[2];
   int r = pipe(pipefd);
   if (0 != r) {
-    gpr_log(GPR_ERROR, "pipe creation failed (%d): %s", errno, strerror(errno));
+    gpr_log(GPR_ERROR, "pipe creation failed (%d): %s", errno,
+            grpc_core::StrError(errno).c_str());
     return GRPC_OS_ERROR(errno, "pipe");
   }
   grpc_error_handle err;
   err = grpc_set_socket_nonblocking(pipefd[0], 1);
-  if (!GRPC_ERROR_IS_NONE(err)) return err;
+  if (!err.ok()) return err;
   err = grpc_set_socket_nonblocking(pipefd[1], 1);
-  if (!GRPC_ERROR_IS_NONE(err)) return err;
+  if (!err.ok()) return err;
   fd_info->read_fd = pipefd[0];
   fd_info->write_fd = pipefd[1];
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 static grpc_error_handle pipe_consume(grpc_wakeup_fd* fd_info) {
@@ -56,10 +59,10 @@ static grpc_error_handle pipe_consume(grpc_wakeup_fd* fd_info) {
   for (;;) {
     r = read(fd_info->read_fd, buf, sizeof(buf));
     if (r > 0) continue;
-    if (r == 0) return GRPC_ERROR_NONE;
+    if (r == 0) return absl::OkStatus();
     switch (errno) {
       case EAGAIN:
-        return GRPC_ERROR_NONE;
+        return absl::OkStatus();
       case EINTR:
         continue;
       default:
@@ -72,7 +75,7 @@ static grpc_error_handle pipe_wakeup(grpc_wakeup_fd* fd_info) {
   char c = 0;
   while (write(fd_info->write_fd, &c, 1) != 1 && errno == EINTR) {
   }
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 static void pipe_destroy(grpc_wakeup_fd* fd_info) {
@@ -84,7 +87,7 @@ static int pipe_check_availability(void) {
   grpc_wakeup_fd fd;
   fd.read_fd = fd.write_fd = -1;
 
-  if (pipe_init(&fd) == GRPC_ERROR_NONE) {
+  if (pipe_init(&fd) == absl::OkStatus()) {
     pipe_destroy(&fd);
     return 1;
   } else {
@@ -96,4 +99,4 @@ const grpc_wakeup_fd_vtable grpc_pipe_wakeup_fd_vtable = {
     pipe_init, pipe_consume, pipe_wakeup, pipe_destroy,
     pipe_check_availability};
 
-#endif /* GPR_POSIX_WAKUP_FD */
+#endif  // GPR_POSIX_WAKUP_FD

data/src/core/lib/iomgr/wakeup_fd_pipe.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_IOMGR_WAKEUP_FD_PIPE_H
 #define GRPC_CORE_LIB_IOMGR_WAKEUP_FD_PIPE_H
@@ -25,4 +25,4 @@
 
 extern const grpc_wakeup_fd_vtable grpc_pipe_wakeup_fd_vtable;
 
-#endif /* GRPC_CORE_LIB_IOMGR_WAKEUP_FD_PIPE_H */
+#endif  // GRPC_CORE_LIB_IOMGR_WAKEUP_FD_PIPE_H

data/src/core/lib/iomgr/wakeup_fd_posix.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>
 
@@ -70,4 +70,4 @@ void grpc_wakeup_fd_destroy(grpc_wakeup_fd* fd_info) {
   wakeup_fd_vtable->destroy(fd_info);
 }
 
-#endif /* GRPC_POSIX_WAKEUP_FD */
+#endif  // GRPC_POSIX_WAKEUP_FD

data/src/core/lib/iomgr/wakeup_fd_posix.h

@@ -1,49 +1,49 @@
-/*
- *
- * 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.
+//
+//
 
-/*
- * wakeup_fd abstracts the concept of a file descriptor for the purpose of
- * waking up a thread in select()/poll()/epoll_wait()/etc.
+//
+// wakeup_fd abstracts the concept of a file descriptor for the purpose of
+// waking up a thread in select()/poll()/epoll_wait()/etc.
 
- * The poll() family of system calls provide a way for a thread to block until
- * there is activity on one (or more) of a set of file descriptors. An
- * application may wish to wake up this thread to do non file related work. The
- * typical way to do this is to add a pipe to the set of file descriptors, then
- * write to the pipe to wake up the thread in poll().
- *
- * Linux has a lighter weight eventfd specifically designed for this purpose.
- * wakeup_fd abstracts the difference between the two.
- *
- * Setup:
- * 1. Before calling anything, call global_init() at least once.
- * 1. Call grpc_wakeup_fd_init() to set up a wakeup_fd.
- * 2. Add the result of GRPC_WAKEUP_FD_FD to the set of monitored file
- *    descriptors for the poll() style API you are using. Monitor the file
- *    descriptor for readability.
- * 3. To tear down, call grpc_wakeup_fd_destroy(). This closes the underlying
- *    file descriptor.
- *
- * Usage:
- * 1. To wake up a polling thread, call grpc_wakeup_fd_wakeup() on a wakeup_fd
- *    it is monitoring.
- * 2. If the polling thread was awakened by a wakeup_fd event, call
- *    grpc_wakeup_fd_consume_wakeup() on it.
- */
+// The poll() family of system calls provide a way for a thread to block until
+// there is activity on one (or more) of a set of file descriptors. An
+// application may wish to wake up this thread to do non file related work. The
+// typical way to do this is to add a pipe to the set of file descriptors, then
+// write to the pipe to wake up the thread in poll().
+//
+// Linux has a lighter weight eventfd specifically designed for this purpose.
+// wakeup_fd abstracts the difference between the two.
+//
+// Setup:
+// 1. Before calling anything, call global_init() at least once.
+// 1. Call grpc_wakeup_fd_init() to set up a wakeup_fd.
+// 2. Add the result of GRPC_WAKEUP_FD_FD to the set of monitored file
+//    descriptors for the poll() style API you are using. Monitor the file
+//    descriptor for readability.
+// 3. To tear down, call grpc_wakeup_fd_destroy(). This closes the underlying
+//    file descriptor.
+//
+// Usage:
+// 1. To wake up a polling thread, call grpc_wakeup_fd_wakeup() on a wakeup_fd
+//    it is monitoring.
+// 2. If the polling thread was awakened by a wakeup_fd event, call
+//    grpc_wakeup_fd_consume_wakeup() on it.
+//
 #ifndef GRPC_CORE_LIB_IOMGR_WAKEUP_FD_POSIX_H
 #define GRPC_CORE_LIB_IOMGR_WAKEUP_FD_POSIX_H
 
@@ -54,8 +54,8 @@
 void grpc_wakeup_fd_global_init(void);
 void grpc_wakeup_fd_global_destroy(void);
 
-/* Force using the fallback implementation. This is intended for testing
- * purposes only.*/
+// Force using the fallback implementation. This is intended for testing
+// purposes only.
 void grpc_wakeup_fd_global_init_force_fallback(void);
 
 int grpc_has_wakeup_fd(void);
@@ -67,7 +67,7 @@ typedef struct grpc_wakeup_fd_vtable {
   grpc_error_handle (*consume)(grpc_wakeup_fd* fd_info);
   grpc_error_handle (*wakeup)(grpc_wakeup_fd* fd_info);
   void (*destroy)(grpc_wakeup_fd* fd_info);
-  /* Must be called before calling any other functions */
+  // Must be called before calling any other functions
   int (*check_availability)(void);
 } grpc_wakeup_fd_vtable;
 
@@ -89,8 +89,8 @@ grpc_error_handle grpc_wakeup_fd_wakeup(grpc_wakeup_fd* fd_info)
     GRPC_MUST_USE_RESULT;
 void grpc_wakeup_fd_destroy(grpc_wakeup_fd* fd_info);
 
-/* Defined in some specialized implementation's .c file, or by
- * wakeup_fd_nospecial.c if no such implementation exists. */
+// Defined in some specialized implementation's .c file, or by
+// wakeup_fd_nospecial.c if no such implementation exists.
 extern const grpc_wakeup_fd_vtable grpc_specialized_wakeup_fd_vtable;
 
-#endif /* GRPC_CORE_LIB_IOMGR_WAKEUP_FD_POSIX_H */
+#endif  // GRPC_CORE_LIB_IOMGR_WAKEUP_FD_POSIX_H

data/src/core/lib/json/json_channel_args.h

@@ -0,0 +1,42 @@
+// 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_JSON_JSON_CHANNEL_ARGS_H
+#define GRPC_CORE_LIB_JSON_JSON_CHANNEL_ARGS_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/json/json_args.h"
+
+namespace grpc_core {
+
+class JsonChannelArgs : public JsonArgs {
+ public:
+  explicit JsonChannelArgs(const ChannelArgs& args) : args_(args) {}
+
+  bool IsEnabled(absl::string_view key) const override {
+    return args_.GetBool(key).value_or(false);
+  }
+
+ private:
+  ChannelArgs args_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_JSON_JSON_CHANNEL_ARGS_H

data/src/core/lib/json/json_object_loader.cc

@@ -56,7 +56,7 @@ void LoadDuration::LoadInto(const std::string& value, void* dst,
   }
   buf = absl::StripAsciiWhitespace(buf);
   auto decimal_point = buf.find('.');
-  int nanos = 0;
+  int32_t nanos = 0;
   if (decimal_point != absl::string_view::npos) {
     absl::string_view after_decimal = buf.substr(decimal_point + 1);
     buf = buf.substr(0, decimal_point);
@@ -73,11 +73,16 @@ void LoadDuration::LoadInto(const std::string& value, void* dst,
       nanos *= 10;
     }
   }
-  int seconds;
+  int64_t seconds;
   if (!absl::SimpleAtoi(buf, &seconds)) {
     errors->AddError("Not a duration (not a number of seconds)");
     return;
   }
+  // Acceptable range for seconds documented at
+  // https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#google.protobuf.Duration
+  if (seconds < 0 || seconds > 315576000000) {
+    errors->AddError("seconds must be in the range [0, 315576000000]");
+  }
   *static_cast<Duration*>(dst) =
       Duration::FromSecondsAndNanoseconds(seconds, nanos);
 }
@@ -105,6 +110,16 @@ void LoadUnprocessedJsonObject::LoadInto(const Json& json, const JsonArgs&,
   *static_cast<Json::Object*>(dst) = json.object_value();
 }
 
+void LoadUnprocessedJsonArray::LoadInto(const Json& json, const JsonArgs&,
+                                        void* dst,
+                                        ValidationErrors* errors) const {
+  if (json.type() != Json::Type::ARRAY) {
+    errors->AddError("is not an array");
+    return;
+  }
+  *static_cast<Json::Array*>(dst) = json.array_value();
+}
+
 void LoadVector::LoadInto(const Json& json, const JsonArgs& args, void* dst,
                           ValidationErrors* errors) const {
   if (json.type() != Json::Type::ARRAY) {

data/src/core/lib/json/json_object_loader.h

@@ -20,7 +20,9 @@
 #include <cstdint>
 #include <cstring>
 #include <map>
+#include <memory>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "absl/meta/type_traits.h"
@@ -212,6 +214,16 @@ class LoadUnprocessedJsonObject : public LoaderInterface {
   ~LoadUnprocessedJsonObject() = default;
 };
 
+// Loads an unprocessed JSON array value.
+class LoadUnprocessedJsonArray : public LoaderInterface {
+ public:
+  void LoadInto(const Json& json, const JsonArgs& /*args*/, void* dst,
+                ValidationErrors* errors) const override;
+
+ protected:
+  ~LoadUnprocessedJsonArray() = default;
+};
+
 // Load a vector of some type.
 class LoadVector : public LoaderInterface {
  public:
@@ -326,6 +338,11 @@ class AutoLoader<Json::Object> final : public LoadUnprocessedJsonObject {
  private:
   ~AutoLoader() = default;
 };
+template <>
+class AutoLoader<Json::Array> final : public LoadUnprocessedJsonArray {
+ private:
+  ~AutoLoader() = default;
+};
 
 // Specializations of AutoLoader for vectors.
 template <typename T>
@@ -369,7 +386,6 @@ class AutoLoader<std::map<std::string, T>> final : public LoadMap {
     return LoaderForType<T>();
   }
 
- private:
   ~AutoLoader() = default;
 };
 
@@ -391,6 +407,26 @@ class AutoLoader<absl::optional<T>> final : public LoadOptional {
   ~AutoLoader() = default;
 };
 
+// Specializations of AutoLoader for std::unique_ptr<>.
+template <typename T>
+class AutoLoader<std::unique_ptr<T>> final : public LoadOptional {
+ public:
+  void* Emplace(void* dst) const final {
+    auto& p = *static_cast<std::unique_ptr<T>*>(dst);
+    p = std::make_unique<T>();
+    return p.get();
+  }
+  void Reset(void* dst) const final {
+    static_cast<std::unique_ptr<T>*>(dst)->reset();
+  }
+  const LoaderInterface* ElementLoader() const final {
+    return LoaderForType<T>();
+  }
+
+ private:
+  ~AutoLoader() = default;
+};
+
 // Implementation of aforementioned LoaderForType.
 // Simply keeps a static AutoLoader<T> and returns a pointer to that.
 template <typename T>

data/src/core/lib/json/json_reader.cc

@@ -50,9 +50,9 @@ class JsonReader {
 
  private:
   enum class Status {
-    GRPC_JSON_DONE,          /* The parser finished successfully. */
-    GRPC_JSON_PARSE_ERROR,   /* The parser found an error in the json stream. */
-    GRPC_JSON_INTERNAL_ERROR /* The parser got an internal error. */
+    GRPC_JSON_DONE,           // The parser finished successfully.
+    GRPC_JSON_PARSE_ERROR,    // The parser found an error in the json stream.
+    GRPC_JSON_INTERNAL_ERROR  // The parser got an internal error.
   };
 
   enum class State {
@@ -86,10 +86,10 @@ class JsonReader {
     GRPC_JSON_STATE_END
   };
 
-  /* The first non-unicode value is 0x110000. But let's pick
-   * a value high enough to start our error codes from. These
-   * values are safe to return from the read_char function.
-   */
+  // The first non-unicode value is 0x110000. But let's pick
+  // a value high enough to start our error codes from. These
+  // values are safe to return from the read_char function.
+  //
   static constexpr uint32_t GRPC_JSON_READ_CHAR_EOF = 0x7ffffff0;
 
   explicit JsonReader(absl::string_view input)
@@ -316,21 +316,21 @@ bool JsonReader::IsComplete() {
                              state_ == State::GRPC_JSON_STATE_VALUE_END));
 }
 
-/* Call this function to start parsing the input. It will return the following:
- *    . GRPC_JSON_DONE if the input got eof, and the parsing finished
- *      successfully.
- *    . GRPC_JSON_PARSE_ERROR if the input was somehow invalid.
- *    . GRPC_JSON_INTERNAL_ERROR if the parser somehow ended into an invalid
- *      internal state.
- */
+// Call this function to start parsing the input. It will return the following:
+//    . GRPC_JSON_DONE if the input got eof, and the parsing finished
+//      successfully.
+//    . GRPC_JSON_PARSE_ERROR if the input was somehow invalid.
+//    . GRPC_JSON_INTERNAL_ERROR if the parser somehow ended into an invalid
+//      internal state.
+//
 JsonReader::Status JsonReader::Run() {
   uint32_t c;
 
-  /* This state-machine is a strict implementation of ECMA-404 */
+  // This state-machine is a strict implementation of ECMA-404
   while (true) {
     c = ReadChar();
     switch (c) {
-      /* Let's process the error case first. */
+      // Let's process the error case first.
       case GRPC_JSON_READ_CHAR_EOF:
         switch (state_) {
           case State::GRPC_JSON_STATE_VALUE_NUMBER:
@@ -349,7 +349,7 @@ JsonReader::Status JsonReader::Run() {
         }
         return Status::GRPC_JSON_PARSE_ERROR;
 
-      /* Processing whitespaces. */
+      // Processing whitespaces.
       case ' ':
       case '\t':
       case '\n':
@@ -384,7 +384,7 @@ JsonReader::Status JsonReader::Run() {
         }
         break;
 
-      /* Value, object or array terminations. */
+      // Value, object or array terminations.
       case ',':
       case '}':
       case ']':
@@ -461,7 +461,7 @@ JsonReader::Status JsonReader::Run() {
         }
         break;
 
-      /* In-string escaping. */
+      // In-string escaping.
       case '\\':
         switch (state_) {
           case State::GRPC_JSON_STATE_OBJECT_KEY_STRING:
@@ -474,7 +474,7 @@ JsonReader::Status JsonReader::Run() {
             state_ = State::GRPC_JSON_STATE_STRING_ESCAPE;
             break;
 
-          /* This is the \\ case. */
+          // This is the \\ case.
           case State::GRPC_JSON_STATE_STRING_ESCAPE:
             if (unicode_high_surrogate_ != 0) {
               return Status::GRPC_JSON_PARSE_ERROR;
@@ -662,17 +662,17 @@ JsonReader::Status JsonReader::Run() {
                 state_ = State::GRPC_JSON_STATE_STRING_ESCAPE_U4;
                 break;
               case State::GRPC_JSON_STATE_STRING_ESCAPE_U4:
-                /* See grpc_json_writer_escape_string to have a description
-                 * of what's going on here.
-                 */
+                // See grpc_json_writer_escape_string to have a description
+                // of what's going on here.
+                //
                 if ((unicode_char_ & 0xfc00) == 0xd800) {
-                  /* high surrogate utf-16 */
+                  // high surrogate utf-16
                   if (unicode_high_surrogate_ != 0) {
                     return Status::GRPC_JSON_PARSE_ERROR;
                   }
                   unicode_high_surrogate_ = unicode_char_;
                 } else if ((unicode_char_ & 0xfc00) == 0xdc00) {
-                  /* low surrogate utf-16 */
+                  // low surrogate utf-16
                   uint32_t utf32;
                   if (unicode_high_surrogate_ == 0) {
                     return Status::GRPC_JSON_PARSE_ERROR;
@@ -686,7 +686,7 @@ JsonReader::Status JsonReader::Run() {
                   }
                   unicode_high_surrogate_ = 0;
                 } else {
-                  /* anything else */
+                  // anything else
                   if (unicode_high_surrogate_ != 0) {
                     return Status::GRPC_JSON_PARSE_ERROR;
                   }
@@ -874,8 +874,8 @@ JsonReader::Status JsonReader::Run() {
             state_ = State::GRPC_JSON_STATE_VALUE_END;
             break;
 
-          /* All of the VALUE_END cases are handled in the specialized case
-           * above. */
+          // All of the VALUE_END cases are handled in the specialized case
+          // above.
           case State::GRPC_JSON_STATE_VALUE_END:
             switch (c) {
               case ',':

data/src/core/lib/json/json_util.cc

@@ -45,7 +45,7 @@ bool ExtractJsonBool(const Json& json, absl::string_view field_name,
       *output = false;
       return true;
     default:
-      error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
+      error_list->push_back(GRPC_ERROR_CREATE(
           absl::StrCat("field:", field_name, " error:type should be BOOLEAN")));
       return false;
   }
@@ -56,7 +56,7 @@ bool ExtractJsonArray(const Json& json, absl::string_view field_name,
                       std::vector<grpc_error_handle>* error_list) {
   if (json.type() != Json::Type::ARRAY) {
     *output = nullptr;
-    error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
+    error_list->push_back(GRPC_ERROR_CREATE(
         absl::StrCat("field:", field_name, " error:type should be ARRAY")));
     return false;
   }
@@ -69,7 +69,7 @@ bool ExtractJsonObject(const Json& json, absl::string_view field_name,
                        std::vector<grpc_error_handle>* error_list) {
   if (json.type() != Json::Type::OBJECT) {
     *output = nullptr;
-    error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
+    error_list->push_back(GRPC_ERROR_CREATE(
         absl::StrCat("field:", field_name, " error:type should be OBJECT")));
     return false;
   }
@@ -87,14 +87,14 @@ bool ParseJsonObjectFieldAsDuration(const Json::Object& object,
   auto it = object.find(std::string(field_name));
   if (it == object.end()) {
     if (required) {
-      error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
+      error_list->push_back(GRPC_ERROR_CREATE(
           absl::StrCat("field:", field_name, " error:does not exist.")));
     }
     return false;
   }
   if (!ParseDurationFromJson(it->second, output)) {
     *output = Duration::NegativeInfinity();
-    error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
+    error_list->push_back(GRPC_ERROR_CREATE(
         absl::StrCat("field:", field_name,
                      " error:type should be STRING of the form given by "
                      "google.proto.Duration.")));