grpc 1.41.1 → 1.44.0.pre2

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

@@ -45,13 +45,20 @@ namespace grpc_core {
 // other callbacks from other threads might also be executed before Run()
 // returns. Since an arbitrary set of callbacks might be executed when Run() is
 // called, generally no locks should be held while calling Run().
+// If a thread wants to preclude the possibility of the callback being invoked
+// inline in Run() (for example, if a mutex lock is held and executing callbacks
+// inline would cause a deadlock), it should use Schedule() instead and then
+// invoke DrainQueue() when it is safe to invoke the callback.
 class ABSL_LOCKABLE WorkSerializer {
  public:
   WorkSerializer();
 
   ~WorkSerializer();
 
-  // Runs a given callback.
+  // Runs a given callback on the work serializer. If there is no other thread
+  // currently executing the WorkSerializer, the callback is run immediately. In
+  // this case, the current thread is also borrowed for draining the queue for
+  // any callbacks that get added in the meantime.
   //
   // If you want to use clang thread annotation to make sure that callback is
   // called by WorkSerializer only, you need to add the annotation to both the
@@ -65,10 +72,15 @@ class ABSL_LOCKABLE WorkSerializer {
   //   }
   //   void callback() ABSL_EXCLUSIVE_LOCKS_REQUIRED(work_serializer) { ... }
   //
-  // TODO(yashkt): Replace grpc_core::DebugLocation with absl::SourceLocation
+  // TODO(yashkt): Replace DebugLocation with absl::SourceLocation
   // once we can start using it directly.
-  void Run(std::function<void()> callback,
-           const grpc_core::DebugLocation& location);
+  void Run(std::function<void()> callback, const DebugLocation& location);
+
+  // Schedule \a callback to be run later when the queue of callbacks is
+  // drained.
+  void Schedule(std::function<void()> callback, const DebugLocation& location);
+  // Drains the queue of callbacks.
+  void DrainQueue();
 
  private:
   class WorkSerializerImpl;

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

@@ -95,8 +95,8 @@ class JsonReader {
 
   size_t CurrentIndex() const { return input_ - original_input_ - 1; }
 
-  void StringAddChar(uint32_t c);
-  void StringAddUtf32(uint32_t c);
+  GRPC_MUST_USE_RESULT bool StringAddChar(uint32_t c);
+  GRPC_MUST_USE_RESULT bool StringAddUtf32(uint32_t c);
 
   Json* CreateAndLinkValue();
   bool StartContainer(Json::Type type);
@@ -119,6 +119,7 @@ class JsonReader {
   uint16_t unicode_high_surrogate_ = 0;
   std::vector<grpc_error_handle> errors_;
   bool truncated_errors_ = false;
+  uint8_t utf8_bytes_remaining_ = 0;
 
   Json root_value_;
   std::vector<Json*> stack_;
@@ -127,34 +128,55 @@ class JsonReader {
   std::string string_;
 };
 
-void JsonReader::StringAddChar(uint32_t c) {
+bool JsonReader::StringAddChar(uint32_t c) {
+  switch (utf8_bytes_remaining_) {
+    case 0:
+      if ((c & 0x80) == 0) {
+        utf8_bytes_remaining_ = 0;
+      } else if ((c & 0xe0) == 0xc0) {
+        utf8_bytes_remaining_ = 1;
+      } else if ((c & 0xf0) == 0xe0) {
+        utf8_bytes_remaining_ = 2;
+      } else if ((c & 0xf8) == 0xf0) {
+        utf8_bytes_remaining_ = 3;
+      } else {
+        return false;
+      }
+      break;
+    case 1:
+    case 2:
+    case 3:
+      if ((c & 0xc0) != 0x80) return false;
+      --utf8_bytes_remaining_;
+      break;
+    default:
+      abort();
+  }
   string_.push_back(static_cast<uint8_t>(c));
+  return true;
 }
 
-void JsonReader::StringAddUtf32(uint32_t c) {
+bool JsonReader::StringAddUtf32(uint32_t c) {
   if (c <= 0x7f) {
-    StringAddChar(c);
+    return StringAddChar(c);
   } else if (c <= 0x7ff) {
     uint32_t b1 = 0xc0 | ((c >> 6) & 0x1f);
     uint32_t b2 = 0x80 | (c & 0x3f);
-    StringAddChar(b1);
-    StringAddChar(b2);
+    return StringAddChar(b1) && StringAddChar(b2);
   } else if (c <= 0xffff) {
     uint32_t b1 = 0xe0 | ((c >> 12) & 0x0f);
     uint32_t b2 = 0x80 | ((c >> 6) & 0x3f);
     uint32_t b3 = 0x80 | (c & 0x3f);
-    StringAddChar(b1);
-    StringAddChar(b2);
-    StringAddChar(b3);
+    return StringAddChar(b1) && StringAddChar(b2) && StringAddChar(b3);
   } else if (c <= 0x1fffff) {
     uint32_t b1 = 0xf0 | ((c >> 18) & 0x07);
     uint32_t b2 = 0x80 | ((c >> 12) & 0x3f);
     uint32_t b3 = 0x80 | ((c >> 6) & 0x3f);
     uint32_t b4 = 0x80 | (c & 0x3f);
-    StringAddChar(b1);
-    StringAddChar(b2);
-    StringAddChar(b3);
-    StringAddChar(b4);
+    return StringAddChar(b1) && StringAddChar(b2) && StringAddChar(b3) &&
+           StringAddChar(b4);
+  } else {
+    return false;
   }
 }
 
@@ -275,6 +297,18 @@ JsonReader::Status JsonReader::Run() {
     switch (c) {
       /* Let's process the error case first. */
       case GRPC_JSON_READ_CHAR_EOF:
+        switch (state_) {
+          case State::GRPC_JSON_STATE_VALUE_NUMBER:
+          case State::GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL:
+          case State::GRPC_JSON_STATE_VALUE_NUMBER_ZERO:
+          case State::GRPC_JSON_STATE_VALUE_NUMBER_EPM:
+            if (!SetNumber()) return Status::GRPC_JSON_PARSE_ERROR;
+            state_ = State::GRPC_JSON_STATE_VALUE_END;
+            break;
+
+          default:
+            break;
+        }
         if (IsComplete()) {
           return Status::GRPC_JSON_DONE;
         }
@@ -299,7 +333,7 @@ JsonReader::Status JsonReader::Run() {
             if (unicode_high_surrogate_ != 0) {
               return Status::GRPC_JSON_PARSE_ERROR;
             }
-            StringAddChar(c);
+            if (!StringAddChar(c)) return Status::GRPC_JSON_PARSE_ERROR;
             break;
 
           case State::GRPC_JSON_STATE_VALUE_NUMBER:
@@ -325,7 +359,7 @@ JsonReader::Status JsonReader::Run() {
             if (unicode_high_surrogate_ != 0) {
               return Status::GRPC_JSON_PARSE_ERROR;
             }
-            StringAddChar(c);
+            if (!StringAddChar(c)) return Status::GRPC_JSON_PARSE_ERROR;
             break;
 
           case State::GRPC_JSON_STATE_VALUE_NUMBER:
@@ -410,7 +444,7 @@ JsonReader::Status JsonReader::Run() {
             if (unicode_high_surrogate_ != 0) {
               return Status::GRPC_JSON_PARSE_ERROR;
             }
-            StringAddChar('\\');
+            if (!StringAddChar('\\')) return Status::GRPC_JSON_PARSE_ERROR;
             if (escaped_string_was_key_) {
               state_ = State::GRPC_JSON_STATE_OBJECT_KEY_STRING;
             } else {
@@ -437,10 +471,15 @@ JsonReader::Status JsonReader::Run() {
             }
             if (c == '"') {
               state_ = State::GRPC_JSON_STATE_OBJECT_KEY_END;
+              // Once the key is parsed, there should no un-matched utf8
+              // encoded bytes.
+              if (utf8_bytes_remaining_ != 0) {
+                return Status::GRPC_JSON_PARSE_ERROR;
+              }
               SetKey();
             } else {
               if (c < 32) return Status::GRPC_JSON_PARSE_ERROR;
-              StringAddChar(c);
+              if (!StringAddChar(c)) return Status::GRPC_JSON_PARSE_ERROR;
             }
             break;
 
@@ -450,10 +489,15 @@ JsonReader::Status JsonReader::Run() {
             }
             if (c == '"') {
               state_ = State::GRPC_JSON_STATE_VALUE_END;
+              // Once the value is parsed, there should no un-matched utf8
+              // encoded bytes.
+              if (utf8_bytes_remaining_ != 0) {
+                return Status::GRPC_JSON_PARSE_ERROR;
+              }
               SetString();
             } else {
               if (c < 32) return Status::GRPC_JSON_PARSE_ERROR;
-              StringAddChar(c);
+              if (!StringAddChar(c)) return Status::GRPC_JSON_PARSE_ERROR;
             }
             break;
 
@@ -481,7 +525,7 @@ JsonReader::Status JsonReader::Run() {
                 break;
 
               case '0':
-                StringAddChar(c);
+                if (!StringAddChar(c)) return Status::GRPC_JSON_PARSE_ERROR;
                 state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_ZERO;
                 break;
 
@@ -495,7 +539,7 @@ JsonReader::Status JsonReader::Run() {
               case '8':
               case '9':
               case '-':
-                StringAddChar(c);
+                if (!StringAddChar(c)) return Status::GRPC_JSON_PARSE_ERROR;
                 state_ = State::GRPC_JSON_STATE_VALUE_NUMBER;
                 break;
 
@@ -530,22 +574,22 @@ JsonReader::Status JsonReader::Run() {
             switch (c) {
               case '"':
               case '/':
-                StringAddChar(c);
+                if (!StringAddChar(c)) return Status::GRPC_JSON_PARSE_ERROR;
                 break;
               case 'b':
-                StringAddChar('\b');
+                if (!StringAddChar('\b')) return Status::GRPC_JSON_PARSE_ERROR;
                 break;
               case 'f':
-                StringAddChar('\f');
+                if (!StringAddChar('\f')) return Status::GRPC_JSON_PARSE_ERROR;
                 break;
               case 'n':
-                StringAddChar('\n');
+                if (!StringAddChar('\n')) return Status::GRPC_JSON_PARSE_ERROR;
                 break;
               case 'r':
-                StringAddChar('\r');
+                if (!StringAddChar('\r')) return Status::GRPC_JSON_PARSE_ERROR;
                 break;
               case 't':
-                StringAddChar('\t');
+                if (!StringAddChar('\t')) return Status::GRPC_JSON_PARSE_ERROR;
                 break;
               case 'u':
                 state_ = State::GRPC_JSON_STATE_STRING_ESCAPE_U1;
@@ -602,14 +646,18 @@ JsonReader::Status JsonReader::Run() {
                   utf32 += static_cast<uint32_t>(
                       (unicode_high_surrogate_ - 0xd800) * 0x400);
                   utf32 += static_cast<uint32_t>(unicode_char_ - 0xdc00);
-                  StringAddUtf32(utf32);
+                  if (!StringAddUtf32(utf32)) {
+                    return Status::GRPC_JSON_PARSE_ERROR;
+                  }
                   unicode_high_surrogate_ = 0;
                 } else {
                   /* anything else */
                   if (unicode_high_surrogate_ != 0) {
                     return Status::GRPC_JSON_PARSE_ERROR;
                   }
-                  StringAddUtf32(unicode_char_);
+                  if (!StringAddUtf32(unicode_char_)) {
+                    return Status::GRPC_JSON_PARSE_ERROR;
+                  }
                 }
                 if (escaped_string_was_key_) {
                   state_ = State::GRPC_JSON_STATE_OBJECT_KEY_STRING;
@@ -623,7 +671,7 @@ JsonReader::Status JsonReader::Run() {
             break;
 
           case State::GRPC_JSON_STATE_VALUE_NUMBER:
-            StringAddChar(c);
+            if (!StringAddChar(c)) return Status::GRPC_JSON_PARSE_ERROR;
             switch (c) {
               case '0':
               case '1':
@@ -649,7 +697,7 @@ JsonReader::Status JsonReader::Run() {
             break;
 
           case State::GRPC_JSON_STATE_VALUE_NUMBER_WITH_DECIMAL:
-            StringAddChar(c);
+            if (!StringAddChar(c)) return Status::GRPC_JSON_PARSE_ERROR;
             switch (c) {
               case '0':
               case '1':
@@ -673,12 +721,12 @@ JsonReader::Status JsonReader::Run() {
 
           case State::GRPC_JSON_STATE_VALUE_NUMBER_ZERO:
             if (c != '.') return Status::GRPC_JSON_PARSE_ERROR;
-            StringAddChar(c);
+            if (!StringAddChar(c)) return Status::GRPC_JSON_PARSE_ERROR;
             state_ = State::GRPC_JSON_STATE_VALUE_NUMBER_DOT;
             break;
 
           case State::GRPC_JSON_STATE_VALUE_NUMBER_DOT:
-            StringAddChar(c);
+            if (!StringAddChar(c)) return Status::GRPC_JSON_PARSE_ERROR;
             switch (c) {
               case '0':
               case '1':
@@ -698,7 +746,7 @@ JsonReader::Status JsonReader::Run() {
             break;
 
           case State::GRPC_JSON_STATE_VALUE_NUMBER_E:
-            StringAddChar(c);
+            if (!StringAddChar(c)) return Status::GRPC_JSON_PARSE_ERROR;
             switch (c) {
               case '0':
               case '1':
@@ -720,7 +768,7 @@ JsonReader::Status JsonReader::Run() {
             break;
 
           case State::GRPC_JSON_STATE_VALUE_NUMBER_EPM:
-            StringAddChar(c);
+            if (!StringAddChar(c)) return Status::GRPC_JSON_PARSE_ERROR;
             switch (c) {
               case '0':
               case '1':

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

@@ -30,7 +30,7 @@ bool ParseDurationFromJson(const Json& field, grpc_millis* duration) {
   if (field.type() != Json::Type::STRING) return false;
   size_t len = field.string_value().size();
   if (field.string_value()[len - 1] != 's') return false;
-  grpc_core::UniquePtr<char> buf(gpr_strdup(field.string_value().c_str()));
+  UniquePtr<char> buf(gpr_strdup(field.string_value().c_str()));
   *(buf.get() + len - 1) = '\0';  // Remove trailing 's'.
   char* decimal_point = strchr(buf.get(), '.');
   int nanos = 0;
@@ -55,4 +55,72 @@ bool ParseDurationFromJson(const Json& field, grpc_millis* duration) {
   return true;
 }
 
+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:
+      *output = true;
+      return true;
+    case Json::Type::JSON_FALSE:
+      *output = false;
+      return true;
+    default:
+      error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
+          absl::StrCat("field:", field_name, " error:type should be BOOLEAN")));
+      return false;
+  }
+}
+
+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) {
+    *output = nullptr;
+    error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
+        absl::StrCat("field:", field_name, " error:type should be ARRAY")));
+    return false;
+  }
+  *output = &json.array_value();
+  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) {
+    *output = nullptr;
+    error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
+        absl::StrCat("field:", field_name, " error:type should be OBJECT")));
+    return false;
+  }
+  *output = &json.object_value();
+  return true;
+}
+
+bool ParseJsonObjectFieldAsDuration(const Json::Object& object,
+                                    absl::string_view field_name,
+                                    grpc_millis* output,
+                                    std::vector<grpc_error_handle>* error_list,
+                                    bool required) {
+  // TODO(roth): Once we can use C++14 heterogenous lookups, stop
+  // creating a std::string here.
+  auto it = object.find(std::string(field_name));
+  if (it == object.end()) {
+    if (required) {
+      error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
+          absl::StrCat("field:", field_name, " error:does not exist.")));
+    }
+    return false;
+  }
+  if (!ParseDurationFromJson(it->second, output)) {
+    *output = GRPC_MILLIS_INF_PAST;
+    error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
+        absl::StrCat("field:", field_name,
+                     " error:type should be STRING of the form given by "
+                     "google.proto.Duration.")));
+    return false;
+  }
+  return true;
+}
+
 }  // namespace grpc_core

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

@@ -40,10 +40,10 @@ bool ParseDurationFromJson(const Json& field, grpc_millis* duration);
 // Return true on success, false otherwise. If an error is encountered during
 // parsing, a descriptive error is appended to \a error_list.
 //
-template <typename NumericType, typename ErrorVectorType>
-inline bool ExtractJsonNumber(const Json& json, const std::string& field_name,
-                              NumericType* output,
-                              ErrorVectorType* error_list) {
+template <typename NumericType>
+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) {
     error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
@@ -58,27 +58,14 @@ inline bool ExtractJsonNumber(const Json& json, const std::string& field_name,
   return true;
 }
 
-template <typename ErrorVectorType>
-inline bool ExtractJsonBool(const Json& json, const std::string& field_name,
-                            bool* output, ErrorVectorType* error_list) {
-  switch (json.type()) {
-    case Json::Type::JSON_TRUE:
-      *output = true;
-      return true;
-    case Json::Type::JSON_FALSE:
-      *output = false;
-      return true;
-    default:
-      error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
-          absl::StrCat("field:", field_name, " error:type should be BOOLEAN")));
-      return false;
-  }
-}
+bool ExtractJsonBool(const Json& json, absl::string_view field_name,
+                     bool* output, std::vector<grpc_error_handle>* error_list);
 
-template <typename ErrorVectorType>
-inline bool ExtractJsonString(const Json& json, const std::string& field_name,
-                              std::string* output,
-                              ErrorVectorType* error_list) {
+// OutputType can be std::string or absl::string_view.
+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) {
     *output = "";
     error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
@@ -89,72 +76,61 @@ inline bool ExtractJsonString(const Json& json, const std::string& field_name,
   return true;
 }
 
-template <typename ErrorVectorType>
-inline bool ExtractJsonArray(const Json& json, const std::string& field_name,
-                             const Json::Array** output,
-                             ErrorVectorType* error_list) {
-  if (json.type() != Json::Type::ARRAY) {
-    *output = nullptr;
-    error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
-        absl::StrCat("field:", field_name, " error:type should be ARRAY")));
-    return false;
-  }
-  *output = &json.array_value();
-  return true;
-}
+bool ExtractJsonArray(const Json& json, absl::string_view field_name,
+                      const Json::Array** output,
+                      std::vector<grpc_error_handle>* error_list);
 
-template <typename ErrorVectorType>
-inline bool ExtractJsonObject(const Json& json, const std::string& field_name,
-                              const Json::Object** output,
-                              ErrorVectorType* error_list) {
-  if (json.type() != Json::Type::OBJECT) {
-    *output = nullptr;
-    error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
-        absl::StrCat("field:", field_name, " error:type should be OBJECT")));
-    return false;
-  }
-  *output = &json.object_value();
-  return true;
-}
+bool ExtractJsonObject(const Json& json, absl::string_view field_name,
+                       const Json::Object** output,
+                       std::vector<grpc_error_handle>* error_list);
 
-template <typename NumericType, typename ErrorVectorType>
-inline bool ExtractJsonType(const Json& json, const std::string& field_name,
-                            NumericType* output, ErrorVectorType* error_list) {
+// Wrappers for automatically choosing one of the above functions based
+// on output parameter type.
+template <typename NumericType>
+inline bool ExtractJsonType(const Json& json, absl::string_view field_name,
+                            NumericType* output,
+                            std::vector<grpc_error_handle>* error_list) {
   return ExtractJsonNumber(json, field_name, output, error_list);
 }
-
-template <typename ErrorVectorType>
-inline bool ExtractJsonType(const Json& json, const std::string& field_name,
-                            bool* output, ErrorVectorType* error_list) {
+inline bool ExtractJsonType(const Json& json, absl::string_view field_name,
+                            bool* output,
+                            std::vector<grpc_error_handle>* error_list) {
   return ExtractJsonBool(json, field_name, output, error_list);
 }
-
-template <typename ErrorVectorType>
-inline bool ExtractJsonType(const Json& json, const std::string& field_name,
-                            std::string* output, ErrorVectorType* error_list) {
+inline bool ExtractJsonType(const Json& json, absl::string_view field_name,
+                            std::string* output,
+                            std::vector<grpc_error_handle>* error_list) {
   return ExtractJsonString(json, field_name, output, error_list);
 }
-
-template <typename ErrorVectorType>
-inline bool ExtractJsonType(const Json& json, const std::string& field_name,
+inline bool ExtractJsonType(const Json& json, absl::string_view field_name,
+                            absl::string_view* output,
+                            std::vector<grpc_error_handle>* error_list) {
+  return ExtractJsonString(json, field_name, output, error_list);
+}
+inline bool ExtractJsonType(const Json& json, absl::string_view field_name,
                             const Json::Array** output,
-                            ErrorVectorType* error_list) {
+                            std::vector<grpc_error_handle>* error_list) {
   return ExtractJsonArray(json, field_name, output, error_list);
 }
-
-template <typename ErrorVectorType>
-inline bool ExtractJsonType(const Json& json, const std::string& field_name,
+inline bool ExtractJsonType(const Json& json, absl::string_view field_name,
                             const Json::Object** output,
-                            ErrorVectorType* error_list) {
+                            std::vector<grpc_error_handle>* error_list) {
   return ExtractJsonObject(json, field_name, output, error_list);
 }
 
-template <typename T, typename ErrorVectorType>
-inline bool ParseJsonObjectField(const Json::Object& object,
-                                 const std::string& field_name, T* output,
-                                 ErrorVectorType* error_list,
-                                 bool required = true) {
-  auto it = object.find(field_name);
+// Extracts a field from a JSON object, automatically selecting the type
+// of parsing based on the output parameter type.
+// If the field is not present, returns false, and if required is true,
+// adds an error to error_list.
+// Upon any other error, adds an error to error_list and returns false.
+template <typename T>
+bool ParseJsonObjectField(const Json::Object& object,
+                          absl::string_view field_name, T* output,
+                          std::vector<grpc_error_handle>* error_list,
+                          bool required = true) {
+  // TODO(roth): Once we can use C++14 heterogenous lookups, stop
+  // creating a std::string here.
+  auto it = object.find(std::string(field_name));
   if (it == object.end()) {
     if (required) {
       error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
@@ -166,30 +142,12 @@ inline bool ParseJsonObjectField(const Json::Object& object,
   return ExtractJsonType(child_object_json, field_name, output, error_list);
 }
 
-template <typename ErrorVectorType>
-inline bool ParseJsonObjectFieldAsDuration(const Json::Object& object,
-                                           const std::string& field_name,
-                                           grpc_millis* output,
-                                           ErrorVectorType* error_list,
-                                           bool required = true) {
-  auto it = object.find(field_name);
-  if (it == object.end()) {
-    if (required) {
-      error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
-          absl::StrCat("field:", field_name, " error:does not exist.")));
-    }
-    return false;
-  }
-  if (!ParseDurationFromJson(it->second, output)) {
-    *output = GRPC_MILLIS_INF_PAST;
-    error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
-        absl::StrCat("field:", field_name,
-                     " error:type should be STRING of the form given by "
-                     "google.proto.Duration.")));
-    return false;
-  }
-  return true;
-}
+// Alternative to ParseJsonObjectField() for duration-value fields.
+bool ParseJsonObjectFieldAsDuration(const Json::Object& object,
+                                    absl::string_view field_name,
+                                    grpc_millis* output,
+                                    std::vector<grpc_error_handle>* error_list,
+                                    bool required = true);
 
 }  // namespace grpc_core
 

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

@@ -23,9 +23,6 @@
 
 #include "absl/strings/string_view.h"
 
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-
 #include "src/core/lib/json/json.h"
 
 namespace grpc_core {

data/src/core/lib/matchers/matchers.cc

@@ -291,7 +291,7 @@ bool HeaderMatcher::Match(
     match = value.has_value() == present_match_;
   } else if (!value.has_value()) {
     // All other types fail to match if field is not present.
-    match = false;
+    return false;
   } else if (type_ == Type::kRange) {
     int64_t int_value;
     match = absl::SimpleAtoi(value.value(), &int_value) &&