grpc 1.27.0 → 1.28.0.pre2

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

@@ -28,6 +28,8 @@ namespace grpc_core {
 
 class LoadBalancingPolicyFactory {
  public:
+  virtual ~LoadBalancingPolicyFactory() {}
+
   /// Returns a new LB policy instance.
   virtual OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
       LoadBalancingPolicy::Args) const = 0;
@@ -37,9 +39,7 @@ class LoadBalancingPolicyFactory {
   virtual const char* name() const = 0;
 
   virtual RefCountedPtr<LoadBalancingPolicy::Config> ParseLoadBalancingConfig(
-      const grpc_json* json, grpc_error** error) const = 0;
-
-  virtual ~LoadBalancingPolicyFactory() {}
+      const Json& json, grpc_error** error) const = 0;
 };
 
 }  // namespace grpc_core

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

@@ -105,106 +105,74 @@ bool LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(
     grpc_error* error = GRPC_ERROR_NONE;
     // Check if the load balancing policy allows an empty config
     *requires_config =
-        factory->ParseLoadBalancingConfig(nullptr, &error) == nullptr;
+        factory->ParseLoadBalancingConfig(Json(), &error) == nullptr;
     GRPC_ERROR_UNREF(error);
   }
   return true;
 }
 
 namespace {
+
 // Returns the JSON node of policy (with both policy name and config content)
 // given the JSON node of a LoadBalancingConfig array.
-grpc_json* ParseLoadBalancingConfigHelper(const grpc_json* lb_config_array,
-                                          grpc_error** error) {
-  GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
-  if (lb_config_array == nullptr) {
-    *error =
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("LB config JSON tree is null");
-    return nullptr;
+grpc_error* ParseLoadBalancingConfigHelper(
+    const Json& lb_config_array, Json::Object::const_iterator* result) {
+  if (lb_config_array.type() != Json::Type::ARRAY) {
+    return GRPC_ERROR_CREATE_FROM_STATIC_STRING("type should be array");
   }
-  char* error_msg;
-  if (lb_config_array->type != GRPC_JSON_ARRAY) {
-    gpr_asprintf(&error_msg, "field:%s error:type should be array",
-                 lb_config_array->key);
-    *error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_msg);
-    gpr_free(error_msg);
-    return nullptr;
-  }
-  const char* field_name = lb_config_array->key;
   // Find the first LB policy that this client supports.
-  for (const grpc_json* lb_config = lb_config_array->child;
-       lb_config != nullptr; lb_config = lb_config->next) {
-    if (lb_config->type != GRPC_JSON_OBJECT) {
-      gpr_asprintf(&error_msg,
-                   "field:%s error:child entry should be of type object",
-                   field_name);
-      *error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_msg);
-      gpr_free(error_msg);
-      return nullptr;
+  for (const Json& lb_config : lb_config_array.array_value()) {
+    if (lb_config.type() != Json::Type::OBJECT) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "child entry should be of type object");
     }
-    grpc_json* policy = nullptr;
-    for (grpc_json* field = lb_config->child; field != nullptr;
-         field = field->next) {
-      if (field->key == nullptr || field->type != GRPC_JSON_OBJECT) {
-        gpr_asprintf(&error_msg,
-                     "field:%s error:child entry should be of type object",
-                     field_name);
-        *error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_msg);
-        gpr_free(error_msg);
-        return nullptr;
-      }
-      if (policy != nullptr) {
-        gpr_asprintf(&error_msg, "field:%s error:oneOf violation", field_name);
-        *error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_msg);
-        gpr_free(error_msg);
-        return nullptr;
-      }  // Violate "oneof" type.
-      policy = field;
+    if (lb_config.object_value().empty()) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "no policy found in child entry");
+    }
+    if (lb_config.object_value().size() > 1) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING("oneOf violation");
     }
-    if (policy == nullptr) {
-      gpr_asprintf(&error_msg, "field:%s error:no policy found in child entry",
-                   field_name);
-      *error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_msg);
-      gpr_free(error_msg);
-      return nullptr;
+    auto it = lb_config.object_value().begin();
+    if (it->second.type() != Json::Type::OBJECT) {
+      return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "child entry should be of type object");
     }
     // If we support this policy, then select it.
-    if (LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(policy->key,
-                                                               nullptr)) {
-      return policy;
+    if (LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(
+            it->first.c_str(), nullptr)) {
+      *result = it;
+      return GRPC_ERROR_NONE;
     }
   }
-  gpr_asprintf(&error_msg, "field:%s error:No known policy", field_name);
-  *error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_msg);
-  gpr_free(error_msg);
-  return nullptr;
+  return GRPC_ERROR_CREATE_FROM_STATIC_STRING("No known policy");
 }
