grpc 1.54.3 → 1.55.0

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

@@ -38,10 +38,10 @@ bool ParseDurationFromJson(const Json& field, Duration* duration) {
 bool ExtractJsonBool(const Json& json, absl::string_view field_name,
                      bool* output, std::vector<grpc_error_handle>* error_list) {
   switch (json.type()) {
-    case Json::Type::JSON_TRUE:
+    case Json::Type::kTrue:
       *output = true;
       return true;
-    case Json::Type::JSON_FALSE:
+    case Json::Type::kFalse:
       *output = false;
       return true;
     default:
@@ -54,26 +54,26 @@ bool ExtractJsonBool(const Json& json, absl::string_view field_name,
 bool ExtractJsonArray(const Json& json, absl::string_view field_name,
                       const Json::Array** output,
                       std::vector<grpc_error_handle>* error_list) {
-  if (json.type() != Json::Type::ARRAY) {
+  if (json.type() != Json::Type::kArray) {
     *output = nullptr;
     error_list->push_back(GRPC_ERROR_CREATE(
         absl::StrCat("field:", field_name, " error:type should be ARRAY")));
     return false;
   }
-  *output = &json.array_value();
+  *output = &json.array();
   return true;
 }
 
 bool ExtractJsonObject(const Json& json, absl::string_view field_name,
                        const Json::Object** output,
                        std::vector<grpc_error_handle>* error_list) {
-  if (json.type() != Json::Type::OBJECT) {
+  if (json.type() != Json::Type::kObject) {
     *output = nullptr;
     error_list->push_back(GRPC_ERROR_CREATE(
         absl::StrCat("field:", field_name, " error:type should be OBJECT")));
     return false;
   }
-  *output = &json.object_value();
+  *output = &json.object();
   return true;
 }
 

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

@@ -54,12 +54,13 @@ bool ExtractJsonNumber(const Json& json, absl::string_view field_name,
                        NumericType* output,
                        std::vector<grpc_error_handle>* error_list) {
   static_assert(std::is_integral<NumericType>::value, "Integral required");
-  if (json.type() != Json::Type::NUMBER && json.type() != Json::Type::STRING) {
+  if (json.type() != Json::Type::kNumber &&
+      json.type() != Json::Type::kString) {
     error_list->push_back(GRPC_ERROR_CREATE(absl::StrCat(
         "field:", field_name, " error:type should be NUMBER or STRING")));
     return false;
   }
-  if (!absl::SimpleAtoi(json.string_value(), output)) {
+  if (!absl::SimpleAtoi(json.string(), output)) {
     error_list->push_back(GRPC_ERROR_CREATE(
         absl::StrCat("field:", field_name, " error:failed to parse.")));
     return false;
@@ -75,13 +76,13 @@ template <typename OutputType>
 bool ExtractJsonString(const Json& json, absl::string_view field_name,
                        OutputType* output,
                        std::vector<grpc_error_handle>* error_list) {
-  if (json.type() != Json::Type::STRING) {
+  if (json.type() != Json::Type::kString) {
     *output = "";
     error_list->push_back(GRPC_ERROR_CREATE(
         absl::StrCat("field:", field_name, " error:type should be STRING")));
     return false;
   }
-  *output = json.string_value();
+  *output = json.string();
   return true;
 }
 

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

@@ -243,7 +243,7 @@ void JsonWriter::EscapeString(const std::string& string) {
 void JsonWriter::ContainerBegins(Json::Type type) {
   if (!got_key_) ValueEnd();
   OutputIndent();
-  OutputChar(type == Json::Type::OBJECT ? '{' : '[');
+  OutputChar(type == Json::Type::kObject ? '{' : '[');
   container_empty_ = true;
   got_key_ = false;
   depth_++;
@@ -253,7 +253,7 @@ void JsonWriter::ContainerEnds(Json::Type type) {
   if (indent_ && !container_empty_) OutputChar('\n');
   depth_--;
   if (!container_empty_) OutputIndent();
-  OutputChar(type == Json::Type::OBJECT ? '}' : ']');
+  OutputChar(type == Json::Type::kObject ? '}' : ']');
   container_empty_ = false;
   got_key_ = false;
 }
@@ -281,43 +281,43 @@ void JsonWriter::ValueString(const std::string& string) {
 }
 
 void JsonWriter::DumpObject(const Json::Object& object) {
-  ContainerBegins(Json::Type::OBJECT);
+  ContainerBegins(Json::Type::kObject);
   for (const auto& p : object) {
     ObjectKey(p.first);
     DumpValue(p.second);
   }
-  ContainerEnds(Json::Type::OBJECT);
+  ContainerEnds(Json::Type::kObject);
 }
 
 void JsonWriter::DumpArray(const Json::Array& array) {
-  ContainerBegins(Json::Type::ARRAY);
+  ContainerBegins(Json::Type::kArray);
   for (const auto& v : array) {
     DumpValue(v);
   }
-  ContainerEnds(Json::Type::ARRAY);
+  ContainerEnds(Json::Type::kArray);
 }
 
 void JsonWriter::DumpValue(const Json& value) {
   switch (value.type()) {
-    case Json::Type::OBJECT:
-      DumpObject(value.object_value());
+    case Json::Type::kObject:
+      DumpObject(value.object());
       break;
-    case Json::Type::ARRAY:
-      DumpArray(value.array_value());
+    case Json::Type::kArray:
+      DumpArray(value.array());
       break;
-    case Json::Type::STRING:
-      ValueString(value.string_value());
+    case Json::Type::kString:
+      ValueString(value.string());
       break;
-    case Json::Type::NUMBER:
-      ValueRaw(value.string_value());
+    case Json::Type::kNumber:
+      ValueRaw(value.string());
       break;
-    case Json::Type::JSON_TRUE:
+    case Json::Type::kTrue:
       ValueRaw(std::string("true", 4));
       break;
-    case Json::Type::JSON_FALSE:
+    case Json::Type::kFalse:
       ValueRaw(std::string("false", 5));
       break;
-    case Json::Type::JSON_NULL:
+    case Json::Type::kNull:
       ValueRaw(std::string("null", 4));
       break;
     default:
@@ -333,8 +333,8 @@ std::string JsonWriter::Dump(const Json& value, int indent) {
 
 }  // namespace
 
-std::string Json::Dump(int indent) const {
-  return JsonWriter::Dump(*this, indent);
+std::string JsonDump(const Json& json, int indent) {
+  return JsonWriter::Dump(json, indent);
 }
 
 }  // namespace grpc_core

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

@@ -0,0 +1,33 @@
+//
+// 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_SRC_CORE_LIB_JSON_JSON_WRITER_H
+#define GRPC_SRC_CORE_LIB_JSON_JSON_WRITER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <string>
+
+#include "src/core/lib/json/json.h"
+
+namespace grpc_core {
+
+// Dumps JSON from value to string form.
+std::string JsonDump(const Json& json, int indent = 0);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_JSON_JSON_WRITER_H

data/src/core/lib/load_balancing/lb_policy_registry.cc

@@ -94,23 +94,23 @@ bool LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(
 absl::StatusOr<Json::Object::const_iterator>
 LoadBalancingPolicyRegistry::ParseLoadBalancingConfigHelper(
     const Json& lb_config_array) const {
-  if (lb_config_array.type() != Json::Type::ARRAY) {
+  if (lb_config_array.type() != Json::Type::kArray) {
     return absl::InvalidArgumentError("type should be array");
   }
   // Find the first LB policy that this client supports.
   std::vector<absl::string_view> policies_tried;
-  for (const Json& lb_config : lb_config_array.array_value()) {
-    if (lb_config.type() != Json::Type::OBJECT) {
+  for (const Json& lb_config : lb_config_array.array()) {
+    if (lb_config.type() != Json::Type::kObject) {
       return absl::InvalidArgumentError("child entry should be of type object");
     }
-    if (lb_config.object_value().empty()) {
+    if (lb_config.object().empty()) {
       return absl::InvalidArgumentError("no policy found in child entry");
     }
-    if (lb_config.object_value().size() > 1) {
+    if (lb_config.object().size() > 1) {
       return absl::InvalidArgumentError("oneOf violation");
     }
-    auto it = lb_config.object_value().begin();
-    if (it->second.type() != Json::Type::OBJECT) {
+    auto it = lb_config.object().begin();
+    if (it->second.type() != Json::Type::kObject) {
       return absl::InvalidArgumentError("child entry should be of type object");
     }
     // If we support this policy, then select it.

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

@@ -477,6 +477,13 @@ class PipeSender {
     }
   }
 
+  void CloseWithError() {
+    if (center_ != nullptr) {
+      center_->MarkCancelled();
+      center_.reset();
+    }
+  }
+
   void Swap(PipeSender<T>* other) { std::swap(center_, other->center_); }
 
   // Send a single message along the pipe.

data/src/core/lib/security/credentials/external/aws_external_account_credentials.cc

@@ -41,6 +41,8 @@
 #include "src/core/lib/http/httpcli_ssl_credentials.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/json/json.h"
+#include "src/core/lib/json/json_reader.h"
+#include "src/core/lib/json/json_writer.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/uri/uri_parser.h"
 
@@ -93,52 +95,51 @@ AwsExternalAccountCredentials::AwsExternalAccountCredentials(
     Options options, std::vector<std::string> scopes, grpc_error_handle* error)
     : ExternalAccountCredentials(options, std::move(scopes)) {
   audience_ = options.audience;
-  auto it = options.credential_source.object_value().find("environment_id");
-  if (it == options.credential_source.object_value().end()) {
+  auto it = options.credential_source.object().find("environment_id");
+  if (it == options.credential_source.object().end()) {
     *error = GRPC_ERROR_CREATE("environment_id field not present.");
     return;
   }
-  if (it->second.type() != Json::Type::STRING) {
+  if (it->second.type() != Json::Type::kString) {
     *error = GRPC_ERROR_CREATE("environment_id field must be a string.");
     return;
   }
-  if (it->second.string_value() != kExpectedEnvironmentId) {
+  if (it->second.string() != kExpectedEnvironmentId) {
     *error = GRPC_ERROR_CREATE("environment_id does not match.");
     return;
   }
-  it = options.credential_source.object_value().find("region_url");
-  if (it == options.credential_source.object_value().end()) {
+  it = options.credential_source.object().find("region_url");
+  if (it == options.credential_source.object().end()) {
     *error = GRPC_ERROR_CREATE("region_url field not present.");
     return;
   }
-  if (it->second.type() != Json::Type::STRING) {
+  if (it->second.type() != Json::Type::kString) {
     *error = GRPC_ERROR_CREATE("region_url field must be a string.");
     return;
   }
-  region_url_ = it->second.string_value();
-  it = options.credential_source.object_value().find("url");
-  if (it != options.credential_source.object_value().end() &&
-      it->second.type() == Json::Type::STRING) {
-    url_ = it->second.string_value();
+  region_url_ = it->second.string();
+  it = options.credential_source.object().find("url");
+  if (it != options.credential_source.object().end() &&
+      it->second.type() == Json::Type::kString) {
+    url_ = it->second.string();
   }
-  it = options.credential_source.object_value().find(
-      "regional_cred_verification_url");
-  if (it == options.credential_source.object_value().end()) {
+  it =
+      options.credential_source.object().find("regional_cred_verification_url");
+  if (it == options.credential_source.object().end()) {
     *error =
         GRPC_ERROR_CREATE("regional_cred_verification_url field not present.");
     return;
   }
-  if (it->second.type() != Json::Type::STRING) {
+  if (it->second.type() != Json::Type::kString) {
     *error = GRPC_ERROR_CREATE(
         "regional_cred_verification_url field must be a string.");
     return;
   }
-  regional_cred_verification_url_ = it->second.string_value();
-  it =
-      options.credential_source.object_value().find("imdsv2_session_token_url");
-  if (it != options.credential_source.object_value().end() &&
-      it->second.type() == Json::Type::STRING) {
-    imdsv2_session_token_url_ = it->second.string_value();
+  regional_cred_verification_url_ = it->second.string();
+  it = options.credential_source.object().find("imdsv2_session_token_url");
+  if (it != options.credential_source.object().end() &&
+      it->second.type() == Json::Type::kString) {
+    imdsv2_session_token_url_ = it->second.string();
   }
 }
 
@@ -416,7 +417,7 @@ void AwsExternalAccountCredentials::OnRetrieveSigningKeysInternal(
   }
   absl::string_view response_body(ctx_->response.body,
                                   ctx_->response.body_length);
-  auto json = Json::Parse(response_body);
+  auto json = JsonParse(response_body);
   if (!json.ok()) {
     FinishRetrieveSubjectToken(
         "", GRPC_ERROR_CREATE(
@@ -424,36 +425,33 @@ void AwsExternalAccountCredentials::OnRetrieveSigningKeysInternal(
                              json.status().ToString())));
     return;
   }
-  if (json->type() != Json::Type::OBJECT) {
+  if (json->type() != Json::Type::kObject) {
     FinishRetrieveSubjectToken(
         "", GRPC_ERROR_CREATE("Invalid retrieve signing keys response: "
                               "JSON type is not object"));
     return;
   }
-  auto it = json->object_value().find("AccessKeyId");
-  if (it != json->object_value().end() &&
-      it->second.type() == Json::Type::STRING) {
-    access_key_id_ = it->second.string_value();
+  auto it = json->object().find("AccessKeyId");
+  if (it != json->object().end() && it->second.type() == Json::Type::kString) {
+    access_key_id_ = it->second.string();
   } else {
     FinishRetrieveSubjectToken(
         "", GRPC_ERROR_CREATE(absl::StrFormat(
                 "Missing or invalid AccessKeyId in %s.", response_body)));
     return;
   }
-  it = json->object_value().find("SecretAccessKey");
-  if (it != json->object_value().end() &&
-      it->second.type() == Json::Type::STRING) {
-    secret_access_key_ = it->second.string_value();
+  it = json->object().find("SecretAccessKey");
+  if (it != json->object().end() && it->second.type() == Json::Type::kString) {
+    secret_access_key_ = it->second.string();
   } else {
     FinishRetrieveSubjectToken(
         "", GRPC_ERROR_CREATE(absl::StrFormat(
                 "Missing or invalid SecretAccessKey in %s.", response_body)));
     return;
   }
-  it = json->object_value().find("Token");
-  if (it != json->object_value().end() &&
-      it->second.type() == Json::Type::STRING) {
-    token_ = it->second.string_value();
+  it = json->object().find("Token");
+  if (it != json->object().end() && it->second.type() == Json::Type::kString) {
+    token_ = it->second.string();
   } else {
     FinishRetrieveSubjectToken(
         "", GRPC_ERROR_CREATE(absl::StrFormat("Missing or invalid Token in %s.",
@@ -502,7 +500,7 @@ void AwsExternalAccountCredentials::BuildSubjectToken() {
                       {"method", Json("POST")},
                       {"headers", Json(headers)}};
   Json subject_token_json(object);
-  std::string subject_token = UrlEncode(subject_token_json.Dump());
+  std::string subject_token = UrlEncode(JsonDump(subject_token_json));
   FinishRetrieveSubjectToken(subject_token, absl::OkStatus());
 }
 

data/src/core/lib/security/credentials/external/external_account_credentials.cc

@@ -1,4 +1,3 @@
-//
 // Copyright 2020 gRPC authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -47,6 +46,8 @@
 #include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/http/httpcli_ssl_credentials.h"
 #include "src/core/lib/http/parser.h"
+#include "src/core/lib/json/json_reader.h"
+#include "src/core/lib/json/json_writer.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/credentials/external/aws_external_account_credentials.h"
 #include "src/core/lib/security/credentials/external/file_external_account_credentials.h"
@@ -109,85 +110,85 @@ RefCountedPtr<ExternalAccountCredentials> ExternalAccountCredentials::Create(
   GPR_ASSERT(error->ok());
   Options options;
   options.type = GRPC_AUTH_JSON_TYPE_INVALID;
-  if (json.type() != Json::Type::OBJECT) {
+  if (json.type() != Json::Type::kObject) {
     *error =
         GRPC_ERROR_CREATE("Invalid json to construct credentials options.");
     return nullptr;
   }
-  auto it = json.object_value().find("type");
-  if (it == json.object_value().end()) {
+  auto it = json.object().find("type");
+  if (it == json.object().end()) {
     *error = GRPC_ERROR_CREATE("type field not present.");
     return nullptr;
   }
-  if (it->second.type() != Json::Type::STRING) {
+  if (it->second.type() != Json::Type::kString) {
     *error = GRPC_ERROR_CREATE("type field must be a string.");
     return nullptr;
   }
-  if (it->second.string_value() != GRPC_AUTH_JSON_TYPE_EXTERNAL_ACCOUNT) {
+  if (it->second.string() != GRPC_AUTH_JSON_TYPE_EXTERNAL_ACCOUNT) {
     *error = GRPC_ERROR_CREATE("Invalid credentials json type.");
     return nullptr;
   }
   options.type = GRPC_AUTH_JSON_TYPE_EXTERNAL_ACCOUNT;
-  it = json.object_value().find("audience");
-  if (it == json.object_value().end()) {
+  it = json.object().find("audience");
+  if (it == json.object().end()) {
     *error = GRPC_ERROR_CREATE("audience field not present.");
     return nullptr;
   }
-  if (it->second.type() != Json::Type::STRING) {
+  if (it->second.type() != Json::Type::kString) {
     *error = GRPC_ERROR_CREATE("audience field must be a string.");
     return nullptr;
   }
-  options.audience = it->second.string_value();
-  it = json.object_value().find("subject_token_type");
-  if (it == json.object_value().end()) {
+  options.audience = it->second.string();
+  it = json.object().find("subject_token_type");
+  if (it == json.object().end()) {
     *error = GRPC_ERROR_CREATE("subject_token_type field not present.");
     return nullptr;
   }
-  if (it->second.type() != Json::Type::STRING) {
+  if (it->second.type() != Json::Type::kString) {
     *error = GRPC_ERROR_CREATE("subject_token_type field must be a string.");
     return nullptr;
   }
-  options.subject_token_type = it->second.string_value();
-  it = json.object_value().find("service_account_impersonation_url");
-  if (it != json.object_value().end()) {
-    options.service_account_impersonation_url = it->second.string_value();
+  options.subject_token_type = it->second.string();
+  it = json.object().find("service_account_impersonation_url");
+  if (it != json.object().end()) {
+    options.service_account_impersonation_url = it->second.string();
   }
-  it = json.object_value().find("token_url");
-  if (it == json.object_value().end()) {
+  it = json.object().find("token_url");
+  if (it == json.object().end()) {
     *error = GRPC_ERROR_CREATE("token_url field not present.");
     return nullptr;
   }
-  if (it->second.type() != Json::Type::STRING) {
+  if (it->second.type() != Json::Type::kString) {
     *error = GRPC_ERROR_CREATE("token_url field must be a string.");
     return nullptr;
   }
-  options.token_url = it->second.string_value();
-  it = json.object_value().find("token_info_url");
-  if (it != json.object_value().end()) {
-    options.token_info_url = it->second.string_value();
+  options.token_url = it->second.string();
+  it = json.object().find("token_info_url");
+  if (it != json.object().end()) {
+    options.token_info_url = it->second.string();
   }
-  it = json.object_value().find("credential_source");
-  if (it == json.object_value().end()) {
+  it = json.object().find("credential_source");
+  if (it == json.object().end()) {
     *error = GRPC_ERROR_CREATE("credential_source field not present.");
     return nullptr;
   }
   options.credential_source = it->second;
-  it = json.object_value().find("quota_project_id");
-  if (it != json.object_value().end()) {
-    options.quota_project_id = it->second.string_value();
+  it = json.object().find("quota_project_id");
+  if (it != json.object().end()) {
+    options.quota_project_id = it->second.string();
   }
-  it = json.object_value().find("client_id");
-  if (it != json.object_value().end()) {
-    options.client_id = it->second.string_value();
+  it = json.object().find("client_id");
+  if (it != json.object().end()) {
+    options.client_id = it->second.string();
   }
-  it = json.object_value().find("client_secret");
-  if (it != json.object_value().end()) {
-    options.client_secret = it->second.string_value();
+  it = json.object().find("client_secret");
+  if (it != json.object().end()) {
+    options.client_secret = it->second.string();
   }
-  it = json.object_value().find("workforce_pool_user_project");
-  if (it != json.object_value().end()) {
+  it = json.object().find("workforce_pool_user_project");
+  if (it != json.object().end()) {
     if (MatchWorkforcePoolAudience(options.audience)) {
-      options.workforce_pool_user_project = it->second.string_value();
+      options.workforce_pool_user_project = it->second.string();
     } else {
       *error = GRPC_ERROR_CREATE(
           "workforce_pool_user_project should not be set for non-workforce "
@@ -196,16 +197,16 @@ RefCountedPtr<ExternalAccountCredentials> ExternalAccountCredentials::Create(
     }
   }
   RefCountedPtr<ExternalAccountCredentials> creds;
-  if (options.credential_source.object_value().find("environment_id") !=
-      options.credential_source.object_value().end()) {
+  if (options.credential_source.object().find("environment_id") !=
+      options.credential_source.object().end()) {
     creds = MakeRefCounted<AwsExternalAccountCredentials>(
         std::move(options), std::move(scopes), error);
-  } else if (options.credential_source.object_value().find("file") !=
-             options.credential_source.object_value().end()) {
+  } else if (options.credential_source.object().find("file") !=
+             options.credential_source.object().end()) {
     creds = MakeRefCounted<FileExternalAccountCredentials>(
         std::move(options), std::move(scopes), error);
-  } else if (options.credential_source.object_value().find("url") !=
-             options.credential_source.object_value().end()) {
+  } else if (options.credential_source.object().find("url") !=
+             options.credential_source.object().end()) {
     creds = MakeRefCounted<UrlExternalAccountCredentials>(
         std::move(options), std::move(scopes), error);
   } else {
@@ -331,7 +332,7 @@ void ExternalAccountCredentials::ExchangeToken(
   }
   Json addtional_options_json(std::move(addtional_options_json_object));
   body_parts.push_back(absl::StrFormat(
-      "options=%s", UrlEncode(addtional_options_json.Dump()).c_str()));
+      "options=%s", UrlEncode(JsonDump(addtional_options_json)).c_str()));
   std::string body = absl::StrJoin(body_parts, "&");
   request.body = const_cast<char*>(body.c_str());
   request.body_length = body.size();
@@ -390,25 +391,24 @@ void ExternalAccountCredentials::OnExchangeTokenInternal(
 void ExternalAccountCredentials::ImpersenateServiceAccount() {
   absl::string_view response_body(ctx_->response.body,
                                   ctx_->response.body_length);
-  auto json = Json::Parse(response_body);
+  auto json = JsonParse(response_body);
   if (!json.ok()) {
     FinishTokenFetch(GRPC_ERROR_CREATE(absl::StrCat(
         "Invalid token exchange response: ", json.status().ToString())));
     return;
   }
-  if (json->type() != Json::Type::OBJECT) {
+  if (json->type() != Json::Type::kObject) {
     FinishTokenFetch(GRPC_ERROR_CREATE(
         "Invalid token exchange response: JSON type is not object"));
     return;
   }
-  auto it = json->object_value().find("access_token");
-  if (it == json->object_value().end() ||
-      it->second.type() != Json::Type::STRING) {
+  auto it = json->object().find("access_token");
+  if (it == json->object().end() || it->second.type() != Json::Type::kString) {
     FinishTokenFetch(GRPC_ERROR_CREATE(absl::StrFormat(
         "Missing or invalid access_token in %s.", response_body)));
     return;
   }
-  std::string access_token = it->second.string_value();
+  std::string access_token = it->second.string();
   absl::StatusOr<URI> uri =
       URI::Parse(options_.service_account_impersonation_url);
   if (!uri.ok()) {
@@ -468,35 +468,33 @@ void ExternalAccountCredentials::OnImpersenateServiceAccountInternal(
   }
   absl::string_view response_body(ctx_->response.body,
                                   ctx_->response.body_length);
-  auto json = Json::Parse(response_body);
+  auto json = JsonParse(response_body);
   if (!json.ok()) {
     FinishTokenFetch(GRPC_ERROR_CREATE(
         absl::StrCat("Invalid service account impersonation response: ",
                      json.status().ToString())));
     return;
   }
-  if (json->type() != Json::Type::OBJECT) {
+  if (json->type() != Json::Type::kObject) {
     FinishTokenFetch(
         GRPC_ERROR_CREATE("Invalid service account impersonation response: "
                           "JSON type is not object"));
     return;
   }
-  auto it = json->object_value().find("accessToken");
-  if (it == json->object_value().end() ||
-      it->second.type() != Json::Type::STRING) {
+  auto it = json->object().find("accessToken");
+  if (it == json->object().end() || it->second.type() != Json::Type::kString) {
     FinishTokenFetch(GRPC_ERROR_CREATE(absl::StrFormat(
         "Missing or invalid accessToken in %s.", response_body)));
     return;
   }
-  std::string access_token = it->second.string_value();
-  it = json->object_value().find("expireTime");
-  if (it == json->object_value().end() ||
-      it->second.type() != Json::Type::STRING) {
+  std::string access_token = it->second.string();
+  it = json->object().find("expireTime");
+  if (it == json->object().end() || it->second.type() != Json::Type::kString) {
     FinishTokenFetch(GRPC_ERROR_CREATE(absl::StrFormat(
         "Missing or invalid expireTime in %s.", response_body)));
     return;
   }
-  std::string expire_time = it->second.string_value();
+  std::string expire_time = it->second.string();
   absl::Time t;
   if (!absl::ParseTime(absl::RFC3339_full, expire_time, &t, nullptr)) {
     FinishTokenFetch(GRPC_ERROR_CREATE(
@@ -540,7 +538,7 @@ void ExternalAccountCredentials::FinishTokenFetch(grpc_error_handle error) {
 
 grpc_call_credentials* grpc_external_account_credentials_create(
     const char* json_string, const char* scopes_string) {
-  auto json = grpc_core::Json::Parse(json_string);
+  auto json = grpc_core::JsonParse(json_string);
   if (!json.ok()) {
     gpr_log(GPR_ERROR,
             "External account credentials creation failed. Error: %s.",