move LowerCaseString to common for common use

include/envoy/common/BUILD

@@ -91,3 +91,11 @@ envoy_cc_library(
     name = "scope_tracker_interface",
     hdrs = ["scope_tracker.h"],
 )
+
+envoy_cc_library(
+    name = "case_insensitive",
+    hdrs = ["case_insensitive.h"],
+    deps = [
+        "//source/common/common:assert_lib",
+    ],
+)

include/envoy/common/case_insensitive.h

@@ -0,0 +1,71 @@
+#pragma once
+
+#include <string>
+
+#include "common/common/assert.h"
+
+#include "absl/strings/ascii.h"
+#include "absl/strings/string_view.h"
+
+namespace Envoy {
+
+/**
+ * Wrapper for case insensitive string to generally avoid needless case insensitive compares. The
+ * wrapper will uniformly convert the string content to lowercase.
+ */
+class LowerCaseStrBase {
+public:
+  explicit LowerCaseStrBase(absl::string_view new_string) : string_(new_string) { lower(); }
+
+  LowerCaseStrBase(LowerCaseStrBase&&) = default;
+  LowerCaseStrBase& operator=(LowerCaseStrBase&&) = default;
+
+  LowerCaseStrBase(const LowerCaseStrBase&) = default;
+  LowerCaseStrBase& operator=(const LowerCaseStrBase&) = default;
+
+  const std::string& get() const { return string_; }
+  std::string& get() { return string_; }
+
+  bool operator==(const LowerCaseStrBase& rhs) const { return string_ == rhs.string_; }
+  bool operator!=(const LowerCaseStrBase& rhs) const { return string_ != rhs.string_; }
+  bool operator<(const LowerCaseStrBase& rhs) const { return string_.compare(rhs.string_) < 0; }
+
+  friend std::ostream& operator<<(std::ostream& os, const LowerCaseStrBase& lower_case_string) {
+    return os << lower_case_string.string_;
+  }
+
+protected:
+  void lower() {
+    std::transform(string_.begin(), string_.end(), string_.begin(), absl::ascii_tolower);
+  }
+
+  std::string string_;
+};
+
+template <bool (*V)(absl::string_view)> class ValidatedLowerCaseStr : public LowerCaseStrBase {
+public:
+  ValidatedLowerCaseStr(LowerCaseStrBase&& rhs) noexcept : LowerCaseStrBase(std::move(rhs)) {
+    ASSERT(valid());
+  }
+  ValidatedLowerCaseStr& operator=(LowerCaseStrBase&& rhs) noexcept {
+    string_ = std::move(rhs.get());
+    ASSERT(valid());
+    return *this;
+  }
+
+  ValidatedLowerCaseStr(const LowerCaseStrBase& rhs) : LowerCaseStrBase(rhs) { ASSERT(valid()); }
+  ValidatedLowerCaseStr& operator=(const LowerCaseStrBase& rhs) {
+    string_ = rhs.get();
+    ASSERT(valid());
+    return *this;
+  }
+
+  explicit ValidatedLowerCaseStr(absl::string_view new_string) : LowerCaseStrBase(new_string) {
+    ASSERT(valid());
+  }
+
+private:
+  bool valid() const { return V(string_); }
+};
+
+} // namespace Envoy

include/envoy/http/BUILD

@@ -115,6 +115,7 @@ envoy_cc_library(
     ],
     deps = [
         ":header_formatter_interface",
+        "//include/envoy/common:case_insensitive",
         "//source/common/common:assert_lib",
         "//source/common/common:hash_lib",
     ],

include/envoy/http/header_map.h

@@ -8,6 +8,7 @@
 #include <string>
 #include <vector>
 
+#include "envoy/common/case_insensitive.h"
 #include "envoy/common/optref.h"
 #include "envoy/common/pure.h"
 #include "envoy/http/header_formatter.h"