+
 }  // namespace
 
 RefCountedPtr<LoadBalancingPolicy::Config>
-LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(const grpc_json* json,
+LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(const Json& json,
                                                       grpc_error** error) {
   GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
   GPR_ASSERT(g_state != nullptr);
-  const grpc_json* policy = ParseLoadBalancingConfigHelper(json, error);
-  if (policy == nullptr) {
+  Json::Object::const_iterator policy;
+  *error = ParseLoadBalancingConfigHelper(json, &policy);
+  if (*error != GRPC_ERROR_NONE) {
+    return nullptr;
+  }
+  // Find factory.
+  LoadBalancingPolicyFactory* factory =
+      g_state->GetLoadBalancingPolicyFactory(policy->first.c_str());
+  if (factory == nullptr) {
+    char* msg;
+    gpr_asprintf(&msg, "Factory not found for policy \"%s\"",
+                 policy->first.c_str());
+    *error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
+    gpr_free(msg);
     return nullptr;
-  } else {
-    GPR_DEBUG_ASSERT(*error == GRPC_ERROR_NONE && json != nullptr);
-    // Find factory.
-    LoadBalancingPolicyFactory* factory =
-        g_state->GetLoadBalancingPolicyFactory(policy->key);
-    if (factory == nullptr) {
-      char* msg;
-      gpr_asprintf(&msg, "field:%s error:Factory not found to create policy",
-                   json->key);
-      *error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
-      gpr_free(msg);
-      return nullptr;
-    }
-    // Parse load balancing config via factory.
-    return factory->ParseLoadBalancingConfig(policy, error);
   }
+  // Parse load balancing config via factory.
+  return factory->ParseLoadBalancingConfig(policy->second, error);
 }
 
 }  // namespace grpc_core

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

@@ -57,7 +57,7 @@ class LoadBalancingPolicyRegistry {
   /// Returns a parsed object of the load balancing policy to be used from a
   /// LoadBalancingConfig array \a json.
   static RefCountedPtr<LoadBalancingPolicy::Config> ParseLoadBalancingConfig(
-      const grpc_json* json, grpc_error** error);
+      const Json& json, grpc_error** error);
 };
 
 }  // namespace grpc_core

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

@@ -223,104 +223,92 @@ void AresDnsResolver::OnNextResolutionLocked(void* arg, grpc_error* error) {
   r->Unref(DEBUG_LOCATION, "next_resolution_timer");
 }
 
-bool ValueInJsonArray(grpc_json* array, const char* value) {
-  for (grpc_json* entry = array->child; entry != nullptr; entry = entry->next) {
-    if (entry->type == GRPC_JSON_STRING && strcmp(entry->value, value) == 0) {
+bool ValueInJsonArray(const Json::Array& array, const char* value) {
+  for (const Json& entry : array) {
+    if (entry.type() == Json::Type::STRING && entry.string_value() == value) {
       return true;
     }
   }
   return false;
 }
 
-char* ChooseServiceConfig(char* service_config_choice_json,
-                          grpc_error** error) {
-  grpc_json* choices_json = grpc_json_parse_string(service_config_choice_json);
-  if (choices_json == nullptr) {
-    *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "Service Config JSON Parsing, error: could not parse");
-    return nullptr;
-  }
-  if (choices_json->type != GRPC_JSON_ARRAY) {
+std::string ChooseServiceConfig(char* service_config_choice_json,
+                                grpc_error** error) {
+  Json json = Json::Parse(service_config_choice_json, error);
+  if (*error != GRPC_ERROR_NONE) return "";
+  if (json.type() != Json::Type::ARRAY) {
     *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "Service Config Choices, error: should be of type array");
-    return nullptr;
+    return "";
   }
-  char* service_config = nullptr;
+  const Json* service_config = nullptr;
   InlinedVector<grpc_error*, 4> error_list;
-  bool found_choice = false;  // have we found a choice?
-  for (grpc_json* choice = choices_json->child; choice != nullptr;
-       choice = choice->next) {
-    if (choice->type != GRPC_JSON_OBJECT) {
+  for (const Json& choice : json.array_value()) {
+    if (choice.type() != Json::Type::OBJECT) {
       error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
           "Service Config Choice, error: should be of type object"));
       continue;
     }
-    grpc_json* service_config_json = nullptr;
-    bool selected = true;  // has this choice been rejected?
-    for (grpc_json* field = choice->child; field != nullptr;
-         field = field->next) {
-      // Check client language, if specified.
-      if (strcmp(field->key, "clientLanguage") == 0) {
-        if (field->type != GRPC_JSON_ARRAY) {
-          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "field:clientLanguage error:should be of type array"));
-        } else if (!ValueInJsonArray(field, "c++")) {
-          selected = false;
-        }
+    // Check client language, if specified.
+    auto it = choice.object_value().find("clientLanguage");
+    if (it != choice.object_value().end()) {
+      if (it->second.type() != Json::Type::ARRAY) {
+        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            "field:clientLanguage error:should be of type array"));
+      } else if (!ValueInJsonArray(it->second.array_value(), "c++")) {
+        continue;
       }
-      // Check client hostname, if specified.
-      if (strcmp(field->key, "clientHostname") == 0) {
-        if (field->type != GRPC_JSON_ARRAY) {
-          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "field:clientHostname error:should be of type array"));
-          continue;
-        }
+    }
+    // Check client hostname, if specified.
+    it = choice.object_value().find("clientHostname");
+    if (it != choice.object_value().end()) {
+      if (it->second.type() != Json::Type::ARRAY) {
+        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            "field:clientHostname error:should be of type array"));
+      } else {
         char* hostname = grpc_gethostname();
-        if (hostname == nullptr || !ValueInJsonArray(field, hostname)) {
-          selected = false;
-        }
-      }
-      // Check percentage, if specified.
-      if (strcmp(field->key, "percentage") == 0) {
-        if (field->type != GRPC_JSON_NUMBER) {
-          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "field:percentage error:should be of type number"));
+        if (hostname == nullptr ||
+            !ValueInJsonArray(it->second.array_value(), hostname)) {
           continue;
         }
+      }
+    }
+    // Check percentage, if specified.
+    it = choice.object_value().find("percentage");
+    if (it != choice.object_value().end()) {
+      if (it->second.type() != Json::Type::NUMBER) {
+        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            "field:percentage error:should be of type number"));
+      } else {
         int random_pct = rand() % 100;
         int percentage;
-        if (sscanf(field->value, "%d", &percentage) != 1) {
+        if (sscanf(it->second.string_value().c_str(), "%d", &percentage) != 1) {
           error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
               "field:percentage error:should be of type integer"));
+        } else if (random_pct > percentage || percentage == 0) {
           continue;
         }
