grpc 1.55.0 → 1.56.0.pre3

data/src/core/ext/transport/chttp2/transport/flow_control.cc

@@ -21,7 +21,6 @@
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
 
 #include <inttypes.h>
-#include <limits.h>
 
 #include <algorithm>
 #include <cmath>
@@ -245,7 +244,7 @@ TransportFlowControl::TargetInitialWindowSizeBasedOnMemoryPressureAndBdp()
   //
   //          ▲
   //          │
-  // 16mb ────┤---------x----
+  //  4mb ────┤---------x----
   //          │              -----
   //  BDP ────┤                   ----x---
   //          │                           ----
@@ -260,7 +259,8 @@ TransportFlowControl::TargetInitialWindowSizeBasedOnMemoryPressureAndBdp()
   //                                                                pressure
   const double kAnythingGoesPressure = 0.2;
   const double kAdjustedToBdpPressure = 0.5;
-  const double kAnythingGoesWindow = std::max(double{1 << 24}, bdp);
+  const double kOneMegabyte = 1024.0 * 1024.0;
+  const double kAnythingGoesWindow = std::max(4.0 * kOneMegabyte, bdp);
   if (memory_pressure < kAnythingGoesPressure) {
     return kAnythingGoesWindow;
   } else if (memory_pressure < kAdjustedToBdpPressure) {
@@ -278,45 +278,33 @@ void TransportFlowControl::UpdateSetting(
     uint32_t new_desired_value, FlowControlAction* action,
     FlowControlAction& (FlowControlAction::*set)(FlowControlAction::Urgency,
                                                  uint32_t)) {
-  if (IsFlowControlFixesEnabled()) {
-    new_desired_value =
-        Clamp(new_desired_value, grpc_chttp2_settings_parameters[id].min_value,
-              grpc_chttp2_settings_parameters[id].max_value);
-    if (new_desired_value != *desired_value) {
-      if (grpc_flowctl_trace.enabled()) {
-        gpr_log(GPR_INFO, "[flowctl] UPDATE SETTING %s from %" PRId64 " to %d",
-                grpc_chttp2_settings_parameters[id].name, *desired_value,
-                new_desired_value);
-      }
-      // Reaching zero can only happen for initial window size, and if it occurs
-      // we really want to wake up writes and ensure all the queued stream
-      // window updates are flushed, since stream flow control operates
-      // differently at zero window size.
-      FlowControlAction::Urgency urgency =
-          FlowControlAction::Urgency::QUEUE_UPDATE;
-      if (*desired_value == 0 || new_desired_value == 0) {
-        urgency = FlowControlAction::Urgency::UPDATE_IMMEDIATELY;
-      }
-      *desired_value = new_desired_value;
-      (action->*set)(urgency, *desired_value);
+  new_desired_value =
+      Clamp(new_desired_value, grpc_chttp2_settings_parameters[id].min_value,
+            grpc_chttp2_settings_parameters[id].max_value);
+  if (new_desired_value != *desired_value) {
+    if (grpc_flowctl_trace.enabled()) {
+      gpr_log(GPR_INFO, "[flowctl] UPDATE SETTING %s from %" PRId64 " to %d",
+              grpc_chttp2_settings_parameters[id].name, *desired_value,
+              new_desired_value);
     }
-  } else {
-    int64_t delta = new_desired_value - *desired_value;
-    // TODO(ncteisen): tune this
-    if (delta != 0 &&
-        (delta <= -*desired_value / 5 || delta >= *desired_value / 5)) {
-      *desired_value = new_desired_value;
-      (action->*set)(FlowControlAction::Urgency::QUEUE_UPDATE,
-                     static_cast<uint32_t>(*desired_value));
+    // Reaching zero can only happen for initial window size, and if it occurs
+    // we really want to wake up writes and ensure all the queued stream
+    // window updates are flushed, since stream flow control operates
+    // differently at zero window size.
+    FlowControlAction::Urgency urgency =
+        FlowControlAction::Urgency::QUEUE_UPDATE;
+    if (*desired_value == 0 || new_desired_value == 0) {
+      urgency = FlowControlAction::Urgency::UPDATE_IMMEDIATELY;
     }
+    *desired_value = new_desired_value;
+    (action->*set)(urgency, *desired_value);
   }
 }
 
 FlowControlAction TransportFlowControl::SetAckedInitialWindow(uint32_t value) {
   acked_init_window_ = value;
   FlowControlAction action;
-  if (IsFlowControlFixesEnabled() &&
-      acked_init_window_ != target_initial_window_size_) {
+  if (acked_init_window_ != target_initial_window_size_) {
     FlowControlAction::Urgency urgency =
         FlowControlAction::Urgency::QUEUE_UPDATE;
     if (acked_init_window_ == 0 || target_initial_window_size_ == 0) {
@@ -330,68 +318,31 @@ FlowControlAction TransportFlowControl::SetAckedInitialWindow(uint32_t value) {
 FlowControlAction TransportFlowControl::PeriodicUpdate() {
   FlowControlAction action;
   if (enable_bdp_probe_) {
-    if (IsFlowControlFixesEnabled()) {
-      // get bdp estimate and update initial_window accordingly.
-      // target might change based on how much memory pressure we are under
-      // TODO(ncteisen): experiment with setting target to be huge under low
-      // memory pressure.
-      uint32_t target = static_cast<uint32_t>(RoundUpToPowerOf2(
-          Clamp(IsMemoryPressureControllerEnabled()
-                    ? TargetInitialWindowSizeBasedOnMemoryPressureAndBdp()
-                    : pow(2, SmoothLogBdp(TargetLogBdp())),
-                0.0, static_cast<double>(kMaxInitialWindowSize))));
-      if (target < kMinPositiveInitialWindowSize) target = 0;
-      if (g_test_only_transport_target_window_estimates_mocker != nullptr) {
-        // Hook for simulating unusual flow control situations in tests.
-        target = g_test_only_transport_target_window_estimates_mocker
-                     ->ComputeNextTargetInitialWindowSizeFromPeriodicUpdate(
-                         target_initial_window_size_ /* current target */);
-      }
-      // Though initial window 'could' drop to 0, we keep the floor at
-      // kMinInitialWindowSize
-      UpdateSetting(GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE,
-                    &target_initial_window_size_, target, &action,
-                    &FlowControlAction::set_send_initial_window_update);
-      // we target the max of BDP or bandwidth in microseconds.
-      UpdateSetting(GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE, &target_frame_size_,
-                    target, &action,
-                    &FlowControlAction::set_send_max_frame_size_update);
-    } else {
-      // get bdp estimate and update initial_window accordingly.
-      // target might change based on how much memory pressure we are under
-      // TODO(ncteisen): experiment with setting target to be huge under low
-      // memory pressure.
-      double target = IsMemoryPressureControllerEnabled()
-                          ? TargetInitialWindowSizeBasedOnMemoryPressureAndBdp()
-                          : pow(2, SmoothLogBdp(TargetLogBdp()));
-      if (g_test_only_transport_target_window_estimates_mocker != nullptr) {
-        // Hook for simulating unusual flow control situations in tests.
-        target = g_test_only_transport_target_window_estimates_mocker
-                     ->ComputeNextTargetInitialWindowSizeFromPeriodicUpdate(
-                         target_initial_window_size_ /* current target */);
-      }
-      // Though initial window 'could' drop to 0, we keep the floor at
-      // kMinInitialWindowSize
-      UpdateSetting(GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE,
-                    &target_initial_window_size_,
-                    static_cast<int32_t>(Clamp(
-                        target, static_cast<double>(kMinInitialWindowSize),
-                        static_cast<double>(kMaxInitialWindowSize))),
-                    &action,
-                    &FlowControlAction::set_send_initial_window_update);
-      // get bandwidth estimate and update max_frame accordingly.
-      double bw_dbl = bdp_estimator_.EstimateBandwidth();
-      // we target the max of BDP or bandwidth in microseconds.
-      UpdateSetting(
-          GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE, &target_frame_size_,
-          static_cast<int32_t>(
-              Clamp(std::max(static_cast<int32_t>(Clamp(
-                                 bw_dbl, 0.0, static_cast<double>(INT_MAX))) /
-                                 1000,
-                             static_cast<int32_t>(target_initial_window_size_)),
-                    16384, 16777215)),
-          &action, &FlowControlAction::set_send_max_frame_size_update);
+    // get bdp estimate and update initial_window accordingly.
+    // target might change based on how much memory pressure we are under
+    // TODO(ncteisen): experiment with setting target to be huge under low
+    // memory pressure.
+    uint32_t target = static_cast<uint32_t>(RoundUpToPowerOf2(
+        Clamp(IsMemoryPressureControllerEnabled()
+                  ? TargetInitialWindowSizeBasedOnMemoryPressureAndBdp()
+                  : pow(2, SmoothLogBdp(TargetLogBdp())),
+              0.0, static_cast<double>(kMaxInitialWindowSize))));
+    if (target < kMinPositiveInitialWindowSize) target = 0;
+    if (g_test_only_transport_target_window_estimates_mocker != nullptr) {
+      // Hook for simulating unusual flow control situations in tests.
+      target = g_test_only_transport_target_window_estimates_mocker
+                   ->ComputeNextTargetInitialWindowSizeFromPeriodicUpdate(
+                       target_initial_window_size_ /* current target */);
     }
+    // Though initial window 'could' drop to 0, we keep the floor at
+    // kMinInitialWindowSize
+    UpdateSetting(GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE,
+                  &target_initial_window_size_, target, &action,
+                  &FlowControlAction::set_send_initial_window_update);
+    // we target the max of BDP or bandwidth in microseconds.
+    UpdateSetting(GRPC_CHTTP2_SETTINGS_MAX_FRAME_SIZE, &target_frame_size_,
+                  target, &action,
+                  &FlowControlAction::set_send_max_frame_size_update);
 
     if (IsTcpFrameSizeTuningEnabled()) {
       // Advertise PREFERRED_RECEIVE_CRYPTO_FRAME_SIZE to peer. By advertising

data/src/core/ext/transport/chttp2/transport/internal.h

@@ -244,21 +244,7 @@ typedef enum {
   GRPC_CHTTP2_KEEPALIVE_STATE_DISABLED,
 } grpc_chttp2_keepalive_state;
 
-struct grpc_chttp2_transport
-// TODO(ctiller): #31319 fixed a crash on Linux & Mac whereby iomgr was
-// accessed after shutdown by chttp2. We've not seen similar behavior on
-// Windows afaik, but this fix has exposed another refcounting bug whereby
-// transports leak on Windows and prevent test shutdown.
-// This hack attempts to compromise between two things that are blocking our CI
-// from giving us a good quality signal, but are unlikely to be problems for
-// most customers. We should continue tracking down what's causing the failure,
-// but this gives us some runway to do so - and given that we're actively
-// working on removing the problematic code paths, it may be that effort brings
-// the result we need.
-#ifndef GPR_WINDOWS
-    : public grpc_core::KeepsGrpcInitialized
-#endif
-{
+struct grpc_chttp2_transport : public grpc_core::KeepsGrpcInitialized {
   grpc_chttp2_transport(const grpc_core::ChannelArgs& channel_args,
                         grpc_endpoint* ep, bool is_client);
   ~grpc_chttp2_transport();

data/src/core/ext/upb-generated/xds/data/orca/v3/orca_load_report.upb.c

@@ -22,7 +22,7 @@ static const upb_MiniTableSub xds_data_orca_v3_OrcaLoadReport_submsgs[3] = {
   {.submsg = &xds_data_orca_v3_OrcaLoadReport_NamedMetricsEntry_msg_init},
 };
 
-static const upb_MiniTableField xds_data_orca_v3_OrcaLoadReport__fields[8] = {
+static const upb_MiniTableField xds_data_orca_v3_OrcaLoadReport__fields[9] = {
   {1, UPB_SIZE(16, 0), 0, kUpb_NoSub, 1, kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
   {2, UPB_SIZE(24, 8), 0, kUpb_NoSub, 1, kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
   {3, UPB_SIZE(32, 16), 0, kUpb_NoSub, 4, kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
@@ -31,12 +31,13 @@ static const upb_MiniTableField xds_data_orca_v3_OrcaLoadReport__fields[8] = {
   {6, 40, 0, kUpb_NoSub, 1, kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
   {7, 48, 0, kUpb_NoSub, 1, kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
   {8, UPB_SIZE(8, 56), 0, 2, 11, kUpb_FieldMode_Map | (UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
+  {9, UPB_SIZE(56, 64), 0, kUpb_NoSub, 1, kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)},
 };
 
 const upb_MiniTable xds_data_orca_v3_OrcaLoadReport_msg_init = {
   &xds_data_orca_v3_OrcaLoadReport_submsgs[0],
   &xds_data_orca_v3_OrcaLoadReport__fields[0],
-  UPB_SIZE(56, 64), 8, kUpb_ExtMode_NonExtendable, 8, UPB_FASTTABLE_MASK(56), 0,
+  UPB_SIZE(64, 72), 9, kUpb_ExtMode_NonExtendable, 9, UPB_FASTTABLE_MASK(120), 0,
   UPB_FASTTABLE_INIT({
     {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
     {0x000000003f000009, &upb_psf8_1bt},
@@ -46,6 +47,14 @@ const upb_MiniTable xds_data_orca_v3_OrcaLoadReport_msg_init = {
     {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
     {0x002800003f000031, &upb_psf8_1bt},
     {0x003000003f000039, &upb_psf8_1bt},
+    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+    {0x004000003f000049, &upb_psf8_1bt},
+    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
   })
 };
 

data/src/core/ext/upb-generated/xds/data/orca/v3/orca_load_report.upb.h

@@ -189,6 +189,17 @@ UPB_INLINE const xds_data_orca_v3_OrcaLoadReport_NamedMetricsEntry* xds_data_orc
   if (!map) return NULL;
   return (const xds_data_orca_v3_OrcaLoadReport_NamedMetricsEntry*)_upb_map_next(map, iter);
 }
+UPB_INLINE void xds_data_orca_v3_OrcaLoadReport_clear_application_utilization(xds_data_orca_v3_OrcaLoadReport* msg) {
+  const upb_MiniTableField field = {9, UPB_SIZE(56, 64), 0, kUpb_NoSub, 1, kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)};
+  _upb_Message_ClearNonExtensionField(msg, &field);
+}
+UPB_INLINE double xds_data_orca_v3_OrcaLoadReport_application_utilization(const xds_data_orca_v3_OrcaLoadReport* msg) {
+  double default_val = 0;
+  double ret;
+  const upb_MiniTableField field = {9, UPB_SIZE(56, 64), 0, kUpb_NoSub, 1, kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)};
+  _upb_Message_GetNonExtensionField(msg, &field, &default_val, &ret);
+  return ret;
+}
 
 UPB_INLINE void xds_data_orca_v3_OrcaLoadReport_set_cpu_utilization(xds_data_orca_v3_OrcaLoadReport *msg, double value) {
   const upb_MiniTableField field = {1, UPB_SIZE(16, 0), 0, kUpb_NoSub, 1, kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)};
@@ -282,6 +293,10 @@ UPB_INLINE xds_data_orca_v3_OrcaLoadReport_NamedMetricsEntry* xds_data_orca_v3_O
   if (!map) return NULL;
   return (xds_data_orca_v3_OrcaLoadReport_NamedMetricsEntry*)_upb_map_next(map, iter);
 }
+UPB_INLINE void xds_data_orca_v3_OrcaLoadReport_set_application_utilization(xds_data_orca_v3_OrcaLoadReport *msg, double value) {
+  const upb_MiniTableField field = {9, UPB_SIZE(56, 64), 0, kUpb_NoSub, 1, kUpb_FieldMode_Scalar | (kUpb_FieldRep_8Byte << kUpb_FieldRep_Shift)};
+  _upb_Message_SetNonExtensionField(msg, &field, &value);
+}
 
 /* xds.data.orca.v3.OrcaLoadReport.RequestCostEntry */
 

data/src/core/ext/xds/certificate_provider_store.cc

@@ -22,11 +22,10 @@
 
 #include "absl/strings/str_cat.h"
 
+#include <grpc/support/json.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/gprpp/status_helper.h"
-#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/security/certificate_provider/certificate_provider_registry.h"
 
 namespace grpc_core {
@@ -45,7 +44,7 @@ CertificateProviderStore::PluginDefinition::JsonLoader(const JsonArgs&) {
 }
 
 void CertificateProviderStore::PluginDefinition::JsonPostLoad(
-    const Json& json, const JsonArgs&, ValidationErrors* errors) {
+    const Json& json, const JsonArgs& args, ValidationErrors* errors) {
   // Check that plugin is supported.
   CertificateProviderFactory* factory = nullptr;
   if (!plugin_name.empty()) {
@@ -75,12 +74,8 @@ void CertificateProviderStore::PluginDefinition::JsonPostLoad(
     }
     if (factory == nullptr) return;
     // Use plugin to validate and parse config.
-    grpc_error_handle parse_error;
-    config =
-        factory->CreateCertificateProviderConfig(config_json, &parse_error);
-    if (!parse_error.ok()) {
-      errors->AddError(StatusToString(parse_error));
-    }
+    config = factory->CreateCertificateProviderConfig(
+        Json::FromObject(std::move(config_json)), args, errors);
   }
 }
 

data/src/core/ext/xds/certificate_provider_store.h

@@ -55,7 +55,7 @@ class CertificateProviderStore
     RefCountedPtr<CertificateProviderFactory::Config> config;
 
     static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
-    void JsonPostLoad(const Json& json, const JsonArgs&,
+    void JsonPostLoad(const Json& json, const JsonArgs& args,
                       ValidationErrors* errors);
   };
 

data/src/core/ext/xds/file_watcher_certificate_provider_factory.cc

@@ -22,6 +22,7 @@
 
 #include <algorithm>
 #include <initializer_list>
+#include <map>
 #include <memory>
 #include <vector>
 
@@ -32,14 +33,13 @@
 #include <grpc/support/time.h>
 
 #include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/json/json_util.h"
 #include "src/core/lib/security/credentials/tls/grpc_tls_certificate_provider.h"
 
 namespace grpc_core {
 
 namespace {
 
-const char* kFileWatcherPlugin = "file_watcher";
+constexpr absl::string_view kFileWatcherPlugin = "file_watcher";
 
 }  // namespace
 
@@ -47,7 +47,7 @@ const char* kFileWatcherPlugin = "file_watcher";
 // FileWatcherCertificateProviderFactory::Config
 //
 
-const char* FileWatcherCertificateProviderFactory::Config::name() const {
+absl::string_view FileWatcherCertificateProviderFactory::Config::name() const {
   return kFileWatcherPlugin;
 }
 
@@ -71,58 +71,46 @@ std::string FileWatcherCertificateProviderFactory::Config::ToString() const {
   return absl::StrJoin(parts, "");
 }
 
-RefCountedPtr<FileWatcherCertificateProviderFactory::Config>
-FileWatcherCertificateProviderFactory::Config::Parse(const Json& config_json,
-                                                     grpc_error_handle* error) {
-  auto config = MakeRefCounted<FileWatcherCertificateProviderFactory::Config>();
-  if (config_json.type() != Json::Type::kObject) {
-    *error = GRPC_ERROR_CREATE("error:config type should be OBJECT.");
-    return nullptr;
-  }
-  std::vector<grpc_error_handle> error_list;
-  ParseJsonObjectField(config_json.object(), "certificate_file",
-                       &config->identity_cert_file_, &error_list, false);
-  ParseJsonObjectField(config_json.object(), "private_key_file",
-                       &config->private_key_file_, &error_list, false);
-  if (config->identity_cert_file_.empty() !=
-      config->private_key_file_.empty()) {
-    error_list.push_back(GRPC_ERROR_CREATE(
+const JsonLoaderInterface*
+FileWatcherCertificateProviderFactory::Config::JsonLoader(const JsonArgs&) {
+  static const auto* loader =
+      JsonObjectLoader<Config>()
+          .OptionalField("certificate_file", &Config::identity_cert_file_)
+          .OptionalField("private_key_file", &Config::private_key_file_)
+          .OptionalField("ca_certificate_file", &Config::root_cert_file_)
+          .OptionalField("refresh_interval", &Config::refresh_interval_)
+          .Finish();
+  return loader;
+}
+
+void FileWatcherCertificateProviderFactory::Config::JsonPostLoad(
+    const Json& json, const JsonArgs& /*args*/, ValidationErrors* errors) {
+  if ((json.object().find("certificate_file") == json.object().end()) !=
+      (json.object().find("private_key_file") == json.object().end())) {
+    errors->AddError(
         "fields \"certificate_file\" and \"private_key_file\" must be both set "
-        "or both unset."));
+        "or both unset");
   }
-  ParseJsonObjectField(config_json.object(), "ca_certificate_file",
-                       &config->root_cert_file_, &error_list, false);
-  if (config->identity_cert_file_.empty() && config->root_cert_file_.empty()) {
-    error_list.push_back(GRPC_ERROR_CREATE(
-        "At least one of \"certificate_file\" and \"ca_certificate_file\" must "
-        "be specified."));
-  }
-  if (!ParseJsonObjectFieldAsDuration(config_json.object(), "refresh_interval",
-                                      &config->refresh_interval_, &error_list,
-                                      false)) {
-    config->refresh_interval_ = Duration::Minutes(10);  // 10 minutes default
-  }
-  if (!error_list.empty()) {
-    *error = GRPC_ERROR_CREATE_FROM_VECTOR(
-        "Error parsing file watcher certificate provider config", &error_list);
-    return nullptr;
+  if ((json.object().find("certificate_file") == json.object().end()) &&
+      (json.object().find("ca_certificate_file") == json.object().end())) {
+    errors->AddError(
+        "at least one of \"certificate_file\" and \"ca_certificate_file\" must "
+        "be specified");
   }
-  return config;
 }
 
 //
 // FileWatcherCertificateProviderFactory
 //
 
-const char* FileWatcherCertificateProviderFactory::name() const {
+absl::string_view FileWatcherCertificateProviderFactory::name() const {
   return kFileWatcherPlugin;
 }
 
 RefCountedPtr<CertificateProviderFactory::Config>
 FileWatcherCertificateProviderFactory::CreateCertificateProviderConfig(
-    const Json& config_json, grpc_error_handle* error) {
-  return FileWatcherCertificateProviderFactory::Config::Parse(config_json,
-                                                              error);
+    const Json& config_json, const JsonArgs& args, ValidationErrors* errors) {
+  return LoadFromJson<RefCountedPtr<Config>>(config_json, args, errors);
 }
 
 RefCountedPtr<grpc_tls_certificate_provider>
@@ -130,7 +118,7 @@ FileWatcherCertificateProviderFactory::CreateCertificateProvider(
     RefCountedPtr<CertificateProviderFactory::Config> config) {
   if (config->name() != name()) {
     gpr_log(GPR_ERROR, "Wrong config type Actual:%s vs Expected:%s",
-            config->name(), name());
+            std::string(config->name()).c_str(), std::string(name()).c_str());
     return nullptr;
   }
   auto* file_watcher_config =

data/src/core/ext/xds/file_watcher_certificate_provider_factory.h

@@ -23,12 +23,16 @@
 
 #include <string>
 
+#include "absl/strings/string_view.h"
+
 #include <grpc/grpc_security.h>
 
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/time.h"
-#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/json/json.h"
+#include "src/core/lib/json/json_args.h"
+#include "src/core/lib/json/json_object_loader.h"
 #include "src/core/lib/security/certificate_provider/certificate_provider_factory.h"
 
 namespace grpc_core {
@@ -38,10 +42,7 @@ class FileWatcherCertificateProviderFactory
  public:
   class Config : public CertificateProviderFactory::Config {
    public:
-    static RefCountedPtr<Config> Parse(const Json& config_json,
-                                       grpc_error_handle* error);
-
-    const char* name() const override;
+    absl::string_view name() const override;
 
     std::string ToString() const override;
 
@@ -55,18 +56,22 @@ class FileWatcherCertificateProviderFactory
 
     Duration refresh_interval() const { return refresh_interval_; }
 
+    static const JsonLoaderInterface* JsonLoader(const JsonArgs& args);
+    void JsonPostLoad(const Json& json, const JsonArgs& args,
+                      ValidationErrors* errors);
+
    private:
     std::string identity_cert_file_;
     std::string private_key_file_;
     std::string root_cert_file_;
-    Duration refresh_interval_;
+    Duration refresh_interval_ = Duration::Minutes(10);
   };
 
-  const char* name() const override;
+  absl::string_view name() const override;
 
   RefCountedPtr<CertificateProviderFactory::Config>
-  CreateCertificateProviderConfig(const Json& config_json,
-                                  grpc_error_handle* error) override;
+  CreateCertificateProviderConfig(const Json& config_json, const JsonArgs& args,
+                                  ValidationErrors* errors) override;
 
   RefCountedPtr<grpc_tls_certificate_provider> CreateCertificateProvider(
       RefCountedPtr<CertificateProviderFactory::Config> config) override;

data/src/core/ext/xds/xds_api.cc

@@ -114,11 +114,8 @@ void PopulateMetadataValue(const XdsApiContext& context,
       google_protobuf_Value_set_string_value(
           value_pb, StdStringToUpbString(value.string()));
       break;
-    case Json::Type::kTrue:
-      google_protobuf_Value_set_bool_value(value_pb, true);
-      break;
-    case Json::Type::kFalse:
-      google_protobuf_Value_set_bool_value(value_pb, false);
+    case Json::Type::kBoolean:
+      google_protobuf_Value_set_bool_value(value_pb, value.boolean());
       break;
     case Json::Type::kObject: {
       google_protobuf_Struct* struct_value =
@@ -327,11 +324,17 @@ absl::Status XdsApi::ParseAdsResponse(absl::string_view encoded_response,
       const auto* resource_wrapper = envoy_service_discovery_v3_Resource_parse(
           serialized_resource.data(), serialized_resource.size(), arena.ptr());
       if (resource_wrapper == nullptr) {
-        parser->ResourceWrapperParsingFailed(i);
+        parser->ResourceWrapperParsingFailed(
+            i, "Can't decode Resource proto wrapper");
         continue;
       }
       const auto* resource =
           envoy_service_discovery_v3_Resource_resource(resource_wrapper);
+      if (resource == nullptr) {
+        parser->ResourceWrapperParsingFailed(
+            i, "No resource present in Resource proto wrapper");
+        continue;
+      }
       type_url = absl::StripPrefix(
           UpbStringToAbsl(google_protobuf_Any_type_url(resource)),
           "type.googleapis.com/");

data/src/core/ext/xds/xds_api.h

@@ -75,8 +75,9 @@ class XdsApi {
                                absl::string_view serialized_resource) = 0;
 
     // Called when a resource is wrapped in a Resource wrapper proto but
-    // we fail to deserialize the wrapper proto.
-    virtual void ResourceWrapperParsingFailed(size_t idx) = 0;
+    // we fail to parse the Resource wrapper.
+    virtual void ResourceWrapperParsingFailed(size_t idx,
+                                              absl::string_view message) = 0;
   };
 
   struct ClusterLoadReport {