diff --git a/quiche/common/structured_headers.cc b/quiche/common/structured_headers.cc
index b348c22..3ab0058 100644
--- a/quiche/common/structured_headers.cc
+++ b/quiche/common/structured_headers.cc
@@ -720,37 +720,30 @@
 }  // namespace
 
 Item::Item() {}
-Item::Item(const std::string& value, Item::ItemType type)
-    : type_(type), string_value_(value) {}
-Item::Item(std::string&& value, Item::ItemType type)
-    : type_(type), string_value_(std::move(value)) {
-  QUICHE_CHECK(type_ == kStringType || type_ == kTokenType ||
-               type_ == kByteSequenceType);
+Item::Item(std::string value, Item::ItemType type) {
+  switch (type) {
+    case kStringType:
+      value_.emplace<kStringType>(std::move(value));
+      break;
+    case kTokenType:
+      value_.emplace<kTokenType>(std::move(value));
+      break;
+    case kByteSequenceType:
+      value_.emplace<kByteSequenceType>(std::move(value));
+      break;
+    default:
+      QUICHE_CHECK(false);
+      break;
+  }
 }
 Item::Item(const char* value, Item::ItemType type)
     : Item(std::string(value), type) {}
-Item::Item(int64_t value) : type_(kIntegerType), integer_value_(value) {}
-Item::Item(double value) : type_(kDecimalType), decimal_value_(value) {}
-Item::Item(bool value) : type_(kBooleanType), boolean_value_(value) {}
+Item::Item(int64_t value) : value_(value) {}
+Item::Item(double value) : value_(value) {}
+Item::Item(bool value) : value_(value) {}
 
 bool operator==(const Item& lhs, const Item& rhs) {
-  if (lhs.type_ != rhs.type_) return false;
-  switch (lhs.type_) {
-    case Item::kNullType:
-      return true;
-    case Item::kStringType:
-    case Item::kTokenType:
-    case Item::kByteSequenceType:
-      return lhs.string_value_ == rhs.string_value_;
-    case Item::kIntegerType:
-      return lhs.integer_value_ == rhs.integer_value_;
-    case Item::kDecimalType:
-      return lhs.decimal_value_ == rhs.decimal_value_;
-    case Item::kBooleanType:
-      return lhs.boolean_value_ == rhs.boolean_value_;
-  }
-  QUICHE_NOTREACHED();
-  return false;
+  return lhs.value_ == rhs.value_;
 }
 
 ParameterizedItem::ParameterizedItem(const ParameterizedItem&) = default;
diff --git a/quiche/common/structured_headers.h b/quiche/common/structured_headers.h
index f0eda84..844f673 100644
--- a/quiche/common/structured_headers.h
+++ b/quiche/common/structured_headers.h
@@ -13,6 +13,7 @@
 
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
+#include "absl/types/variant.h"
 #include "quiche/common/platform/api/quiche_export.h"
 #include "quiche/common/platform/api/quiche_logging.h"
 
@@ -73,8 +74,7 @@
 
   // Constructors for string-like items: Strings, Tokens and Byte Sequences.
   Item(const char* value, Item::ItemType type = kStringType);
-  Item(const std::string& value, Item::ItemType type = kStringType);
-  Item(std::string&& value, Item::ItemType type = kStringType);
+  Item(std::string value, Item::ItemType type = kStringType);
 
   QUICHE_EXPORT_PRIVATE friend bool operator==(const Item& lhs,
                                                const Item& rhs);
@@ -82,43 +82,49 @@
     return !(lhs == rhs);
   }
 
-  bool is_null() const { return type_ == kNullType; }
-  bool is_integer() const { return type_ == kIntegerType; }
-  bool is_decimal() const { return type_ == kDecimalType; }
-  bool is_string() const { return type_ == kStringType; }
-  bool is_token() const { return type_ == kTokenType; }
-  bool is_byte_sequence() const { return type_ == kByteSequenceType; }
-  bool is_boolean() const { return type_ == kBooleanType; }
+  bool is_null() const { return Type() == kNullType; }
+  bool is_integer() const { return Type() == kIntegerType; }
+  bool is_decimal() const { return Type() == kDecimalType; }
+  bool is_string() const { return Type() == kStringType; }
+  bool is_token() const { return Type() == kTokenType; }
+  bool is_byte_sequence() const { return Type() == kByteSequenceType; }
+  bool is_boolean() const { return Type() == kBooleanType; }
 
   int64_t GetInteger() const {
-    QUICHE_CHECK_EQ(type_, kIntegerType);
-    return integer_value_;
+    const auto* value = absl::get_if<int64_t>(&value_);
+    QUICHE_CHECK(value);
+    return *value;
   }
   double GetDecimal() const {
-    QUICHE_CHECK_EQ(type_, kDecimalType);
-    return decimal_value_;
+    const auto* value = absl::get_if<double>(&value_);
+    QUICHE_CHECK(value);
+    return *value;
   }
   bool GetBoolean() const {
-    QUICHE_CHECK_EQ(type_, kBooleanType);
-    return boolean_value_;
+    const auto* value = absl::get_if<bool>(&value_);
+    QUICHE_CHECK(value);
+    return *value;
   }
   // TODO(iclelland): Split up accessors for String, Token and Byte Sequence.
   const std::string& GetString() const {
-    QUICHE_CHECK(type_ == kStringType || type_ == kTokenType ||
-                 type_ == kByteSequenceType);
-    return string_value_;
+    struct Visitor {
+      const std::string* operator()(const absl::monostate&) { return nullptr; }
+      const std::string* operator()(const int64_t&) { return nullptr; }
+      const std::string* operator()(const double&) { return nullptr; }
+      const std::string* operator()(const std::string& value) { return &value; }
+      const std::string* operator()(const bool&) { return nullptr; }
+    };
+    const std::string* value = absl::visit(Visitor(), value_);
+    QUICHE_CHECK(value);
+    return *value;
   }
 
-  ItemType Type() const { return type_; }
+  ItemType Type() const { return static_cast<ItemType>(value_.index()); }
 
  private:
-  ItemType type_ = kNullType;
-  // TODO(iclelland): Make this class more memory-efficient, replacing the
-  // values here with a union or std::variant (when available).
-  int64_t integer_value_ = 0;
-  std::string string_value_;
-  double decimal_value_;
-  bool boolean_value_;
+  absl::variant<absl::monostate, int64_t, double, std::string, std::string,
+                std::string, bool>
+      value_;
 };
 
 // Holds a ParameterizedIdentifier (draft 9 only). The contained Item must be a