-        if (random_pct > percentage || percentage == 0) {
-          selected = false;
-        }
-      }
-      // Save service config.
-      if (strcmp(field->key, "serviceConfig") == 0) {
-        if (field->type == GRPC_JSON_OBJECT) {
-          service_config_json = field;
-        } else {
-          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "field:serviceConfig error:should be of type object"));
-        }
       }
     }
-    if (!found_choice && selected && service_config_json != nullptr) {
-      service_config = grpc_json_dump_to_string(service_config_json, 0);
-      found_choice = true;
+    // Found service config.
+    it = choice.object_value().find("serviceConfig");
+    if (it == choice.object_value().end()) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:serviceConfig error:required field missing"));
+    } else if (it->second.type() != Json::Type::OBJECT) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:serviceConfig error:should be of type object"));
+    } else if (service_config == nullptr) {
+      service_config = &it->second;
     }
   }
-  grpc_json_destroy(choices_json);
   if (!error_list.empty()) {
-    gpr_free(service_config);
     service_config = nullptr;
     *error = GRPC_ERROR_CREATE_FROM_VECTOR("Service Config Choices Parser",
                                            &error_list);
   }
-  return service_config;
+  if (service_config == nullptr) return "";
+  return service_config->Dump();
 }
 
 void AresDnsResolver::OnResolved(void* arg, grpc_error* error) {
@@ -344,17 +332,16 @@ void AresDnsResolver::OnResolvedLocked(void* arg, grpc_error* error) {
     Result result;
     result.addresses = std::move(*r->addresses_);
     if (r->service_config_json_ != nullptr) {
-      char* service_config_string = ChooseServiceConfig(
+      std::string service_config_string = ChooseServiceConfig(
           r->service_config_json_, &result.service_config_error);
       gpr_free(r->service_config_json_);
       if (result.service_config_error == GRPC_ERROR_NONE &&
-          service_config_string != nullptr) {
+          !service_config_string.empty()) {
         GRPC_CARES_TRACE_LOG("resolver:%p selected service config choice: %s",
-                             r, service_config_string);
+                             r, service_config_string.c_str());
         result.service_config = ServiceConfig::Create(
             service_config_string, &result.service_config_error);
       }
-      gpr_free(service_config_string);
     }
     result.args = grpc_channel_args_copy(r->channel_args_);
     r->result_handler()->ReturnResult(std::move(result));
@@ -512,7 +499,7 @@ void grpc_resolver_dns_ares_init() {
     }
     grpc_set_resolver_impl(&ares_resolver);
     grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
-        grpc_core::MakeUnique<grpc_core::AresDnsResolverFactory>());
+        absl::make_unique<grpc_core::AresDnsResolverFactory>());
   } else {
     g_use_ares_dns_resolver = false;
   }

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