@@ -24,7 +25,7 @@ namespace Http {
 
 // Used by ASSERTs to validate internal consistency. E.g. valid HTTP header keys/values should
 // never contain embedded NULLs.
-static inline bool validHeaderString(absl::string_view s) {
+inline bool validHeaderString(absl::string_view s) {
   // If you modify this list of illegal embedded characters you will probably
   // want to change header_map_fuzz_impl_test at the same time.
   for (const char c : s) {
@@ -43,49 +44,9 @@ static inline bool validHeaderString(absl::string_view s) {
 }
 
 /**
- * Wrapper for a lower case string used in header operations to generally avoid needless case
- * insensitive compares.
+ * Wrapper for a lower case string used in header operations.
  */
-class LowerCaseString {
-public:
-  LowerCaseString(LowerCaseString&& rhs) noexcept : string_(std::move(rhs.string_)) {
-    ASSERT(valid());
-  }
-  LowerCaseString& operator=(LowerCaseString&& rhs) noexcept {
-    string_ = std::move(rhs.string_);
-    ASSERT(valid());
-    return *this;
-  }
-
-  LowerCaseString(const LowerCaseString& rhs) : string_(rhs.string_) { ASSERT(valid()); }
-  LowerCaseString& operator=(const LowerCaseString& rhs) {
-    string_ = std::move(rhs.string_);
-    ASSERT(valid());
-    return *this;
-  }
-
-  explicit LowerCaseString(const std::string& new_string) : string_(new_string) {
-    ASSERT(valid());
-    lower();
-  }
-
-  const std::string& get() const { return string_; }
-  bool operator==(const LowerCaseString& rhs) const { return string_ == rhs.string_; }
-  bool operator!=(const LowerCaseString& rhs) const { return string_ != rhs.string_; }
-  bool operator<(const LowerCaseString& rhs) const { return string_.compare(rhs.string_) < 0; }
-
-  friend std::ostream& operator<<(std::ostream& os, const LowerCaseString& lower_case_string) {
-    return os << lower_case_string.string_;
-  }
-
-private:
-  void lower() {
-    std::transform(string_.begin(), string_.end(), string_.begin(), absl::ascii_tolower);
-  }
-  bool valid() const { return validHeaderString(string_); }
-
-  std::string string_;
-};
+using LowerCaseString = Envoy::ValidatedLowerCaseStr<validHeaderString>;
 
 /**
  * Convenient type for a vector of lower case string and string pair.

source/extensions/tracers/common/ot/opentracing_driver_impl.cc

@@ -29,7 +29,7 @@ class OpenTracingHTTPHeadersWriter : public opentracing::HTTPHeadersWriter {
   // opentracing::HTTPHeadersWriter
   opentracing::expected<void> Set(opentracing::string_view key,
                                   opentracing::string_view value) const override {
-    Http::LowerCaseString lowercase_key{key};
+    Http::LowerCaseString lowercase_key{{key.data(), key.size()}};
     request_headers_.remove(lowercase_key);
     request_headers_.addCopy(std::move(lowercase_key), {value.data(), value.size()});
     return {};
@@ -50,7 +50,7 @@ class OpenTracingHTTPHeadersReader : public opentracing::HTTPHeadersReader {
   // opentracing::HTTPHeadersReader
   opentracing::expected<opentracing::string_view>
   LookupKey(opentracing::string_view key) const override {
-    const auto entry = request_headers_.get(Http::LowerCaseString{key});
+    const auto entry = request_headers_.get(Http::LowerCaseString{{key.data(), key.size()}});
     if (!entry.empty()) {
       // This is an implicitly untrusted header, so only the first value is used.
       return opentracing::string_view{entry[0]->value().getStringView().data(),

test/extensions/filters/http/fault/fault_filter_integration_test.cc

@@ -3,6 +3,8 @@
 
 #include "gtest/gtest.h"
 
+using Envoy::Http::HeaderValueOf;
+
 namespace Envoy {
 namespace Extensions {
 namespace HttpFilters {