@@ -173,7 +173,7 @@ class GrpcPolledFdFactoryLibuv : public GrpcPolledFdFactory {
 
 std::unique_ptr<GrpcPolledFdFactory> NewGrpcPolledFdFactory(
     Combiner* combiner) {
-  return MakeUnique<GrpcPolledFdFactoryLibuv>();
+  return absl::make_unique<GrpcPolledFdFactoryLibuv>();
 }
 
 }  // namespace grpc_core

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

@@ -99,7 +99,7 @@ class GrpcPolledFdFactoryPosix : public GrpcPolledFdFactory {
 
 std::unique_ptr<GrpcPolledFdFactory> NewGrpcPolledFdFactory(
     Combiner* /*combiner*/) {
-  return MakeUnique<GrpcPolledFdFactoryPosix>();
+  return absl::make_unique<GrpcPolledFdFactoryPosix>();
 }
 
 }  // namespace grpc_core

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

@@ -934,7 +934,7 @@ class GrpcPolledFdFactoryWindows : public GrpcPolledFdFactory {
 
 std::unique_ptr<GrpcPolledFdFactory> NewGrpcPolledFdFactory(
     Combiner* combiner) {
-  return MakeUnique<GrpcPolledFdFactoryWindows>(combiner);
+  return absl::make_unique<GrpcPolledFdFactoryWindows>(combiner);
 }
 
 }  // namespace grpc_core

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

@@ -185,7 +185,7 @@ static void on_hostbyname_done_locked(void* arg, int status, int /*timeouts*/,
         "request:%p on_hostbyname_done_locked host=%s ARES_SUCCESS", r,
         hr->host);
     if (*r->addresses_out == nullptr) {
-      *r->addresses_out = grpc_core::MakeUnique<ServerAddressList>();
+      *r->addresses_out = absl::make_unique<ServerAddressList>();
     }
     ServerAddressList& addresses = **r->addresses_out;
     for (size_t i = 0; hostent->h_addr_list[i] != nullptr; ++i) {
@@ -480,7 +480,7 @@ static bool inner_resolve_as_ip_literal_locked(
       grpc_parse_ipv6_hostport(hostport->get(), &addr,
                                false /* log errors */)) {
     GPR_ASSERT(*addrs == nullptr);
-    *addrs = grpc_core::MakeUnique<ServerAddressList>();
+    *addrs = absl::make_unique<ServerAddressList>();
     (*addrs)->emplace_back(addr.addr, addr.len, nullptr /* args */);
     return true;
   }
@@ -543,7 +543,7 @@ static bool inner_maybe_resolve_localhost_manually_locked(
   }
   if (gpr_stricmp(host->get(), "localhost") == 0) {
     GPR_ASSERT(*addrs == nullptr);
-    *addrs = grpc_core::MakeUnique<grpc_core::ServerAddressList>();
+    *addrs = absl::make_unique<grpc_core::ServerAddressList>();
     uint16_t numeric_port = grpc_strhtons(port->get());
     // Append the ipv6 loopback address.
     struct sockaddr_in6 ipv6_loopback_addr;

data/src/core/ext/filters/client_channel/resolver/dns/native/dns_resolver.cc

@@ -305,7 +305,7 @@ void grpc_resolver_dns_native_init() {
   if (gpr_stricmp(resolver.get(), "native") == 0) {
     gpr_log(GPR_DEBUG, "Using native dns resolver");
     grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
-        grpc_core::MakeUnique<grpc_core::NativeDnsResolverFactory>());
+        absl::make_unique<grpc_core::NativeDnsResolverFactory>());
   } else {
     grpc_core::ResolverRegistry::Builder::InitRegistry();
     grpc_core::ResolverFactory* existing_factory =
@@ -313,7 +313,7 @@ void grpc_resolver_dns_native_init() {
     if (existing_factory == nullptr) {
       gpr_log(GPR_DEBUG, "Using native dns resolver");
       grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
-          grpc_core::MakeUnique<grpc_core::NativeDnsResolverFactory>());
+          absl::make_unique<grpc_core::NativeDnsResolverFactory>());
     }
   }
 }

data/src/core/ext/filters/client_channel/resolver/fake/fake_resolver.cc

@@ -386,7 +386,7 @@ class FakeResolverFactory : public ResolverFactory {
 
 void grpc_resolver_fake_init() {
   grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
-      grpc_core::MakeUnique<grpc_core::FakeResolverFactory>());
+      absl::make_unique<grpc_core::FakeResolverFactory>());
 }
 
 void grpc_resolver_fake_shutdown() {}