BASELINE: Update Chromium to 72.0.3626.110 and Ninja to 1.9.0

Change-Id: Ic57220b00ecc929a893c91f5cc552f5d3e99e922
Reviewed-by: Michael Brüning <michael.bruning@qt.io>

95 files changed, 1028 insertions, 1050 deletions

diff --git a/chromium/components/cbor/BUILD.gn b/chromium/components/cbor/BUILD.gn
index c44e464409c..b0d8024539a 100644
--- a/chromium/components/cbor/BUILD.gn
+++ b/chromium/components/cbor/BUILD.gn
@@ -6,13 +6,13 @@ import("//testing/libfuzzer/fuzzer_test.gni")
 
 component("cbor") {
   sources = [
-    "cbor_constants.h",
-    "cbor_reader.cc",
-    "cbor_reader.h",
-    "cbor_values.cc",
-    "cbor_values.h",
-    "cbor_writer.cc",
-    "cbor_writer.h",
+    "constants.h",
+    "reader.cc",
+    "reader.h",
+    "values.cc",
+    "values.h",
+    "writer.cc",
+    "writer.h",
   ]
 
   defines = [ "CBOR_IMPLEMENTATION" ]
@@ -25,9 +25,9 @@ component("cbor") {
 source_set("unit_tests") {
   testonly = true
   sources = [
-    "cbor_reader_unittest.cc",
-    "cbor_values_unittest.cc",
-    "cbor_writer_unittest.cc",
+    "reader_unittest.cc",
+    "values_unittest.cc",
+    "writer_unittest.cc",
   ]
 
   deps = [
@@ -38,14 +38,14 @@ source_set("unit_tests") {
   ]
 }
 
-fuzzer_test("cbor_reader_fuzzer") {
+fuzzer_test("reader_fuzzer") {
   sources = [
-    "cbor_reader_fuzzer.cc",
+    "reader_fuzzer.cc",
   ]
   deps = [
     ":cbor",
     "//base",
   ]
-  seed_corpus = "cbor_reader_fuzzer_corpus/"
+  seed_corpus = "reader_fuzzer_corpus/"
   libfuzzer_options = [ "max_len=65535" ]
 }
diff --git a/chromium/components/cbor/cbor_values_unittest.cc b/chromium/components/cbor/cbor_values_unittest.cc
deleted file mode 100644
index 23a959ece17..00000000000
--- a/chromium/components/cbor/cbor_values_unittest.cc
+++ /dev/null
@@ -1,372 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "components/cbor/cbor_values.h"
-
-#include <string>
-#include <utility>
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace cbor {
-
-TEST(CBORValuesTest, TestNothrow) {
-  static_assert(std::is_nothrow_move_constructible<CBORValue>::value,
-                "IsNothrowMoveConstructible");
-  static_assert(std::is_nothrow_default_constructible<CBORValue>::value,
-                "IsNothrowDefaultConstructible");
-  static_assert(std::is_nothrow_constructible<CBORValue, std::string&&>::value,
-                "IsNothrowMoveConstructibleFromString");
-  static_assert(
-      std::is_nothrow_constructible<CBORValue, CBORValue::BinaryValue&&>::value,
-      "IsNothrowMoveConstructibleFromBytestring");
-  static_assert(
-      std::is_nothrow_constructible<CBORValue, CBORValue::ArrayValue&&>::value,
-      "IsNothrowMoveConstructibleFromArray");
-  static_assert(std::is_nothrow_move_assignable<CBORValue>::value,
-                "IsNothrowMoveAssignable");
-}
-
-// Test constructors
-TEST(CBORValuesTest, ConstructUnsigned) {
-  CBORValue value(37);
-  ASSERT_EQ(CBORValue::Type::UNSIGNED, value.type());
-  EXPECT_EQ(37u, value.GetInteger());
-}
-
-TEST(CBORValuesTest, ConstructNegative) {
-  CBORValue value(-1);
-  ASSERT_EQ(CBORValue::Type::NEGATIVE, value.type());
-  EXPECT_EQ(-1, value.GetInteger());
-}
-
-TEST(CBORValuesTest, ConstructStringFromConstCharPtr) {
-  const char* str = "foobar";
-  CBORValue value(str);
-  ASSERT_EQ(CBORValue::Type::STRING, value.type());
-  EXPECT_EQ("foobar", value.GetString());
-}
-
-TEST(CBORValuesTest, ConstructStringFromStdStringConstRef) {
-  std::string str = "foobar";
-  CBORValue value(str);
-  ASSERT_EQ(CBORValue::Type::STRING, value.type());
-  EXPECT_EQ("foobar", value.GetString());
-}
-
-TEST(CBORValuesTest, ConstructStringFromStdStringRefRef) {
-  std::string str = "foobar";
-  CBORValue value(std::move(str));
-  ASSERT_EQ(CBORValue::Type::STRING, value.type());
-  EXPECT_EQ("foobar", value.GetString());
-}
-
-TEST(CBORValuesTest, ConstructBytestring) {
-  CBORValue value(CBORValue::BinaryValue({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}));
-  ASSERT_EQ(CBORValue::Type::BYTE_STRING, value.type());
-  EXPECT_EQ(CBORValue::BinaryValue({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}),
-            value.GetBytestring());
-}
-
-TEST(CBORValuesTest, ConstructBytestringFromString) {
-  CBORValue value(CBORValue("hello", CBORValue::Type::BYTE_STRING));
-  ASSERT_EQ(CBORValue::Type::BYTE_STRING, value.type());
-  EXPECT_EQ(CBORValue::BinaryValue({'h', 'e', 'l', 'l', 'o'}),
-            value.GetBytestring());
-  EXPECT_EQ("hello", value.GetBytestringAsString());
-}
-
-TEST(CBORValuesTest, ConstructArray) {
-  CBORValue::ArrayValue array;
-  array.emplace_back(CBORValue("foo"));
-  {
-    CBORValue value(array);
-    ASSERT_EQ(CBORValue::Type::ARRAY, value.type());
-    ASSERT_EQ(1u, value.GetArray().size());
-    ASSERT_EQ(CBORValue::Type::STRING, value.GetArray()[0].type());
-    EXPECT_EQ("foo", value.GetArray()[0].GetString());
-  }
-
-  array.back() = CBORValue("bar");
-  {
-    CBORValue value(std::move(array));
-    ASSERT_EQ(CBORValue::Type::ARRAY, value.type());
-    ASSERT_EQ(1u, value.GetArray().size());
-    ASSERT_EQ(CBORValue::Type::STRING, value.GetArray()[0].type());
-    EXPECT_EQ("bar", value.GetArray()[0].GetString());
-  }
-}
-
-TEST(CBORValuesTest, ConstructMap) {
-  CBORValue::MapValue map;
-  const CBORValue key_foo("foo");
-  map[CBORValue("foo")] = CBORValue("bar");
-  {
-    CBORValue value(map);
-    ASSERT_EQ(CBORValue::Type::MAP, value.type());
-    ASSERT_EQ(value.GetMap().count(key_foo), 1u);
-    ASSERT_EQ(CBORValue::Type::STRING,
-              value.GetMap().find(key_foo)->second.type());
-    EXPECT_EQ("bar", value.GetMap().find(key_foo)->second.GetString());
-  }
-
-  map[CBORValue("foo")] = CBORValue("baz");
-  {
-    CBORValue value(std::move(map));
-    ASSERT_EQ(CBORValue::Type::MAP, value.type());
-    ASSERT_EQ(value.GetMap().count(key_foo), 1u);
-    ASSERT_EQ(CBORValue::Type::STRING,
-              value.GetMap().find(key_foo)->second.type());
-    EXPECT_EQ("baz", value.GetMap().find(key_foo)->second.GetString());
-  }
-}
-
-TEST(CBORValuesTest, ConstructSimpleValue) {
-  CBORValue false_value(CBORValue::SimpleValue::FALSE_VALUE);
-  ASSERT_EQ(CBORValue::Type::SIMPLE_VALUE, false_value.type());
-  EXPECT_EQ(CBORValue::SimpleValue::FALSE_VALUE, false_value.GetSimpleValue());
-
-  CBORValue true_value(CBORValue::SimpleValue::TRUE_VALUE);
-  ASSERT_EQ(CBORValue::Type::SIMPLE_VALUE, true_value.type());
-  EXPECT_EQ(CBORValue::SimpleValue::TRUE_VALUE, true_value.GetSimpleValue());
-
-  CBORValue null_value(CBORValue::SimpleValue::NULL_VALUE);
-  ASSERT_EQ(CBORValue::Type::SIMPLE_VALUE, null_value.type());
-  EXPECT_EQ(CBORValue::SimpleValue::NULL_VALUE, null_value.GetSimpleValue());
-
-  CBORValue undefined_value(CBORValue::SimpleValue::UNDEFINED);
-  ASSERT_EQ(CBORValue::Type::SIMPLE_VALUE, undefined_value.type());
-  EXPECT_EQ(CBORValue::SimpleValue::UNDEFINED,
-            undefined_value.GetSimpleValue());
-}
-
-TEST(CBORValuesTest, ConstructSimpleBooleanValue) {
-  CBORValue true_value(true);
-  ASSERT_EQ(CBORValue::Type::SIMPLE_VALUE, true_value.type());
-  EXPECT_TRUE(true_value.GetBool());
-
-  CBORValue false_value(false);
-  ASSERT_EQ(CBORValue::Type::SIMPLE_VALUE, false_value.type());
-  EXPECT_FALSE(false_value.GetBool());
-}
-
-// Test copy constructors
-TEST(CBORValuesTest, CopyUnsigned) {
-  CBORValue value(74);
-  CBORValue copied_value(value.Clone());
-  ASSERT_EQ(value.type(), copied_value.type());
-  EXPECT_EQ(value.GetInteger(), copied_value.GetInteger());
-
-  CBORValue blank;
-
-  blank = value.Clone();
-  ASSERT_EQ(value.type(), blank.type());
-  EXPECT_EQ(value.GetInteger(), blank.GetInteger());
-}
-
-TEST(CBORValuesTest, CopyNegativeInt) {
-  CBORValue value(-74);
-  CBORValue copied_value(value.Clone());
-  ASSERT_EQ(value.type(), copied_value.type());
-  EXPECT_EQ(value.GetInteger(), copied_value.GetInteger());
-
-  CBORValue blank;
-
-  blank = value.Clone();
-  ASSERT_EQ(value.type(), blank.type());
-  EXPECT_EQ(value.GetInteger(), blank.GetInteger());
-}
-
-TEST(CBORValuesTest, CopyString) {
-  CBORValue value("foobar");
-  CBORValue copied_value(value.Clone());
-  ASSERT_EQ(value.type(), copied_value.type());
-  EXPECT_EQ(value.GetString(), copied_value.GetString());
-
-  CBORValue blank;
-
-  blank = value.Clone();
-  ASSERT_EQ(value.type(), blank.type());
-  EXPECT_EQ(value.GetString(), blank.GetString());
-}
-
-TEST(CBORValuesTest, CopyBytestring) {
-  CBORValue value(CBORValue::BinaryValue({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}));
-  CBORValue copied_value(value.Clone());
-  ASSERT_EQ(value.type(), copied_value.type());
-  EXPECT_EQ(value.GetBytestring(), copied_value.GetBytestring());
-
-  CBORValue blank;
-
-  blank = value.Clone();
-  ASSERT_EQ(value.type(), blank.type());
-  EXPECT_EQ(value.GetBytestring(), blank.GetBytestring());
-}
-
-TEST(CBORValuesTest, CopyArray) {
-  CBORValue::ArrayValue array;
-  array.emplace_back(123);
-  CBORValue value(std::move(array));
-
-  CBORValue copied_value(value.Clone());
-  ASSERT_EQ(1u, copied_value.GetArray().size());
-  ASSERT_TRUE(copied_value.GetArray()[0].is_unsigned());
-  EXPECT_EQ(value.GetArray()[0].GetInteger(),
-            copied_value.GetArray()[0].GetInteger());
-
-  CBORValue blank;
-  blank = value.Clone();
-  EXPECT_EQ(1u, blank.GetArray().size());
-}
-
-TEST(CBORValuesTest, CopyMap) {
-  CBORValue::MapValue map;
-  CBORValue key_a("a");
-  map[CBORValue("a")] = CBORValue(123);
-  CBORValue value(std::move(map));
-
-  CBORValue copied_value(value.Clone());
-  EXPECT_EQ(1u, copied_value.GetMap().size());
-  ASSERT_EQ(value.GetMap().count(key_a), 1u);
-  ASSERT_EQ(copied_value.GetMap().count(key_a), 1u);
-  ASSERT_TRUE(copied_value.GetMap().find(key_a)->second.is_unsigned());
-  EXPECT_EQ(value.GetMap().find(key_a)->second.GetInteger(),
-            copied_value.GetMap().find(key_a)->second.GetInteger());
-
-  CBORValue blank;
-  blank = value.Clone();
-  EXPECT_EQ(1u, blank.GetMap().size());
-  ASSERT_EQ(blank.GetMap().count(key_a), 1u);
-  ASSERT_TRUE(blank.GetMap().find(key_a)->second.is_unsigned());
-  EXPECT_EQ(value.GetMap().find(key_a)->second.GetInteger(),
-            blank.GetMap().find(key_a)->second.GetInteger());
-}
-
-TEST(CBORValuesTest, CopySimpleValue) {
-  CBORValue value(CBORValue::SimpleValue::TRUE_VALUE);
-  CBORValue copied_value(value.Clone());
-  EXPECT_EQ(value.type(), copied_value.type());
-  EXPECT_EQ(value.GetSimpleValue(), copied_value.GetSimpleValue());
-
-  CBORValue blank;
-
-  blank = value.Clone();
-  EXPECT_EQ(value.type(), blank.type());
-  EXPECT_EQ(value.GetSimpleValue(), blank.GetSimpleValue());
-}
-
-// Test move constructors and move-assignment
-TEST(CBORValuesTest, MoveUnsigned) {
-  CBORValue value(74);
-  CBORValue moved_value(std::move(value));
-  EXPECT_EQ(CBORValue::Type::UNSIGNED, moved_value.type());
-  EXPECT_EQ(74u, moved_value.GetInteger());
-
-  CBORValue blank;
-
-  blank = CBORValue(654);
-  EXPECT_EQ(CBORValue::Type::UNSIGNED, blank.type());
-  EXPECT_EQ(654u, blank.GetInteger());
-}
-
-TEST(CBORValuesTest, MoveNegativeInteger) {
-  CBORValue value(-74);
-  CBORValue moved_value(std::move(value));
-  EXPECT_EQ(CBORValue::Type::NEGATIVE, moved_value.type());
-  EXPECT_EQ(-74, moved_value.GetInteger());
-
-  CBORValue blank;
-
-  blank = CBORValue(-654);
-  EXPECT_EQ(CBORValue::Type::NEGATIVE, blank.type());
-  EXPECT_EQ(-654, blank.GetInteger());
-}
-
-TEST(CBORValuesTest, MoveString) {
-  CBORValue value("foobar");
-  CBORValue moved_value(std::move(value));
-  EXPECT_EQ(CBORValue::Type::STRING, moved_value.type());
-  EXPECT_EQ("foobar", moved_value.GetString());
-
-  CBORValue blank;
-
-  blank = CBORValue("foobar");
-  EXPECT_EQ(CBORValue::Type::STRING, blank.type());
-  EXPECT_EQ("foobar", blank.GetString());
-}
-
-TEST(CBORValuesTest, MoveBytestring) {
-  const CBORValue::BinaryValue bytes({0xF, 0x0, 0x0, 0xB, 0xA, 0x2});
-  CBORValue value(bytes);
-  CBORValue moved_value(std::move(value));
-  EXPECT_EQ(CBORValue::Type::BYTE_STRING, moved_value.type());
-  EXPECT_EQ(bytes, moved_value.GetBytestring());
-
-  CBORValue blank;
-
-  blank = CBORValue(bytes);
-  EXPECT_EQ(CBORValue::Type::BYTE_STRING, blank.type());
-  EXPECT_EQ(bytes, blank.GetBytestring());
-}
-
-TEST(CBORValuesTest, MoveConstructMap) {
-  CBORValue::MapValue map;
-  const CBORValue key_a("a");
-  map[CBORValue("a")] = CBORValue(123);
-
-  CBORValue value(std::move(map));
-  CBORValue moved_value(std::move(value));
-  ASSERT_EQ(CBORValue::Type::MAP, moved_value.type());
-  ASSERT_EQ(moved_value.GetMap().count(key_a), 1u);
-  ASSERT_TRUE(moved_value.GetMap().find(key_a)->second.is_unsigned());
-  EXPECT_EQ(123u, moved_value.GetMap().find(key_a)->second.GetInteger());
-}
-
-TEST(CBORValuesTest, MoveAssignMap) {
-  CBORValue::MapValue map;
-  const CBORValue key_a("a");
-  map[CBORValue("a")] = CBORValue(123);
-
-  CBORValue blank;
-  blank = CBORValue(std::move(map));
-  ASSERT_TRUE(blank.is_map());
-  ASSERT_EQ(blank.GetMap().count(key_a), 1u);
-  ASSERT_TRUE(blank.GetMap().find(key_a)->second.is_unsigned());
-  EXPECT_EQ(123u, blank.GetMap().find(key_a)->second.GetInteger());
-}
-
-TEST(CBORValuesTest, MoveArray) {
-  CBORValue::ArrayValue array;
-  array.emplace_back(123);
-  CBORValue value(array);
-  CBORValue moved_value(std::move(value));
-  EXPECT_EQ(CBORValue::Type::ARRAY, moved_value.type());
-  EXPECT_EQ(123u, moved_value.GetArray().back().GetInteger());
-
-  CBORValue blank;
-  blank = CBORValue(std::move(array));
-  EXPECT_EQ(CBORValue::Type::ARRAY, blank.type());
-  EXPECT_EQ(123u, blank.GetArray().back().GetInteger());
-}
-
-TEST(CBORValuesTest, MoveSimpleValue) {
-  CBORValue value(CBORValue::SimpleValue::UNDEFINED);
-  CBORValue moved_value(std::move(value));
-  EXPECT_EQ(CBORValue::Type::SIMPLE_VALUE, moved_value.type());
-  EXPECT_EQ(CBORValue::SimpleValue::UNDEFINED, moved_value.GetSimpleValue());
-
-  CBORValue blank;
-
-  blank = CBORValue(CBORValue::SimpleValue::UNDEFINED);
-  EXPECT_EQ(CBORValue::Type::SIMPLE_VALUE, blank.type());
-  EXPECT_EQ(CBORValue::SimpleValue::UNDEFINED, blank.GetSimpleValue());
-}
-
-TEST(CBORValuesTest, SelfSwap) {
-  CBORValue test(1);
-  std::swap(test, test);
-  EXPECT_EQ(test.GetInteger(), 1u);
-}
-
-}  // namespace cbor
diff --git a/chromium/components/cbor/cbor_constants.h b/chromium/components/cbor/constants.h
index 69a6364c759..2df971dc2ed 100644
--- a/chromium/components/cbor/cbor_constants.h
+++ b/chromium/components/cbor/constants.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef COMPONENTS_CBOR_CBOR_CONSTANTS_H_
-#define COMPONENTS_CBOR_CBOR_CONSTANTS_H_
+#ifndef COMPONENTS_CBOR_CONSTANTS_H_
+#define COMPONENTS_CBOR_CONSTANTS_H_
 
 #include <stdint.h>
 
@@ -34,4 +34,4 @@ extern const char kUnsupportedMajorType[];
 }  // namespace constants
 }  // namespace cbor
 
-#endif  // COMPONENTS_CBOR_CBOR_CONSTANTS_H_
+#endif  // COMPONENTS_CBOR_CONSTANTS_H_
diff --git a/chromium/components/cbor/cbor_reader.cc b/chromium/components/cbor/reader.cc
index e4efdae95bb..dbab26836d0 100644
--- a/chromium/components/cbor/cbor_reader.cc
+++ b/chromium/components/cbor/reader.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "components/cbor/cbor_reader.h"
+#include "components/cbor/reader.h"
 
 #include <math.h>
 
@@ -12,7 +12,7 @@
 #include "base/numerics/safe_conversions.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
-#include "components/cbor/cbor_constants.h"
+#include "components/cbor/constants.h"
 
 namespace cbor {
 
@@ -22,8 +22,8 @@ const char kUnsupportedMajorType[] = "Unsupported major type.";
 
 namespace {
 
-CBORValue::Type GetMajorType(uint8_t initial_data_byte) {
-  return static_cast<CBORValue::Type>(
+Value::Type GetMajorType(uint8_t initial_data_byte) {
+  return static_cast<Value::Type>(
       (initial_data_byte & constants::kMajorTypeMask) >>
       constants::kMajorTypeBitShift);
 }
@@ -33,7 +33,7 @@ uint8_t GetAdditionalInfo(uint8_t initial_data_byte) {
 }
 
 // Error messages that correspond to each of the error codes. There is 1
-// exception: we declare |kUnsupportedMajorType| in cbor_constants.h in the
+// exception: we declare |kUnsupportedMajorType| in constants.h in the
 // `constants` namespace, because we use it in several files.
 const char kNoError[] = "Successfully deserialized to a CBOR value.";
 const char kUnknownAdditionalInfo[] =
@@ -43,7 +43,8 @@ const char kIncompleteCBORData[] =
 const char kIncorrectMapKeyType[] =
     "Specified map key type is not supported by the current implementation.";
 const char kTooMuchNesting[] = "Too much nesting.";
-const char kInvalidUTF8[] = "String encoding other than utf8 are not allowed.";
+const char kInvalidUTF8[] =
+    "String encodings other than UTF-8 are not allowed.";
 const char kExtraneousData[] = "Trailing data bytes are not allowed.";
 const char kMapKeyOutOfOrder[] =
     "Map keys must be strictly monotonically increasing based on byte length "
@@ -60,77 +61,78 @@ const char kUnknownError[] = "An unknown error occured.";
 
 }  // namespace
 
-CBORReader::CBORReader(base::span<const uint8_t> data)
+Reader::Reader(base::span<const uint8_t> data)
     : rest_(data), error_code_(DecoderError::CBOR_NO_ERROR) {}
-CBORReader::~CBORReader() {}
+Reader::~Reader() {}
 
 // static
-base::Optional<CBORValue> CBORReader::Read(base::span<uint8_t const> data,
-                                           DecoderError* error_code_out,
-                                           int max_nesting_level) {
+base::Optional<Value> Reader::Read(base::span<uint8_t const> data,
+                                   DecoderError* error_code_out,
+                                   int max_nesting_level) {
   size_t num_bytes_consumed;
-  auto decoded_cbor =
+  auto value =
       Read(data, &num_bytes_consumed, error_code_out, max_nesting_level);
 
-  if (decoded_cbor && num_bytes_consumed != data.size()) {
-    if (error_code_out)
+  if (value && num_bytes_consumed != data.size()) {
+    if (error_code_out) {
       *error_code_out = DecoderError::EXTRANEOUS_DATA;
+    }
     return base::nullopt;
   }
 
-  return decoded_cbor;
+  return value;
 }
 
 // static
-base::Optional<CBORValue> CBORReader::Read(base::span<uint8_t const> data,
-                                           size_t* num_bytes_consumed,
-                                           DecoderError* error_code_out,
-                                           int max_nesting_level) {
-  CBORReader reader(data);
-  base::Optional<CBORValue> decoded_cbor =
+base::Optional<Value> Reader::Read(base::span<uint8_t const> data,
+                                   size_t* num_bytes_consumed,
+                                   DecoderError* error_code_out,
+                                   int max_nesting_level) {
+  Reader reader(data);
+  base::Optional<Value> value =
       reader.DecodeCompleteDataItem(max_nesting_level);
 
-  auto error_code = reader.GetErrorCode();
-  const bool failed = !decoded_cbor.has_value();
-
-  // An error code must be set iff parsing failed.
-  DCHECK_EQ(failed, error_code != DecoderError::CBOR_NO_ERROR);
+  auto error = reader.GetErrorCode();
+  const bool success = value.has_value();
+  DCHECK_EQ(success, error == DecoderError::CBOR_NO_ERROR);
 
-  if (error_code_out)
-    *error_code_out = error_code;
+  if (error_code_out) {
+    *error_code_out = error;
+  }
 
-  *num_bytes_consumed = failed ? 0 : data.size() - reader.num_bytes_remaining();
-  return decoded_cbor;
+  *num_bytes_consumed =
+      success ? data.size() - reader.num_bytes_remaining() : 0;
+  return value;
 }
 
-base::Optional<CBORValue> CBORReader::DecodeCompleteDataItem(
-    int max_nesting_level) {
+base::Optional<Value> Reader::DecodeCompleteDataItem(int max_nesting_level) {
   if (max_nesting_level < 0 || max_nesting_level > kCBORMaxDepth) {
     error_code_ = DecoderError::TOO_MUCH_NESTING;
     return base::nullopt;
   }
 
   base::Optional<DataItemHeader> header = DecodeDataItemHeader();
-  if (!header.has_value())
+  if (!header.has_value()) {
     return base::nullopt;
+  }
 
   switch (header->type) {
-    case CBORValue::Type::UNSIGNED:
+    case Value::Type::UNSIGNED:
       return DecodeValueToUnsigned(header->value);
-    case CBORValue::Type::NEGATIVE:
+    case Value::Type::NEGATIVE:
       return DecodeValueToNegative(header->value);
-    case CBORValue::Type::BYTE_STRING:
+    case Value::Type::BYTE_STRING:
       return ReadByteStringContent(*header);
-    case CBORValue::Type::STRING:
+    case Value::Type::STRING:
       return ReadStringContent(*header);
-    case CBORValue::Type::ARRAY:
+    case Value::Type::ARRAY:
       return ReadArrayContent(*header, max_nesting_level);
-    case CBORValue::Type::MAP:
+    case Value::Type::MAP:
       return ReadMapContent(*header, max_nesting_level);
-    case CBORValue::Type::SIMPLE_VALUE:
+    case Value::Type::SIMPLE_VALUE:
       return DecodeToSimpleValue(*header);
-    case CBORValue::Type::TAG:  // We explicitly don't support TAG.
-    case CBORValue::Type::NONE:
+    case Value::Type::TAG:  // We explicitly don't support TAG.
+    case Value::Type::NONE:
       break;
   }
 
@@ -138,7 +140,7 @@ base::Optional<CBORValue> CBORReader::DecodeCompleteDataItem(
   return base::nullopt;
 }
 
-base::Optional<CBORReader::DataItemHeader> CBORReader::DecodeDataItemHeader() {
+base::Optional<Reader::DataItemHeader> Reader::DecodeDataItemHeader() {
   const base::Optional<uint8_t> initial_byte = ReadByte();
   if (!initial_byte) {
     return base::nullopt;
@@ -153,7 +155,7 @@ base::Optional<CBORReader::DataItemHeader> CBORReader::DecodeDataItemHeader() {
                : base::nullopt;
 }
 
-base::Optional<uint64_t> CBORReader::ReadVariadicLengthInteger(
+base::Optional<uint64_t> Reader::ReadVariadicLengthInteger(
     uint8_t additional_info) {
   uint8_t additional_bytes = 0;
   if (additional_info < 24) {
@@ -183,30 +185,30 @@ base::Optional<uint64_t> CBORReader::ReadVariadicLengthInteger(
     int_data |= b;
   }
 
-  return CheckMinimalEncoding(additional_bytes, int_data)
+  return IsEncodingMinimal(additional_bytes, int_data)
              ? base::make_optional(int_data)
              : base::nullopt;
 }
 
-base::Optional<CBORValue> CBORReader::DecodeValueToNegative(uint64_t value) {
+base::Optional<Value> Reader::DecodeValueToNegative(uint64_t value) {
   auto negative_value = -base::CheckedNumeric<int64_t>(value) - 1;
   if (!negative_value.IsValid()) {
     error_code_ = DecoderError::OUT_OF_RANGE_INTEGER_VALUE;
     return base::nullopt;
   }
-  return CBORValue(negative_value.ValueOrDie());
+  return Value(negative_value.ValueOrDie());
 }
 
-base::Optional<CBORValue> CBORReader::DecodeValueToUnsigned(uint64_t value) {
+base::Optional<Value> Reader::DecodeValueToUnsigned(uint64_t value) {
   auto unsigned_value = base::CheckedNumeric<int64_t>(value);
   if (!unsigned_value.IsValid()) {
     error_code_ = DecoderError::OUT_OF_RANGE_INTEGER_VALUE;
     return base::nullopt;
   }
-  return CBORValue(unsigned_value.ValueOrDie());
+  return Value(unsigned_value.ValueOrDie());
 }
 
-base::Optional<CBORValue> CBORReader::DecodeToSimpleValue(
+base::Optional<Value> Reader::DecodeToSimpleValue(
     const DataItemHeader& header) {
   // ReadVariadicLengthInteger provides this bound.
   CHECK_LE(header.additional_info, 27);
@@ -221,22 +223,22 @@ base::Optional<CBORValue> CBORReader::DecodeToSimpleValue(
   CHECK_LE(header.value, 255u);
   // |SimpleValue| is an enum class and so the underlying type is specified to
   // be |int|. So this cast is safe.
-  CBORValue::SimpleValue possibly_unsupported_simple_value =
-      static_cast<CBORValue::SimpleValue>(static_cast<int>(header.value));
+  Value::SimpleValue possibly_unsupported_simple_value =
+      static_cast<Value::SimpleValue>(static_cast<int>(header.value));
   switch (possibly_unsupported_simple_value) {
-    case CBORValue::SimpleValue::FALSE_VALUE:
-    case CBORValue::SimpleValue::TRUE_VALUE:
-    case CBORValue::SimpleValue::NULL_VALUE:
-    case CBORValue::SimpleValue::UNDEFINED:
-      return CBORValue(possibly_unsupported_simple_value);
+    case Value::SimpleValue::FALSE_VALUE:
+    case Value::SimpleValue::TRUE_VALUE:
+    case Value::SimpleValue::NULL_VALUE:
+    case Value::SimpleValue::UNDEFINED:
+      return Value(possibly_unsupported_simple_value);
   }
 
   error_code_ = DecoderError::UNSUPPORTED_SIMPLE_VALUE;
   return base::nullopt;
 }
 
-base::Optional<CBORValue> CBORReader::ReadStringContent(
-    const CBORReader::DataItemHeader& header) {
+base::Optional<Value> Reader::ReadStringContent(
+    const Reader::DataItemHeader& header) {
   uint64_t num_bytes = header.value;
   const base::Optional<base::span<const uint8_t>> bytes = ReadBytes(num_bytes);
   if (!bytes) {
@@ -246,12 +248,12 @@ base::Optional<CBORValue> CBORReader::ReadStringContent(
   std::string cbor_string(bytes->begin(), bytes->end());
 
   return HasValidUTF8Format(cbor_string)
-             ? base::make_optional<CBORValue>(CBORValue(std::move(cbor_string)))
+             ? base::make_optional<Value>(Value(std::move(cbor_string)))
              : base::nullopt;
 }
 
-base::Optional<CBORValue> CBORReader::ReadByteStringContent(
-    const CBORReader::DataItemHeader& header) {
+base::Optional<Value> Reader::ReadByteStringContent(
+    const Reader::DataItemHeader& header) {
   uint64_t num_bytes = header.value;
   const base::Optional<base::span<const uint8_t>> bytes = ReadBytes(num_bytes);
   if (!bytes) {
@@ -259,64 +261,64 @@ base::Optional<CBORValue> CBORReader::ReadByteStringContent(
   }
 
   std::vector<uint8_t> cbor_byte_string(bytes->begin(), bytes->end());
-  return CBORValue(std::move(cbor_byte_string));
+  return Value(std::move(cbor_byte_string));
 }
 
-base::Optional<CBORValue> CBORReader::ReadArrayContent(
-    const CBORReader::DataItemHeader& header,
+base::Optional<Value> Reader::ReadArrayContent(
+    const Reader::DataItemHeader& header,
     int max_nesting_level) {
-  uint64_t length = header.value;
+  const uint64_t length = header.value;
 
-  CBORValue::ArrayValue cbor_array;
+  Value::ArrayValue cbor_array;
   for (uint64_t i = 0; i < length; ++i) {
-    base::Optional<CBORValue> cbor_element =
+    base::Optional<Value> cbor_element =
         DecodeCompleteDataItem(max_nesting_level - 1);
-    if (!cbor_element.has_value())
+    if (!cbor_element.has_value()) {
       return base::nullopt;
+    }
     cbor_array.push_back(std::move(cbor_element.value()));
   }
-  return CBORValue(std::move(cbor_array));
+  return Value(std::move(cbor_array));
 }
 
-base::Optional<CBORValue> CBORReader::ReadMapContent(
-    const CBORReader::DataItemHeader& header,
+base::Optional<Value> Reader::ReadMapContent(
+    const Reader::DataItemHeader& header,
     int max_nesting_level) {
-  uint64_t length = header.value;
+  const uint64_t length = header.value;
 
-  CBORValue::MapValue cbor_map;
+  Value::MapValue cbor_map;
   for (uint64_t i = 0; i < length; ++i) {
-    base::Optional<CBORValue> key =
-        DecodeCompleteDataItem(max_nesting_level - 1);
-    base::Optional<CBORValue> value =
-        DecodeCompleteDataItem(max_nesting_level - 1);
-    if (!key.has_value() || !value.has_value())
+    base::Optional<Value> key = DecodeCompleteDataItem(max_nesting_level - 1);
+    base::Optional<Value> value = DecodeCompleteDataItem(max_nesting_level - 1);
+    if (!key.has_value() || !value.has_value()) {
       return base::nullopt;
+    }
 
     switch (key.value().type()) {
-      case CBORValue::Type::UNSIGNED:
-      case CBORValue::Type::NEGATIVE:
-      case CBORValue::Type::STRING:
-      case CBORValue::Type::BYTE_STRING:
+      case Value::Type::UNSIGNED:
+      case Value::Type::NEGATIVE:
+      case Value::Type::STRING:
+      case Value::Type::BYTE_STRING:
         break;
       default:
         error_code_ = DecoderError::INCORRECT_MAP_KEY_TYPE;
         return base::nullopt;
     }
-    if (!CheckOutOfOrderKey(key.value(), &cbor_map)) {
+    if (!IsKeyInOrder(key.value(), &cbor_map)) {
       return base::nullopt;
     }
 
     cbor_map.insert_or_assign(std::move(key.value()), std::move(value.value()));
   }
-  return CBORValue(std::move(cbor_map));
+  return Value(std::move(cbor_map));
 }
 
-base::Optional<uint8_t> CBORReader::ReadByte() {
+base::Optional<uint8_t> Reader::ReadByte() {
   const base::Optional<base::span<const uint8_t>> bytes = ReadBytes(1);
   return bytes ? base::make_optional(bytes.value()[0]) : base::nullopt;
 }
 
-base::Optional<base::span<const uint8_t>> CBORReader::ReadBytes(
+base::Optional<base::span<const uint8_t>> Reader::ReadBytes(
     uint64_t num_bytes) {
   if (base::strict_cast<uint64_t>(rest_.size()) < num_bytes) {
     error_code_ = DecoderError::INCOMPLETE_CBOR_DATA;
@@ -327,8 +329,7 @@ base::Optional<base::span<const uint8_t>> CBORReader::ReadBytes(
   return ret;
 }
 
-bool CBORReader::CheckMinimalEncoding(uint8_t additional_bytes,
-                                      uint64_t uint_data) {
+bool Reader::IsEncodingMinimal(uint8_t additional_bytes, uint64_t uint_data) {
   if ((additional_bytes == 1 && uint_data < 24) ||
       uint_data <= (1ULL << 8 * (additional_bytes >> 1)) - 1) {
     error_code_ = DecoderError::NON_MINIMAL_CBOR_ENCODING;
@@ -337,7 +338,7 @@ bool CBORReader::CheckMinimalEncoding(uint8_t additional_bytes,
   return true;
 }
 
-bool CBORReader::HasValidUTF8Format(const std::string& string_data) {
+bool Reader::HasValidUTF8Format(const std::string& string_data) {
   if (!base::IsStringUTF8(string_data)) {
     error_code_ = DecoderError::INVALID_UTF8;
     return false;
@@ -345,8 +346,7 @@ bool CBORReader::HasValidUTF8Format(const std::string& string_data) {
   return true;
 }
 
-bool CBORReader::CheckOutOfOrderKey(const CBORValue& new_key,
-                                    CBORValue::MapValue* map) {
+bool Reader::IsKeyInOrder(const Value& new_key, Value::MapValue* map) {
   if (map->empty()) {
     return true;
   }
@@ -360,12 +360,8 @@ bool CBORReader::CheckOutOfOrderKey(const CBORValue& new_key,
   return true;
 }
 
-CBORReader::DecoderError CBORReader::GetErrorCode() {
-  return error_code_;
-}
-
 // static
-const char* CBORReader::ErrorCodeToString(DecoderError error) {
+const char* Reader::ErrorCodeToString(DecoderError error) {
   switch (error) {
     case DecoderError::CBOR_NO_ERROR:
       return kNoError;
diff --git a/chromium/components/cbor/cbor_reader.h b/chromium/components/cbor/reader.h
index 1a1589cde72..6cf58873b57 100644
--- a/chromium/components/cbor/cbor_reader.h
+++ b/chromium/components/cbor/reader.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef COMPONENTS_CBOR_CBOR_READER_H_
-#define COMPONENTS_CBOR_CBOR_READER_H_
+#ifndef COMPONENTS_CBOR_READER_H_
+#define COMPONENTS_CBOR_READER_H_
 
 #include <stddef.h>
 
@@ -13,21 +13,25 @@
 #include "base/containers/span.h"
 #include "base/optional.h"
 #include "components/cbor/cbor_export.h"
-#include "components/cbor/cbor_values.h"
+#include "components/cbor/values.h"
 
 // Concise Binary Object Representation (CBOR) decoder as defined by
 // https://tools.ietf.org/html/rfc7049. This decoder only accepts canonical CBOR
 // as defined by section 3.9.
 //
 // This implementation supports the following major types:
-//  - 0: Unsigned integers, up to 64-bit values.
-//  - 1: Signed integers, up to 64-bit values.
+//  - 0: Unsigned integers, up to 64-bit values*.
+//  - 1: Signed integers, up to 64-bit values*.
 //  - 2: Byte strings.
 //  - 3: UTF-8 strings.
 //  - 4: Definite-length arrays.
 //  - 5: Definite-length maps.
 //  - 7: Simple values.
 //
+//  * Note: For simplicity, this implementation represents both signed and
+//    unsigned integers with signed int64_t. This reduces the effective range
+//    of unsigned integers.
+//
 // Requirements for canonical CBOR representation:
 //  - Duplicate keys in maps are not allowed.
 //  - Keys for maps must be sorted first by length and then by byte-wise
@@ -53,7 +57,7 @@
 
 namespace cbor {
 
-class CBOR_EXPORT CBORReader {
+class CBOR_EXPORT Reader {
  public:
   enum class DecoderError {
     CBOR_NO_ERROR = 0,
@@ -75,9 +79,9 @@ class CBOR_EXPORT CBORReader {
   // CBOR nested depth sufficient for most use cases.
   static const int kCBORMaxDepth = 16;
 
-  ~CBORReader();
+  ~Reader();
 
-  // Reads and parses |input_data| into a CBORValue. Returns an empty Optional
+  // Reads and parses |input_data| into a Value. Returns an empty Optional
   // if the input violates any one of the syntax requirements (including unknown
   // additional info and incomplete CBOR data).
   //
@@ -89,29 +93,29 @@ class CBOR_EXPORT CBORReader {
   //
   // Returns an empty Optional if not all the data was consumed, and sets
   // |error_code_out| to EXTRANEOUS_DATA in this case.
-  static base::Optional<CBORValue> Read(base::span<const uint8_t> input_data,
-                                        DecoderError* error_code_out = nullptr,
-                                        int max_nesting_level = kCBORMaxDepth);
+  static base::Optional<Value> Read(base::span<const uint8_t> input_data,
+                                    DecoderError* error_code_out = nullptr,
+                                    int max_nesting_level = kCBORMaxDepth);
 
   // Never fails with EXTRANEOUS_DATA, but informs the caller of how many bytes
   // were consumed through |num_bytes_consumed|.
-  static base::Optional<CBORValue> Read(base::span<const uint8_t> input_data,
-                                        size_t* num_bytes_consumed,
-                                        DecoderError* error_code_out = nullptr,
-                                        int max_nesting_level = kCBORMaxDepth);
+  static base::Optional<Value> Read(base::span<const uint8_t> input_data,
+                                    size_t* num_bytes_consumed,
+                                    DecoderError* error_code_out = nullptr,
+                                    int max_nesting_level = kCBORMaxDepth);
 
   // Translates errors to human-readable error messages.
   static const char* ErrorCodeToString(DecoderError error_code);
 
  private:
-  explicit CBORReader(base::span<const uint8_t> data);
+  explicit Reader(base::span<const uint8_t> data);
 
   // Encapsulates information extracted from the header of a CBOR data item,
   // which consists of the initial byte, and a variable-length-encoded integer
   // (if any).
   struct DataItemHeader {
     // The major type decoded from the initial byte.
-    CBORValue::Type type;
+    Value::Type type;
 
     // The raw 5-bit additional information from the initial byte.
     uint8_t additional_info;
@@ -122,36 +126,36 @@ class CBOR_EXPORT CBORReader {
   };
 
   base::Optional<DataItemHeader> DecodeDataItemHeader();
-  base::Optional<CBORValue> DecodeCompleteDataItem(int max_nesting_level);
-  base::Optional<CBORValue> DecodeValueToNegative(uint64_t value);
-  base::Optional<CBORValue> DecodeValueToUnsigned(uint64_t value);
-  base::Optional<CBORValue> DecodeToSimpleValue(const DataItemHeader& header);
+  base::Optional<Value> DecodeCompleteDataItem(int max_nesting_level);
+  base::Optional<Value> DecodeValueToNegative(uint64_t value);
+  base::Optional<Value> DecodeValueToUnsigned(uint64_t value);
+  base::Optional<Value> DecodeToSimpleValue(const DataItemHeader& header);
   base::Optional<uint64_t> ReadVariadicLengthInteger(uint8_t additional_info);
-  base::Optional<CBORValue> ReadByteStringContent(const DataItemHeader& header);
-  base::Optional<CBORValue> ReadStringContent(const DataItemHeader& header);
-  base::Optional<CBORValue> ReadArrayContent(const DataItemHeader& header,
-                                             int max_nesting_level);
-  base::Optional<CBORValue> ReadMapContent(const DataItemHeader& header,
-                                           int max_nesting_level);
+  base::Optional<Value> ReadByteStringContent(const DataItemHeader& header);
+  base::Optional<Value> ReadStringContent(const DataItemHeader& header);
+  base::Optional<Value> ReadArrayContent(const DataItemHeader& header,
+                                         int max_nesting_level);
+  base::Optional<Value> ReadMapContent(const DataItemHeader& header,
+                                       int max_nesting_level);
   base::Optional<uint8_t> ReadByte();
   base::Optional<base::span<const uint8_t>> ReadBytes(uint64_t num_bytes);
   // TODO(crbug/879237): This function's only caller has to make a copy of a
   // `span<uint8_t>` to satisfy this function's interface. Maybe we can make
   // this function take a `const span<const uint8_t>` and avoid copying?
   bool HasValidUTF8Format(const std::string& string_data);
-  bool CheckOutOfOrderKey(const CBORValue& new_key, CBORValue::MapValue* map);
-  bool CheckMinimalEncoding(uint8_t additional_bytes, uint64_t uint_data);
+  bool IsKeyInOrder(const Value& new_key, Value::MapValue* map);
+  bool IsEncodingMinimal(uint8_t additional_bytes, uint64_t uint_data);
 
-  DecoderError GetErrorCode();
+  DecoderError GetErrorCode() { return error_code_; }
 
   size_t num_bytes_remaining() const { return rest_.size(); }
 
   base::span<const uint8_t> rest_;
   DecoderError error_code_;
 
-  DISALLOW_COPY_AND_ASSIGN(CBORReader);
+  DISALLOW_COPY_AND_ASSIGN(Reader);
 };
 
 }  // namespace cbor
 
-#endif  // COMPONENTS_CBOR_CBOR_READER_H_
+#endif  // COMPONENTS_CBOR_READER_H_
diff --git a/chromium/components/cbor/cbor_reader_fuzzer.cc b/chromium/components/cbor/reader_fuzzer.cc
index 4809e704adb..3a1e0458ad9 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer.cc
+++ b/chromium/components/cbor/reader_fuzzer.cc
@@ -5,18 +5,18 @@
 #include <stdint.h>
 #include <algorithm>
 
-#include "components/cbor/cbor_reader.h"  // nogncheck
-#include "components/cbor/cbor_writer.h"  // nogncheck
+#include "components/cbor/reader.h"  // nogncheck
+#include "components/cbor/writer.h"  // nogncheck
 
 namespace cbor {
 
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   std::vector<uint8_t> input(data, data + size);
-  base::Optional<CBORValue> cbor = CBORReader::Read(input);
+  base::Optional<Value> cbor = Reader::Read(input);
 
   if (cbor.has_value()) {
     base::Optional<std::vector<uint8_t>> serialized_cbor =
-        CBORWriter::Write(cbor.value());
+        Writer::Write(cbor.value());
     CHECK(serialized_cbor.has_value());
     if (serialized_cbor.has_value()) {
       CHECK(serialized_cbor.value().size() == input.size());
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor0 b/chromium/components/cbor/reader_fuzzer_corpus/cbor0
index f76dd238ade..f76dd238ade 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor0
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor0
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor1 b/chromium/components/cbor/reader_fuzzer_corpus/cbor1
index 6b2aaa76407..6b2aaa76407 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor1
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor1
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor10 b/chromium/components/cbor/reader_fuzzer_corpus/cbor10
index fed1e13fcfa..fed1e13fcfa 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor10
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor10
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor11 b/chromium/components/cbor/reader_fuzzer_corpus/cbor11
index 00a3f0c5362..00a3f0c5362 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor11
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor11
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor12 b/chromium/components/cbor/reader_fuzzer_corpus/cbor12
index 077457ad259..077457ad259 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor12
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor12
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor13 b/chromium/components/cbor/reader_fuzzer_corpus/cbor13
index b4818a3b38b..b4818a3b38b 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor13
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor13
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor14 b/chromium/components/cbor/reader_fuzzer_corpus/cbor14
index 0519ecba6ea..0519ecba6ea 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor14
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor14
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor15 b/chromium/components/cbor/reader_fuzzer_corpus/cbor15
index e8a0f87653d..e8a0f87653d 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor15
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor15
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor16 b/chromium/components/cbor/reader_fuzzer_corpus/cbor16
index bfefdad18c4..bfefdad18c4 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor16
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor16
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor17 b/chromium/components/cbor/reader_fuzzer_corpus/cbor17
index 5de255544fc..5de255544fc 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor17
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor17
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor18 b/chromium/components/cbor/reader_fuzzer_corpus/cbor18
index e43ae5af822..e43ae5af822 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor18
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor18
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor19 b/chromium/components/cbor/reader_fuzzer_corpus/cbor19
index 6935671d0de..6935671d0de 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor19
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor19
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor2 b/chromium/components/cbor/reader_fuzzer_corpus/cbor2
index 8b137891791..8b137891791 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor2
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor2
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor20 b/chromium/components/cbor/reader_fuzzer_corpus/cbor20
index ed788bb3a4c..ed788bb3a4c 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor20
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor20
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor21 b/chromium/components/cbor/reader_fuzzer_corpus/cbor21
index fc9ea00d188..fc9ea00d188 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor21
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor21
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor22 b/chromium/components/cbor/reader_fuzzer_corpus/cbor22
index 5ac3929dea8..5ac3929dea8 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor22
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor22
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor23 b/chromium/components/cbor/reader_fuzzer_corpus/cbor23
index 735f4675f10..735f4675f10 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor23
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor23
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor24 b/chromium/components/cbor/reader_fuzzer_corpus/cbor24
index f36a086ed50..f36a086ed50 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor24
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor24
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor25 b/chromium/components/cbor/reader_fuzzer_corpus/cbor25
index 16f3345724b..16f3345724b 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor25
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor25
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor26 b/chromium/components/cbor/reader_fuzzer_corpus/cbor26
index 8e79bf519fe..8e79bf519fe 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor26
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor26
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor27 b/chromium/components/cbor/reader_fuzzer_corpus/cbor27
index 8e144ff3cd2..8e144ff3cd2 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor27
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor27
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor28 b/chromium/components/cbor/reader_fuzzer_corpus/cbor28
index 16b0d43402f..16b0d43402f 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor28
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor28
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor29 b/chromium/components/cbor/reader_fuzzer_corpus/cbor29
index e5b8b4d8adb..e5b8b4d8adb 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor29
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor29
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor3 b/chromium/components/cbor/reader_fuzzer_corpus/cbor3
index c96ab3cc70e..c96ab3cc70e 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor3
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor3
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor30 b/chromium/components/cbor/reader_fuzzer_corpus/cbor30
index 815adc3e417..815adc3e417 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor30
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor30
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor31 b/chromium/components/cbor/reader_fuzzer_corpus/cbor31
index 2b119eb6592..2b119eb6592 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor31
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor31
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor32 b/chromium/components/cbor/reader_fuzzer_corpus/cbor32
index d73f58e36a2..d73f58e36a2 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor32
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor32
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor33 b/chromium/components/cbor/reader_fuzzer_corpus/cbor33
index 7c2eb64047e..7c2eb64047e 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor33
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor33
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor34 b/chromium/components/cbor/reader_fuzzer_corpus/cbor34
index 82965f3b13a..82965f3b13a 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor34
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor34
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor35 b/chromium/components/cbor/reader_fuzzer_corpus/cbor35
index 2a9ccaec94a..2a9ccaec94a 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor35
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor35
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor36 b/chromium/components/cbor/reader_fuzzer_corpus/cbor36
index a9e0eebe00c..a9e0eebe00c 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor36
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor36
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor37 b/chromium/components/cbor/reader_fuzzer_corpus/cbor37
index c90d682d848..c90d682d848 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor37
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor37
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor38 b/chromium/components/cbor/reader_fuzzer_corpus/cbor38
index 802efe1966e..802efe1966e 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor38
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor38
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor39 b/chromium/components/cbor/reader_fuzzer_corpus/cbor39
index 7a1f61c5343..7a1f61c5343 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor39
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor39
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor4 b/chromium/components/cbor/reader_fuzzer_corpus/cbor4
index a1910b3f6cc..a1910b3f6cc 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor4
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor4
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor40 b/chromium/components/cbor/reader_fuzzer_corpus/cbor40
index 3a6e607aa5a..3a6e607aa5a 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor40
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor40
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor41 b/chromium/components/cbor/reader_fuzzer_corpus/cbor41
index bb7d13c5e9a..bb7d13c5e9a 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor41
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor41
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor42 b/chromium/components/cbor/reader_fuzzer_corpus/cbor42
index f7a8cadeb57..f7a8cadeb57 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor42
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor42
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor43 b/chromium/components/cbor/reader_fuzzer_corpus/cbor43
index 009080e8e0b..009080e8e0b 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor43
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor43
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor44 b/chromium/components/cbor/reader_fuzzer_corpus/cbor44
index 04f7b5be698..04f7b5be698 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor44
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor44
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor45 b/chromium/components/cbor/reader_fuzzer_corpus/cbor45
index 33c4e29de19..33c4e29de19 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor45
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor45
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor46 b/chromium/components/cbor/reader_fuzzer_corpus/cbor46
index a61a4624f2c..a61a4624f2c 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor46
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor46
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor47 b/chromium/components/cbor/reader_fuzzer_corpus/cbor47
index d2fbff8927a..d2fbff8927a 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor47
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor47
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor48 b/chromium/components/cbor/reader_fuzzer_corpus/cbor48
index 4ecf94681e9..4ecf94681e9 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor48
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor48
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor49 b/chromium/components/cbor/reader_fuzzer_corpus/cbor49
index c5c79cf7779..c5c79cf7779 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor49
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor49
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor5 b/chromium/components/cbor/reader_fuzzer_corpus/cbor5
index d4e634a6b50..d4e634a6b50 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor5
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor5
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor50 b/chromium/components/cbor/reader_fuzzer_corpus/cbor50
index 7d0120d5bff..7d0120d5bff 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor50
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor50
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor51 b/chromium/components/cbor/reader_fuzzer_corpus/cbor51
index 2784fd87e9b..2784fd87e9b 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor51
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor51
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor52 b/chromium/components/cbor/reader_fuzzer_corpus/cbor52
index b7d2601ab13..b7d2601ab13 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor52
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor52
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor53 b/chromium/components/cbor/reader_fuzzer_corpus/cbor53
index b516b2c489f..b516b2c489f 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor53
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor53
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor54 b/chromium/components/cbor/reader_fuzzer_corpus/cbor54
index 352e89a8017..352e89a8017 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor54
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor54
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor55 b/chromium/components/cbor/reader_fuzzer_corpus/cbor55
index 64845fb7679..64845fb7679 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor55
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor55
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor56 b/chromium/components/cbor/reader_fuzzer_corpus/cbor56
index 7ec9a4b774e..7ec9a4b774e 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor56
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor56
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor57 b/chromium/components/cbor/reader_fuzzer_corpus/cbor57
index 743669bb19c..743669bb19c 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor57
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor57
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor58 b/chromium/components/cbor/reader_fuzzer_corpus/cbor58
index cce6615381d..cce6615381d 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor58
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor58
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor59 b/chromium/components/cbor/reader_fuzzer_corpus/cbor59
index 9055a92aa61..9055a92aa61 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor59
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor59
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor6 b/chromium/components/cbor/reader_fuzzer_corpus/cbor6
index 3b5c90718af..3b5c90718af 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor6
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor6
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor60 b/chromium/components/cbor/reader_fuzzer_corpus/cbor60
index 0868c9a4288..0868c9a4288 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor60
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor60
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor61 b/chromium/components/cbor/reader_fuzzer_corpus/cbor61
index 8ea48a07a27..8ea48a07a27 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor61
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor61
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor62 b/chromium/components/cbor/reader_fuzzer_corpus/cbor62
index 5416677bc7d..5416677bc7d 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor62
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor62
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor63 b/chromium/components/cbor/reader_fuzzer_corpus/cbor63
index 4cdf6ce18a8..4cdf6ce18a8 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor63
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor63
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor64 b/chromium/components/cbor/reader_fuzzer_corpus/cbor64
index 80fd3949e51..80fd3949e51 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor64
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor64
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor65 b/chromium/components/cbor/reader_fuzzer_corpus/cbor65
index b4495842ec6..b4495842ec6 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor65
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor65
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor66 b/chromium/components/cbor/reader_fuzzer_corpus/cbor66
index eea1bf0c31f..eea1bf0c31f 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor66
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor66
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor67 b/chromium/components/cbor/reader_fuzzer_corpus/cbor67
index abc169a8cc5..abc169a8cc5 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor67
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor67
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor68 b/chromium/components/cbor/reader_fuzzer_corpus/cbor68
index 81e38473ff6..81e38473ff6 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor68
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor68
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor69 b/chromium/components/cbor/reader_fuzzer_corpus/cbor69
index 9b1d08caf44..9b1d08caf44 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor69
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor69
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor7 b/chromium/components/cbor/reader_fuzzer_corpus/cbor7
index fda74fd9c88..fda74fd9c88 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor7
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor7
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor70 b/chromium/components/cbor/reader_fuzzer_corpus/cbor70
index 05bb07fc9d1..05bb07fc9d1 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor70
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor70
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor71 b/chromium/components/cbor/reader_fuzzer_corpus/cbor71
index 2681a857cb7..2681a857cb7 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor71
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor71
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor72 b/chromium/components/cbor/reader_fuzzer_corpus/cbor72
index d0daf282398..d0daf282398 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor72
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor72
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor73 b/chromium/components/cbor/reader_fuzzer_corpus/cbor73
index 422ce24eaac..422ce24eaac 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor73
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor73
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor74 b/chromium/components/cbor/reader_fuzzer_corpus/cbor74
index f67cd5703a8..f67cd5703a8 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor74
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor74
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor75 b/chromium/components/cbor/reader_fuzzer_corpus/cbor75
index 78343ed40e3..78343ed40e3 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor75
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor75
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor76 b/chromium/components/cbor/reader_fuzzer_corpus/cbor76
index a0f1ea25969..a0f1ea25969 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor76
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor76
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor77 b/chromium/components/cbor/reader_fuzzer_corpus/cbor77
index dbbf8e51a3f..dbbf8e51a3f 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor77
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor77
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor78 b/chromium/components/cbor/reader_fuzzer_corpus/cbor78
index 81c9910e824..81c9910e824 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor78
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor78
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor79 b/chromium/components/cbor/reader_fuzzer_corpus/cbor79
index 018602c1e13..018602c1e13 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor79
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor79
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor8 b/chromium/components/cbor/reader_fuzzer_corpus/cbor8
index 916281951cd..916281951cd 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor8
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor8
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor80 b/chromium/components/cbor/reader_fuzzer_corpus/cbor80
index 151c13e53d3..151c13e53d3 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor80
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor80
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor81 b/chromium/components/cbor/reader_fuzzer_corpus/cbor81
index c0f4fd5eb32..c0f4fd5eb32 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor81
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor81
diff --git a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor9 b/chromium/components/cbor/reader_fuzzer_corpus/cbor9
index 4cdcd7ccc3f..4cdcd7ccc3f 100644
--- a/chromium/components/cbor/cbor_reader_fuzzer_corpus/cbor9
+++ b/chromium/components/cbor/reader_fuzzer_corpus/cbor9
diff --git a/chromium/components/cbor/cbor_reader_unittest.cc b/chromium/components/cbor/reader_unittest.cc
index d86866d3048..6af8d600e8e 100644
--- a/chromium/components/cbor/cbor_reader_unittest.cc
+++ b/chromium/components/cbor/reader_unittest.cc
@@ -5,7 +5,7 @@
 #include <limits>
 #include <utility>
 
-#include "components/cbor/cbor_reader.h"
+#include "components/cbor/reader.h"
 
 #include "base/containers/span.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -51,24 +51,24 @@ TEST(CBORReaderTest, TestReadUint) {
   for (const UintTestCase& test_case : kUintTestCases) {
     SCOPED_TRACE(testing::Message() << "testing uint: " << test_case.value);
 
-    base::Optional<CBORValue> cbor = CBORReader::Read(test_case.cbor_data);
+    base::Optional<Value> cbor = Reader::Read(test_case.cbor_data);
     ASSERT_TRUE(cbor.has_value());
-    ASSERT_EQ(cbor.value().type(), CBORValue::Type::UNSIGNED);
+    ASSERT_EQ(cbor.value().type(), Value::Type::UNSIGNED);
     EXPECT_EQ(cbor.value().GetInteger(), test_case.value);
 
     auto cbor_data_with_extra_byte = WithExtraneousData(test_case.cbor_data);
-    CBORReader::DecoderError error_code;
-    cbor = CBORReader::Read(cbor_data_with_extra_byte, &error_code);
+    Reader::DecoderError error_code;
+    cbor = Reader::Read(cbor_data_with_extra_byte, &error_code);
     EXPECT_FALSE(cbor.has_value());
-    EXPECT_EQ(error_code, CBORReader::DecoderError::EXTRANEOUS_DATA);
+    EXPECT_EQ(error_code, Reader::DecoderError::EXTRANEOUS_DATA);
 
     size_t num_bytes_consumed;
-    cbor = CBORReader::Read(cbor_data_with_extra_byte, &num_bytes_consumed,
-                            &error_code);
+    cbor = Reader::Read(cbor_data_with_extra_byte, &num_bytes_consumed,
+                        &error_code);
     ASSERT_TRUE(cbor.has_value());
-    ASSERT_EQ(cbor.value().type(), CBORValue::Type::UNSIGNED);
+    ASSERT_EQ(cbor.value().type(), Value::Type::UNSIGNED);
     EXPECT_EQ(cbor.value().GetInteger(), test_case.value);
-    EXPECT_EQ(error_code, CBORReader::DecoderError::CBOR_NO_ERROR);
+    EXPECT_EQ(error_code, Reader::DecoderError::CBOR_NO_ERROR);
     EXPECT_EQ(num_bytes_consumed, test_case.cbor_data.size());
   }
 }
@@ -111,15 +111,14 @@ TEST(CBORReaderTest, TestUintEncodedWithNonMinimumByteLength) {
   };
 
   int test_case_index = 0;
-  CBORReader::DecoderError error_code;
+  Reader::DecoderError error_code;
   for (const auto& non_minimal_uint : non_minimal_uint_encodings) {
     SCOPED_TRACE(testing::Message()
                  << "testing element at index : " << test_case_index++);
 
-    base::Optional<CBORValue> cbor =
-        CBORReader::Read(non_minimal_uint, &error_code);
+    base::Optional<Value> cbor = Reader::Read(non_minimal_uint, &error_code);
     EXPECT_FALSE(cbor.has_value());
-    EXPECT_EQ(error_code, CBORReader::DecoderError::NON_MINIMAL_CBOR_ENCODING);
+    EXPECT_EQ(error_code, Reader::DecoderError::NON_MINIMAL_CBOR_ENCODING);
   }
 }
 
@@ -144,24 +143,24 @@ TEST(CBORReaderTest, TestReadNegativeInt) {
     SCOPED_TRACE(testing::Message()
                  << "testing negative int : " << test_case.negative_int);
 
-    base::Optional<CBORValue> cbor = CBORReader::Read(test_case.cbor_data);
+    base::Optional<Value> cbor = Reader::Read(test_case.cbor_data);
     ASSERT_TRUE(cbor.has_value());
-    ASSERT_EQ(cbor.value().type(), CBORValue::Type::NEGATIVE);
+    ASSERT_EQ(cbor.value().type(), Value::Type::NEGATIVE);
     EXPECT_EQ(cbor.value().GetInteger(), test_case.negative_int);
 
     auto cbor_data_with_extra_byte = WithExtraneousData(test_case.cbor_data);
-    CBORReader::DecoderError error_code;
-    cbor = CBORReader::Read(cbor_data_with_extra_byte, &error_code);
+    Reader::DecoderError error_code;
+    cbor = Reader::Read(cbor_data_with_extra_byte, &error_code);
     EXPECT_FALSE(cbor.has_value());
-    EXPECT_EQ(error_code, CBORReader::DecoderError::EXTRANEOUS_DATA);
+    EXPECT_EQ(error_code, Reader::DecoderError::EXTRANEOUS_DATA);
 
     size_t num_bytes_consumed;
-    cbor = CBORReader::Read(cbor_data_with_extra_byte, &num_bytes_consumed,
-                            &error_code);
+    cbor = Reader::Read(cbor_data_with_extra_byte, &num_bytes_consumed,
+                        &error_code);
     ASSERT_TRUE(cbor.has_value());
-    ASSERT_EQ(cbor.value().type(), CBORValue::Type::NEGATIVE);
+    ASSERT_EQ(cbor.value().type(), Value::Type::NEGATIVE);
     EXPECT_EQ(cbor.value().GetInteger(), test_case.negative_int);
-    EXPECT_EQ(error_code, CBORReader::DecoderError::CBOR_NO_ERROR);
+    EXPECT_EQ(error_code, Reader::DecoderError::CBOR_NO_ERROR);
     EXPECT_EQ(num_bytes_consumed, test_case.cbor_data.size());
   }
 }
@@ -184,24 +183,24 @@ TEST(CBORReaderTest, TestReadBytes) {
     SCOPED_TRACE(testing::Message()
                  << "testing string test case at : " << element_index++);
 
-    base::Optional<CBORValue> cbor = CBORReader::Read(test_case.cbor_data);
+    base::Optional<Value> cbor = Reader::Read(test_case.cbor_data);
     ASSERT_TRUE(cbor.has_value());
-    ASSERT_EQ(cbor.value().type(), CBORValue::Type::BYTE_STRING);
+    ASSERT_EQ(cbor.value().type(), Value::Type::BYTE_STRING);
     EXPECT_EQ(cbor.value().GetBytestring(), test_case.value);
 
     auto cbor_data_with_extra_byte = WithExtraneousData(test_case.cbor_data);
-    CBORReader::DecoderError error_code;
-    cbor = CBORReader::Read(cbor_data_with_extra_byte, &error_code);
+    Reader::DecoderError error_code;
+    cbor = Reader::Read(cbor_data_with_extra_byte, &error_code);
     EXPECT_FALSE(cbor.has_value());
-    EXPECT_EQ(error_code, CBORReader::DecoderError::EXTRANEOUS_DATA);
+    EXPECT_EQ(error_code, Reader::DecoderError::EXTRANEOUS_DATA);
 
     size_t num_bytes_consumed;
-    cbor = CBORReader::Read(cbor_data_with_extra_byte, &num_bytes_consumed,
-                            &error_code);
+    cbor = Reader::Read(cbor_data_with_extra_byte, &num_bytes_consumed,
+                        &error_code);
     ASSERT_TRUE(cbor.has_value());
-    ASSERT_EQ(cbor.value().type(), CBORValue::Type::BYTE_STRING);
+    ASSERT_EQ(cbor.value().type(), Value::Type::BYTE_STRING);
     EXPECT_EQ(cbor.value().GetBytestring(), test_case.value);
-    EXPECT_EQ(error_code, CBORReader::DecoderError::CBOR_NO_ERROR);
+    EXPECT_EQ(error_code, Reader::DecoderError::CBOR_NO_ERROR);
     EXPECT_EQ(num_bytes_consumed, test_case.cbor_data.size());
   }
 }
@@ -226,24 +225,24 @@ TEST(CBORReaderTest, TestReadString) {
     SCOPED_TRACE(testing::Message()
                  << "testing string value : " << test_case.value);
 
-    base::Optional<CBORValue> cbor = CBORReader::Read(test_case.cbor_data);
+    base::Optional<Value> cbor = Reader::Read(test_case.cbor_data);
     ASSERT_TRUE(cbor.has_value());
-    ASSERT_EQ(cbor.value().type(), CBORValue::Type::STRING);
+    ASSERT_EQ(cbor.value().type(), Value::Type::STRING);
     EXPECT_EQ(cbor.value().GetString(), test_case.value);
 
     auto cbor_data_with_extra_byte = WithExtraneousData(test_case.cbor_data);
-    CBORReader::DecoderError error_code;
-    cbor = CBORReader::Read(cbor_data_with_extra_byte, &error_code);
+    Reader::DecoderError error_code;
+    cbor = Reader::Read(cbor_data_with_extra_byte, &error_code);
     EXPECT_FALSE(cbor.has_value());
-    EXPECT_EQ(error_code, CBORReader::DecoderError::EXTRANEOUS_DATA);
+    EXPECT_EQ(error_code, Reader::DecoderError::EXTRANEOUS_DATA);
 
     size_t num_bytes_consumed;
-    cbor = CBORReader::Read(cbor_data_with_extra_byte, &num_bytes_consumed,
-                            &error_code);
+    cbor = Reader::Read(cbor_data_with_extra_byte, &num_bytes_consumed,
+                        &error_code);
     ASSERT_TRUE(cbor.has_value());
-    ASSERT_EQ(cbor.value().type(), CBORValue::Type::STRING);
+    ASSERT_EQ(cbor.value().type(), Value::Type::STRING);
     EXPECT_EQ(cbor.value().GetString(), test_case.value);
-    EXPECT_EQ(error_code, CBORReader::DecoderError::CBOR_NO_ERROR);
+    EXPECT_EQ(error_code, Reader::DecoderError::CBOR_NO_ERROR);
     EXPECT_EQ(num_bytes_consumed, test_case.cbor_data.size());
   }
 }
@@ -271,24 +270,24 @@ TEST(CBORReaderTest, TestReadStringWithNUL) {
     SCOPED_TRACE(testing::Message()
                  << "testing string with nul bytes :" << test_case.value);
 
-    base::Optional<CBORValue> cbor = CBORReader::Read(test_case.cbor_data);
+    base::Optional<Value> cbor = Reader::Read(test_case.cbor_data);
     ASSERT_TRUE(cbor.has_value());
-    ASSERT_EQ(cbor.value().type(), CBORValue::Type::STRING);
+    ASSERT_EQ(cbor.value().type(), Value::Type::STRING);
     EXPECT_EQ(cbor.value().GetString(), test_case.value);
 
     auto cbor_data_with_extra_byte = WithExtraneousData(test_case.cbor_data);
-    CBORReader::DecoderError error_code;
-    cbor = CBORReader::Read(cbor_data_with_extra_byte, &error_code);
+    Reader::DecoderError error_code;
+    cbor = Reader::Read(cbor_data_with_extra_byte, &error_code);
     EXPECT_FALSE(cbor.has_value());
-    EXPECT_EQ(error_code, CBORReader::DecoderError::EXTRANEOUS_DATA);
+    EXPECT_EQ(error_code, Reader::DecoderError::EXTRANEOUS_DATA);
 
     size_t num_bytes_consumed;
-    cbor = CBORReader::Read(cbor_data_with_extra_byte, &num_bytes_consumed,
-                            &error_code);
+    cbor = Reader::Read(cbor_data_with_extra_byte, &num_bytes_consumed,
+                        &error_code);
     ASSERT_TRUE(cbor.has_value());
-    ASSERT_EQ(cbor.value().type(), CBORValue::Type::STRING);
+    ASSERT_EQ(cbor.value().type(), Value::Type::STRING);
     EXPECT_EQ(cbor.value().GetString(), test_case.value);
-    EXPECT_EQ(error_code, CBORReader::DecoderError::CBOR_NO_ERROR);
+    EXPECT_EQ(error_code, Reader::DecoderError::CBOR_NO_ERROR);
     EXPECT_EQ(num_bytes_consumed, test_case.cbor_data.size());
   }
 }
@@ -300,11 +299,11 @@ TEST(CBORReaderTest, TestReadStringWithInvalidByteSequenceAfterNUL) {
   // characters. Here, 0xA6 is an unexpected continuation byte.
   static const std::vector<uint8_t> string_with_invalid_continuation_byte = {
       0x63, 0x00, 0x00, 0xA6};
-  CBORReader::DecoderError error_code;
-  base::Optional<CBORValue> cbor =
-      CBORReader::Read(string_with_invalid_continuation_byte, &error_code);
+  Reader::DecoderError error_code;
+  base::Optional<Value> cbor =
+      Reader::Read(string_with_invalid_continuation_byte, &error_code);
   EXPECT_FALSE(cbor.has_value());
-  EXPECT_EQ(error_code, CBORReader::DecoderError::INVALID_UTF8);
+  EXPECT_EQ(error_code, Reader::DecoderError::INVALID_UTF8);
 }
 
 TEST(CBORReaderTest, TestReadArray) {
@@ -317,34 +316,34 @@ TEST(CBORReaderTest, TestReadArray) {
       // clang-format on
   };
 
-  base::Optional<CBORValue> cbor = CBORReader::Read(kArrayTestCaseCbor);
+  base::Optional<Value> cbor = Reader::Read(kArrayTestCaseCbor);
   ASSERT_TRUE(cbor.has_value());
-  const CBORValue cbor_array = std::move(cbor.value());
-  ASSERT_EQ(cbor_array.type(), CBORValue::Type::ARRAY);
+  const Value cbor_array = std::move(cbor.value());
+  ASSERT_EQ(cbor_array.type(), Value::Type::ARRAY);
   ASSERT_THAT(cbor_array.GetArray(), testing::SizeIs(25));
 
-  std::vector<CBORValue> array;
+  std::vector<Value> array;
   for (int i = 0; i < 25; i++) {
     SCOPED_TRACE(testing::Message() << "testing array element at index " << i);
 
-    ASSERT_EQ(cbor_array.GetArray()[i].type(), CBORValue::Type::UNSIGNED);
+    ASSERT_EQ(cbor_array.GetArray()[i].type(), Value::Type::UNSIGNED);
     EXPECT_EQ(cbor_array.GetArray()[i].GetInteger(),
               static_cast<int64_t>(i + 1));
   }
 
   auto cbor_data_with_extra_byte = WithExtraneousData(kArrayTestCaseCbor);
-  CBORReader::DecoderError error_code;
-  cbor = CBORReader::Read(cbor_data_with_extra_byte, &error_code);
+  Reader::DecoderError error_code;
+  cbor = Reader::Read(cbor_data_with_extra_byte, &error_code);
   EXPECT_FALSE(cbor.has_value());
-  EXPECT_EQ(error_code, CBORReader::DecoderError::EXTRANEOUS_DATA);
+  EXPECT_EQ(error_code, Reader::DecoderError::EXTRANEOUS_DATA);
 
   size_t num_bytes_consumed;
-  cbor = CBORReader::Read(cbor_data_with_extra_byte, &num_bytes_consumed,
-                          &error_code);
+  cbor =
+      Reader::Read(cbor_data_with_extra_byte, &num_bytes_consumed, &error_code);
   ASSERT_TRUE(cbor.has_value());
-  ASSERT_EQ(cbor_array.type(), CBORValue::Type::ARRAY);
+  ASSERT_EQ(cbor_array.type(), Value::Type::ARRAY);
   ASSERT_THAT(cbor_array.GetArray(), testing::SizeIs(25));
-  EXPECT_EQ(error_code, CBORReader::DecoderError::CBOR_NO_ERROR);
+  EXPECT_EQ(error_code, Reader::DecoderError::CBOR_NO_ERROR);
   EXPECT_EQ(num_bytes_consumed, kArrayTestCaseCbor.size());
 }
 
@@ -366,49 +365,47 @@ TEST(CBORReaderTest, TestReadMapWithMapValue) {
       // clang-format on
   };
 
-  base::Optional<CBORValue> cbor = CBORReader::Read(kMapTestCaseCbor);
+  base::Optional<Value> cbor = Reader::Read(kMapTestCaseCbor);
   ASSERT_TRUE(cbor.has_value());
-  const CBORValue cbor_val = std::move(cbor.value());
-  ASSERT_EQ(cbor_val.type(), CBORValue::Type::MAP);
+  const Value cbor_val = std::move(cbor.value());
+  ASSERT_EQ(cbor_val.type(), Value::Type::MAP);
   ASSERT_EQ(cbor_val.GetMap().size(), 4u);
 
-  const CBORValue key_uint(24);
+  const Value key_uint(24);
   ASSERT_EQ(cbor_val.GetMap().count(key_uint), 1u);
   ASSERT_EQ(cbor_val.GetMap().find(key_uint)->second.type(),
-            CBORValue::Type::STRING);
+            Value::Type::STRING);
   EXPECT_EQ(cbor_val.GetMap().find(key_uint)->second.GetString(), "abc");
 
-  const CBORValue key_empty_string("");
+  const Value key_empty_string("");
   ASSERT_EQ(cbor_val.GetMap().count(key_empty_string), 1u);
   ASSERT_EQ(cbor_val.GetMap().find(key_empty_string)->second.type(),
-            CBORValue::Type::STRING);
+            Value::Type::STRING);
   EXPECT_EQ(cbor_val.GetMap().find(key_empty_string)->second.GetString(), ".");
 
-  const CBORValue key_b("b");
+  const Value key_b("b");
   ASSERT_EQ(cbor_val.GetMap().count(key_b), 1u);
-  ASSERT_EQ(cbor_val.GetMap().find(key_b)->second.type(),
-            CBORValue::Type::STRING);
+  ASSERT_EQ(cbor_val.GetMap().find(key_b)->second.type(), Value::Type::STRING);
   EXPECT_EQ(cbor_val.GetMap().find(key_b)->second.GetString(), "B");
 
-  const CBORValue key_aa("aa");
+  const Value key_aa("aa");
   ASSERT_EQ(cbor_val.GetMap().count(key_aa), 1u);
-  ASSERT_EQ(cbor_val.GetMap().find(key_aa)->second.type(),
-            CBORValue::Type::STRING);
+  ASSERT_EQ(cbor_val.GetMap().find(key_aa)->second.type(), Value::Type::STRING);
   EXPECT_EQ(cbor_val.GetMap().find(key_aa)->second.GetString(), "AA");
 
   auto cbor_data_with_extra_byte = WithExtraneousData(kMapTestCaseCbor);
-  CBORReader::DecoderError error_code;
-  cbor = CBORReader::Read(cbor_data_with_extra_byte, &error_code);
+  Reader::DecoderError error_code;
+  cbor = Reader::Read(cbor_data_with_extra_byte, &error_code);
   EXPECT_FALSE(cbor.has_value());
-  EXPECT_EQ(error_code, CBORReader::DecoderError::EXTRANEOUS_DATA);
+  EXPECT_EQ(error_code, Reader::DecoderError::EXTRANEOUS_DATA);
 
   size_t num_bytes_consumed;
-  cbor = CBORReader::Read(cbor_data_with_extra_byte, &num_bytes_consumed,
-                          &error_code);
+  cbor =
+      Reader::Read(cbor_data_with_extra_byte, &num_bytes_consumed, &error_code);
   ASSERT_TRUE(cbor.has_value());
-  ASSERT_EQ(cbor_val.type(), CBORValue::Type::MAP);
+  ASSERT_EQ(cbor_val.type(), Value::Type::MAP);
   ASSERT_EQ(cbor_val.GetMap().size(), 4u);
-  EXPECT_EQ(error_code, CBORReader::DecoderError::CBOR_NO_ERROR);
+  EXPECT_EQ(error_code, Reader::DecoderError::CBOR_NO_ERROR);
   EXPECT_EQ(num_bytes_consumed, kMapTestCaseCbor.size());
 }
 
@@ -430,49 +427,47 @@ TEST(CBORReaderTest, TestReadMapWithIntegerKeys) {
       // clang-format on
   };
 
-  base::Optional<CBORValue> cbor = CBORReader::Read(kMapWithIntegerKeyCbor);
+  base::Optional<Value> cbor = Reader::Read(kMapWithIntegerKeyCbor);
   ASSERT_TRUE(cbor.has_value());
-  const CBORValue cbor_val = std::move(cbor.value());
-  ASSERT_EQ(cbor_val.type(), CBORValue::Type::MAP);
+  const Value cbor_val = std::move(cbor.value());
+  ASSERT_EQ(cbor_val.type(), Value::Type::MAP);
   ASSERT_EQ(cbor_val.GetMap().size(), 4u);
 
-  const CBORValue key_1(1);
+  const Value key_1(1);
   ASSERT_EQ(cbor_val.GetMap().count(key_1), 1u);
-  ASSERT_EQ(cbor_val.GetMap().find(key_1)->second.type(),
-            CBORValue::Type::STRING);
+  ASSERT_EQ(cbor_val.GetMap().find(key_1)->second.type(), Value::Type::STRING);
   EXPECT_EQ(cbor_val.GetMap().find(key_1)->second.GetString(), "a");
 
-  const CBORValue key_9(9);
+  const Value key_9(9);
   ASSERT_EQ(cbor_val.GetMap().count(key_9), 1u);
-  ASSERT_EQ(cbor_val.GetMap().find(key_9)->second.type(),
-            CBORValue::Type::STRING);
+  ASSERT_EQ(cbor_val.GetMap().find(key_9)->second.type(), Value::Type::STRING);
   EXPECT_EQ(cbor_val.GetMap().find(key_9)->second.GetString(), "b");
 
-  const CBORValue key_999(999);
+  const Value key_999(999);
   ASSERT_EQ(cbor_val.GetMap().count(key_999), 1u);
   ASSERT_EQ(cbor_val.GetMap().find(key_999)->second.type(),
-            CBORValue::Type::STRING);
+            Value::Type::STRING);
   EXPECT_EQ(cbor_val.GetMap().find(key_999)->second.GetString(), "c");
 
-  const CBORValue key_1111(1111);
+  const Value key_1111(1111);
   ASSERT_EQ(cbor_val.GetMap().count(key_1111), 1u);
   ASSERT_EQ(cbor_val.GetMap().find(key_1111)->second.type(),
-            CBORValue::Type::STRING);
+            Value::Type::STRING);
   EXPECT_EQ(cbor_val.GetMap().find(key_1111)->second.GetString(), "d");
 
   auto cbor_data_with_extra_byte = WithExtraneousData(kMapWithIntegerKeyCbor);
-  CBORReader::DecoderError error_code;
-  cbor = CBORReader::Read(cbor_data_with_extra_byte, &error_code);
+  Reader::DecoderError error_code;
+  cbor = Reader::Read(cbor_data_with_extra_byte, &error_code);
   EXPECT_FALSE(cbor.has_value());
-  EXPECT_EQ(error_code, CBORReader::DecoderError::EXTRANEOUS_DATA);
+  EXPECT_EQ(error_code, Reader::DecoderError::EXTRANEOUS_DATA);
 
   size_t num_bytes_consumed;
-  cbor = CBORReader::Read(cbor_data_with_extra_byte, &num_bytes_consumed,
-                          &error_code);
+  cbor =
+      Reader::Read(cbor_data_with_extra_byte, &num_bytes_consumed, &error_code);
   ASSERT_TRUE(cbor.has_value());
-  ASSERT_EQ(cbor_val.type(), CBORValue::Type::MAP);
+  ASSERT_EQ(cbor_val.type(), Value::Type::MAP);
   ASSERT_EQ(cbor_val.GetMap().size(), 4u);
-  EXPECT_EQ(error_code, CBORReader::DecoderError::CBOR_NO_ERROR);
+  EXPECT_EQ(error_code, Reader::DecoderError::CBOR_NO_ERROR);
   EXPECT_EQ(num_bytes_consumed, kMapWithIntegerKeyCbor.size());
 }
 
@@ -491,43 +486,43 @@ TEST(CBORReaderTest, TestReadMapWithNegativeIntegersKeys) {
       // clang-format on
   };
 
-  base::Optional<CBORValue> cbor = CBORReader::Read(kMapWithIntegerKeyCbor);
+  base::Optional<Value> cbor = Reader::Read(kMapWithIntegerKeyCbor);
   ASSERT_TRUE(cbor.has_value());
-  const CBORValue cbor_val = std::move(cbor.value());
-  ASSERT_EQ(cbor_val.type(), CBORValue::Type::MAP);
+  const Value cbor_val = std::move(cbor.value());
+  ASSERT_EQ(cbor_val.type(), Value::Type::MAP);
   ASSERT_EQ(cbor_val.GetMap().size(), 3u);
 
-  const CBORValue key_1(-1);
+  const Value key_1(-1);
   ASSERT_EQ(cbor_val.GetMap().count(key_1), 1u);
   ASSERT_EQ(cbor_val.GetMap().find(key_1)->second.type(),
-            CBORValue::Type::UNSIGNED);
+            Value::Type::UNSIGNED);
   EXPECT_EQ(cbor_val.GetMap().find(key_1)->second.GetInteger(), 1);
 
-  const CBORValue key_2(-2);
+  const Value key_2(-2);
   ASSERT_EQ(cbor_val.GetMap().count(key_2), 1u);
   ASSERT_EQ(cbor_val.GetMap().find(key_2)->second.type(),
-            CBORValue::Type::UNSIGNED);
+            Value::Type::UNSIGNED);
   EXPECT_EQ(cbor_val.GetMap().find(key_2)->second.GetInteger(), 2);
 
-  const CBORValue key_100(-100);
+  const Value key_100(-100);
   ASSERT_EQ(cbor_val.GetMap().count(key_100), 1u);
   ASSERT_EQ(cbor_val.GetMap().find(key_100)->second.type(),
-            CBORValue::Type::UNSIGNED);
+            Value::Type::UNSIGNED);
   EXPECT_EQ(cbor_val.GetMap().find(key_100)->second.GetInteger(), 3);
 
   auto cbor_data_with_extra_byte = WithExtraneousData(kMapWithIntegerKeyCbor);
-  CBORReader::DecoderError error_code;
-  cbor = CBORReader::Read(cbor_data_with_extra_byte, &error_code);
+  Reader::DecoderError error_code;
+  cbor = Reader::Read(cbor_data_with_extra_byte, &error_code);
   EXPECT_FALSE(cbor.has_value());
-  EXPECT_EQ(error_code, CBORReader::DecoderError::EXTRANEOUS_DATA);
+  EXPECT_EQ(error_code, Reader::DecoderError::EXTRANEOUS_DATA);
 
   size_t num_bytes_consumed;
-  cbor = CBORReader::Read(cbor_data_with_extra_byte, &num_bytes_consumed,
-                          &error_code);
+  cbor =
+      Reader::Read(cbor_data_with_extra_byte, &num_bytes_consumed, &error_code);
   ASSERT_TRUE(cbor.has_value());
-  ASSERT_EQ(cbor_val.type(), CBORValue::Type::MAP);
+  ASSERT_EQ(cbor_val.type(), Value::Type::MAP);
   ASSERT_EQ(cbor_val.GetMap().size(), 3u);
-  EXPECT_EQ(error_code, CBORReader::DecoderError::CBOR_NO_ERROR);
+  EXPECT_EQ(error_code, Reader::DecoderError::CBOR_NO_ERROR);
   EXPECT_EQ(num_bytes_consumed, kMapWithIntegerKeyCbor.size());
 }
 
@@ -545,44 +540,43 @@ TEST(CBORReaderTest, TestReadMapWithArray) {
       // clang-format on
   };
 
-  base::Optional<CBORValue> cbor = CBORReader::Read(kMapArrayTestCaseCbor);
+  base::Optional<Value> cbor = Reader::Read(kMapArrayTestCaseCbor);
   ASSERT_TRUE(cbor.has_value());
-  const CBORValue cbor_val = std::move(cbor.value());
-  ASSERT_EQ(cbor_val.type(), CBORValue::Type::MAP);
+  const Value cbor_val = std::move(cbor.value());
+  ASSERT_EQ(cbor_val.type(), Value::Type::MAP);
   ASSERT_EQ(cbor_val.GetMap().size(), 2u);
 
-  const CBORValue key_a("a");
+  const Value key_a("a");
   ASSERT_EQ(cbor_val.GetMap().count(key_a), 1u);
   ASSERT_EQ(cbor_val.GetMap().find(key_a)->second.type(),
-            CBORValue::Type::UNSIGNED);
+            Value::Type::UNSIGNED);
   EXPECT_EQ(cbor_val.GetMap().find(key_a)->second.GetInteger(), 1u);
 
-  const CBORValue key_b("b");
+  const Value key_b("b");
   ASSERT_EQ(cbor_val.GetMap().count(key_b), 1u);
-  ASSERT_EQ(cbor_val.GetMap().find(key_b)->second.type(),
-            CBORValue::Type::ARRAY);
+  ASSERT_EQ(cbor_val.GetMap().find(key_b)->second.type(), Value::Type::ARRAY);
 
-  const CBORValue nested_array = cbor_val.GetMap().find(key_b)->second.Clone();
+  const Value nested_array = cbor_val.GetMap().find(key_b)->second.Clone();
   ASSERT_EQ(nested_array.GetArray().size(), 2u);
   for (int i = 0; i < 2; i++) {
-    ASSERT_THAT(nested_array.GetArray()[i].type(), CBORValue::Type::UNSIGNED);
+    ASSERT_THAT(nested_array.GetArray()[i].type(), Value::Type::UNSIGNED);
     EXPECT_EQ(nested_array.GetArray()[i].GetInteger(),
               static_cast<int64_t>(i + 2));
   }
 
   auto cbor_data_with_extra_byte = WithExtraneousData(kMapArrayTestCaseCbor);
-  CBORReader::DecoderError error_code;
-  cbor = CBORReader::Read(cbor_data_with_extra_byte, &error_code);
+  Reader::DecoderError error_code;
+  cbor = Reader::Read(cbor_data_with_extra_byte, &error_code);
   EXPECT_FALSE(cbor.has_value());
-  EXPECT_EQ(error_code, CBORReader::DecoderError::EXTRANEOUS_DATA);
+  EXPECT_EQ(error_code, Reader::DecoderError::EXTRANEOUS_DATA);
 
   size_t num_bytes_consumed;
-  cbor = CBORReader::Read(cbor_data_with_extra_byte, &num_bytes_consumed,
-                          &error_code);
+  cbor =
+      Reader::Read(cbor_data_with_extra_byte, &num_bytes_consumed, &error_code);
   ASSERT_TRUE(cbor.has_value());
-  ASSERT_EQ(cbor_val.type(), CBORValue::Type::MAP);
+  ASSERT_EQ(cbor_val.type(), Value::Type::MAP);
   ASSERT_EQ(cbor_val.GetMap().size(), 2u);
-  EXPECT_EQ(error_code, CBORReader::DecoderError::CBOR_NO_ERROR);
+  EXPECT_EQ(error_code, Reader::DecoderError::CBOR_NO_ERROR);
   EXPECT_EQ(num_bytes_consumed, kMapArrayTestCaseCbor.size());
 }
 
@@ -598,35 +592,34 @@ TEST(CBORReaderTest, TestReadMapWithTextStringKeys) {
       // clang-format on
   };
 
-  CBORReader::DecoderError error_code;
-  base::Optional<CBORValue> cbor = CBORReader::Read(kMapTestCase, &error_code);
+  Reader::DecoderError error_code;
+  base::Optional<Value> cbor = Reader::Read(kMapTestCase, &error_code);
   ASSERT_TRUE(cbor.has_value());
-  ASSERT_EQ(cbor->type(), CBORValue::Type::MAP);
+  ASSERT_EQ(cbor->type(), Value::Type::MAP);
   ASSERT_EQ(cbor->GetMap().size(), 2u);
 
-  const CBORValue key_k("k");
+  const Value key_k("k");
   ASSERT_EQ(cbor->GetMap().count(key_k), 1u);
-  ASSERT_EQ(cbor->GetMap().find(key_k)->second.type(), CBORValue::Type::STRING);
+  ASSERT_EQ(cbor->GetMap().find(key_k)->second.type(), Value::Type::STRING);
   EXPECT_EQ(cbor->GetMap().find(key_k)->second.GetString(), "v");
 
-  const CBORValue key_foo("foo");
+  const Value key_foo("foo");
   ASSERT_EQ(cbor->GetMap().count(key_foo), 1u);
-  ASSERT_EQ(cbor->GetMap().find(key_foo)->second.type(),
-            CBORValue::Type::STRING);
+  ASSERT_EQ(cbor->GetMap().find(key_foo)->second.type(), Value::Type::STRING);
   EXPECT_EQ(cbor->GetMap().find(key_foo)->second.GetString(), "bar");
 
   auto cbor_data_with_extra_byte = WithExtraneousData(kMapTestCase);
-  cbor = CBORReader::Read(cbor_data_with_extra_byte, &error_code);
+  cbor = Reader::Read(cbor_data_with_extra_byte, &error_code);
   EXPECT_FALSE(cbor.has_value());
-  EXPECT_EQ(error_code, CBORReader::DecoderError::EXTRANEOUS_DATA);
+  EXPECT_EQ(error_code, Reader::DecoderError::EXTRANEOUS_DATA);
 
   size_t num_bytes_consumed;
-  cbor = CBORReader::Read(cbor_data_with_extra_byte, &num_bytes_consumed,
-                          &error_code);
+  cbor =
+      Reader::Read(cbor_data_with_extra_byte, &num_bytes_consumed, &error_code);
   ASSERT_TRUE(cbor.has_value());
-  ASSERT_EQ(cbor->type(), CBORValue::Type::MAP);
+  ASSERT_EQ(cbor->type(), Value::Type::MAP);
   ASSERT_EQ(cbor->GetMap().size(), 2u);
-  EXPECT_EQ(error_code, CBORReader::DecoderError::CBOR_NO_ERROR);
+  EXPECT_EQ(error_code, Reader::DecoderError::CBOR_NO_ERROR);
   EXPECT_EQ(num_bytes_consumed, kMapTestCase.size());
 }
 
@@ -642,38 +635,38 @@ TEST(CBORReaderTest, TestReadMapWithByteStringKeys) {
       // clang-format on
   };
 
-  CBORReader::DecoderError error_code;
-  base::Optional<CBORValue> cbor = CBORReader::Read(kMapTestCase, &error_code);
+  Reader::DecoderError error_code;
+  base::Optional<Value> cbor = Reader::Read(kMapTestCase, &error_code);
   ASSERT_TRUE(cbor.has_value());
-  ASSERT_EQ(cbor->type(), CBORValue::Type::MAP);
+  ASSERT_EQ(cbor->type(), Value::Type::MAP);
   ASSERT_EQ(cbor->GetMap().size(), 2u);
 
-  const CBORValue key_k(std::vector<uint8_t>{'k'});
+  const Value key_k(std::vector<uint8_t>{'k'});
   ASSERT_EQ(cbor->GetMap().count(key_k), 1u);
   ASSERT_EQ(cbor->GetMap().find(key_k)->second.type(),
-            CBORValue::Type::BYTE_STRING);
+            Value::Type::BYTE_STRING);
   EXPECT_EQ(cbor->GetMap().find(key_k)->second.GetBytestring(),
             std::vector<uint8_t>{'v'});
 
-  const CBORValue key_foo(std::vector<uint8_t>{'f', 'o', 'o'});
+  const Value key_foo(std::vector<uint8_t>{'f', 'o', 'o'});
   ASSERT_EQ(cbor->GetMap().count(key_foo), 1u);
   ASSERT_EQ(cbor->GetMap().find(key_foo)->second.type(),
-            CBORValue::Type::BYTE_STRING);
+            Value::Type::BYTE_STRING);
   static const std::vector<uint8_t> kBarBytes{'b', 'a', 'r'};
   EXPECT_EQ(cbor->GetMap().find(key_foo)->second.GetBytestring(), kBarBytes);
 
   auto cbor_data_with_extra_byte = WithExtraneousData(kMapTestCase);
-  cbor = CBORReader::Read(cbor_data_with_extra_byte, &error_code);
+  cbor = Reader::Read(cbor_data_with_extra_byte, &error_code);
   EXPECT_FALSE(cbor.has_value());
-  EXPECT_EQ(error_code, CBORReader::DecoderError::EXTRANEOUS_DATA);
+  EXPECT_EQ(error_code, Reader::DecoderError::EXTRANEOUS_DATA);
 
   size_t num_bytes_consumed;
-  cbor = CBORReader::Read(cbor_data_with_extra_byte, &num_bytes_consumed,
-                          &error_code);
+  cbor =
+      Reader::Read(cbor_data_with_extra_byte, &num_bytes_consumed, &error_code);
   ASSERT_TRUE(cbor.has_value());
-  ASSERT_EQ(cbor->type(), CBORValue::Type::MAP);
+  ASSERT_EQ(cbor->type(), Value::Type::MAP);
   ASSERT_EQ(cbor->GetMap().size(), 2u);
-  EXPECT_EQ(error_code, CBORReader::DecoderError::CBOR_NO_ERROR);
+  EXPECT_EQ(error_code, Reader::DecoderError::CBOR_NO_ERROR);
   EXPECT_EQ(num_bytes_consumed, kMapTestCase.size());
 }
 
@@ -715,40 +708,40 @@ TEST(CBORReaderTest, TestReadMapWithMixedKeys) {
       // clang-format on
   };
 
-  CBORReader::DecoderError error_code;
-  base::Optional<CBORValue> cbor = CBORReader::Read(kMapTestCase, &error_code);
+  Reader::DecoderError error_code;
+  base::Optional<Value> cbor = Reader::Read(kMapTestCase, &error_code);
   ASSERT_TRUE(cbor.has_value());
-  ASSERT_EQ(cbor->type(), CBORValue::Type::MAP);
+  ASSERT_EQ(cbor->type(), Value::Type::MAP);
   ASSERT_EQ(cbor->GetMap().size(), 6u);
 
-  std::vector<CBORValue> keys;
+  std::vector<Value> keys;
   keys.emplace_back(10);
   keys.emplace_back(100);
   keys.emplace_back(-1);
-  keys.emplace_back(CBORValue::BinaryValue{'x', 'y'});
+  keys.emplace_back(Value::BinaryValue{'x', 'y'});
   keys.emplace_back("z");
   keys.emplace_back("aa");
   for (size_t i = 0; i < keys.size(); ++i) {
     SCOPED_TRACE(testing::Message() << "testing key at index: " << i);
     ASSERT_EQ(cbor->GetMap().count(keys[i]), 1u);
     ASSERT_EQ(cbor->GetMap().find(keys[i])->second.type(),
-              CBORValue::Type::UNSIGNED);
+              Value::Type::UNSIGNED);
     EXPECT_EQ(cbor->GetMap().find(keys[i])->second.GetInteger(),
               static_cast<int>(i));
   }
 
   auto cbor_data_with_extra_byte = WithExtraneousData(kMapTestCase);
-  cbor = CBORReader::Read(cbor_data_with_extra_byte, &error_code);
+  cbor = Reader::Read(cbor_data_with_extra_byte, &error_code);
   EXPECT_FALSE(cbor.has_value());
-  EXPECT_EQ(error_code, CBORReader::DecoderError::EXTRANEOUS_DATA);
+  EXPECT_EQ(error_code, Reader::DecoderError::EXTRANEOUS_DATA);
 
   size_t num_bytes_consumed;
-  cbor = CBORReader::Read(cbor_data_with_extra_byte, &num_bytes_consumed,
-                          &error_code);
+  cbor =
+      Reader::Read(cbor_data_with_extra_byte, &num_bytes_consumed, &error_code);
   ASSERT_TRUE(cbor.has_value());
-  ASSERT_EQ(cbor->type(), CBORValue::Type::MAP);
+  ASSERT_EQ(cbor->type(), Value::Type::MAP);
   ASSERT_EQ(cbor->GetMap().size(), 6u);
-  EXPECT_EQ(error_code, CBORReader::DecoderError::CBOR_NO_ERROR);
+  EXPECT_EQ(error_code, Reader::DecoderError::CBOR_NO_ERROR);
   EXPECT_EQ(num_bytes_consumed, arraysize(kMapTestCase));
 }
 
@@ -769,34 +762,34 @@ TEST(CBORReaderTest, TestReadNestedMap) {
       // clang-format on
   };
 
-  base::Optional<CBORValue> cbor = CBORReader::Read(kNestedMapTestCase);
+  base::Optional<Value> cbor = Reader::Read(kNestedMapTestCase);
   ASSERT_TRUE(cbor.has_value());
-  const CBORValue cbor_val = std::move(cbor.value());
-  ASSERT_EQ(cbor_val.type(), CBORValue::Type::MAP);
+  const Value cbor_val = std::move(cbor.value());
+  ASSERT_EQ(cbor_val.type(), Value::Type::MAP);
   ASSERT_EQ(cbor_val.GetMap().size(), 2u);
 
-  const CBORValue key_a("a");
+  const Value key_a("a");
   ASSERT_EQ(cbor_val.GetMap().count(key_a), 1u);
   ASSERT_EQ(cbor_val.GetMap().find(key_a)->second.type(),
-            CBORValue::Type::UNSIGNED);
+            Value::Type::UNSIGNED);
   EXPECT_EQ(cbor_val.GetMap().find(key_a)->second.GetInteger(), 1u);
 
-  const CBORValue key_b("b");
+  const Value key_b("b");
   ASSERT_EQ(cbor_val.GetMap().count(key_b), 1u);
-  const CBORValue nested_map = cbor_val.GetMap().find(key_b)->second.Clone();
-  ASSERT_EQ(nested_map.type(), CBORValue::Type::MAP);
+  const Value nested_map = cbor_val.GetMap().find(key_b)->second.Clone();
+  ASSERT_EQ(nested_map.type(), Value::Type::MAP);
   ASSERT_EQ(nested_map.GetMap().size(), 2u);
 
-  const CBORValue key_c("c");
+  const Value key_c("c");
   ASSERT_EQ(nested_map.GetMap().count(key_c), 1u);
   ASSERT_EQ(nested_map.GetMap().find(key_c)->second.type(),
-            CBORValue::Type::UNSIGNED);
+            Value::Type::UNSIGNED);
   EXPECT_EQ(nested_map.GetMap().find(key_c)->second.GetInteger(), 2u);
 
-  const CBORValue key_d("d");
+  const Value key_d("d");
   ASSERT_EQ(nested_map.GetMap().count(key_d), 1u);
   ASSERT_EQ(nested_map.GetMap().find(key_d)->second.type(),
-            CBORValue::Type::UNSIGNED);
+            Value::Type::UNSIGNED);
   EXPECT_EQ(nested_map.GetMap().find(key_d)->second.GetInteger(), 3u);
 }
 
@@ -806,13 +799,11 @@ TEST(CBORReaderTest, TestIntegerRange) {
   static const std::vector<uint8_t> kMinNegativeInt = {
       0x3b, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
 
-  base::Optional<CBORValue> max_positive_int =
-      CBORReader::Read(kMaxPositiveInt);
+  base::Optional<Value> max_positive_int = Reader::Read(kMaxPositiveInt);
   ASSERT_TRUE(max_positive_int.has_value());
   EXPECT_EQ(max_positive_int.value().GetInteger(), INT64_MAX);
 
-  base::Optional<CBORValue> min_negative_int =
-      CBORReader::Read(kMinNegativeInt);
+  base::Optional<Value> min_negative_int = Reader::Read(kMinNegativeInt);
   ASSERT_TRUE(min_negative_int.has_value());
   EXPECT_EQ(min_negative_int.value().GetInteger(), INT64_MIN);
 }
@@ -824,27 +815,27 @@ TEST(CBORReaderTest, TestIntegerOutOfRangeError) {
   static const std::vector<uint8_t> kOutOfRangeNegativeInt = {
       0x3b, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
-  CBORReader::DecoderError error_code;
-  base::Optional<CBORValue> positive_int_out_of_range_cbor =
-      CBORReader::Read(kOutOfRangePositiveInt, &error_code);
+  Reader::DecoderError error_code;
+  base::Optional<Value> positive_int_out_of_range_cbor =
+      Reader::Read(kOutOfRangePositiveInt, &error_code);
   EXPECT_FALSE(positive_int_out_of_range_cbor.has_value());
-  EXPECT_EQ(error_code, CBORReader::DecoderError::OUT_OF_RANGE_INTEGER_VALUE);
+  EXPECT_EQ(error_code, Reader::DecoderError::OUT_OF_RANGE_INTEGER_VALUE);
 
-  base::Optional<CBORValue> negative_int_out_of_range_cbor =
-      CBORReader::Read(kOutOfRangeNegativeInt, &error_code);
+  base::Optional<Value> negative_int_out_of_range_cbor =
+      Reader::Read(kOutOfRangeNegativeInt, &error_code);
   EXPECT_FALSE(negative_int_out_of_range_cbor.has_value());
-  EXPECT_EQ(error_code, CBORReader::DecoderError::OUT_OF_RANGE_INTEGER_VALUE);
+  EXPECT_EQ(error_code, Reader::DecoderError::OUT_OF_RANGE_INTEGER_VALUE);
 }
 
 TEST(CBORReaderTest, TestReadSimpleValue) {
   static const struct {
-    const CBORValue::SimpleValue value;
+    const Value::SimpleValue value;
     const std::vector<uint8_t> cbor_data;
   } kSimpleValueTestCases[] = {
-      {CBORValue::SimpleValue::FALSE_VALUE, {0xf4}},
-      {CBORValue::SimpleValue::TRUE_VALUE, {0xf5}},
-      {CBORValue::SimpleValue::NULL_VALUE, {0xf6}},
-      {CBORValue::SimpleValue::UNDEFINED, {0xf7}},
+      {Value::SimpleValue::FALSE_VALUE, {0xf4}},
+      {Value::SimpleValue::TRUE_VALUE, {0xf5}},
+      {Value::SimpleValue::NULL_VALUE, {0xf6}},
+      {Value::SimpleValue::UNDEFINED, {0xf7}},
   };
 
   int test_element_index = 0;
@@ -852,24 +843,24 @@ TEST(CBORReaderTest, TestReadSimpleValue) {
     SCOPED_TRACE(testing::Message()
                  << "testing simple value at index : " << test_element_index++);
 
-    base::Optional<CBORValue> cbor = CBORReader::Read(test_case.cbor_data);
+    base::Optional<Value> cbor = Reader::Read(test_case.cbor_data);
     ASSERT_TRUE(cbor.has_value());
-    ASSERT_EQ(cbor.value().type(), CBORValue::Type::SIMPLE_VALUE);
+    ASSERT_EQ(cbor.value().type(), Value::Type::SIMPLE_VALUE);
     EXPECT_EQ(cbor.value().GetSimpleValue(), test_case.value);
 
     auto cbor_data_with_extra_byte = WithExtraneousData(test_case.cbor_data);
-    CBORReader::DecoderError error_code;
-    cbor = CBORReader::Read(cbor_data_with_extra_byte, &error_code);
+    Reader::DecoderError error_code;
+    cbor = Reader::Read(cbor_data_with_extra_byte, &error_code);
     EXPECT_FALSE(cbor.has_value());
-    EXPECT_EQ(error_code, CBORReader::DecoderError::EXTRANEOUS_DATA);
+    EXPECT_EQ(error_code, Reader::DecoderError::EXTRANEOUS_DATA);
 
     size_t num_bytes_consumed;
-    cbor = CBORReader::Read(cbor_data_with_extra_byte, &num_bytes_consumed,
-                            &error_code);
+    cbor = Reader::Read(cbor_data_with_extra_byte, &num_bytes_consumed,
+                        &error_code);
     ASSERT_TRUE(cbor.has_value());
-    ASSERT_EQ(cbor.value().type(), CBORValue::Type::SIMPLE_VALUE);
+    ASSERT_EQ(cbor.value().type(), Value::Type::SIMPLE_VALUE);
     EXPECT_EQ(cbor.value().GetSimpleValue(), test_case.value);
-    EXPECT_EQ(error_code, CBORReader::DecoderError::CBOR_NO_ERROR);
+    EXPECT_EQ(error_code, Reader::DecoderError::CBOR_NO_ERROR);
     EXPECT_EQ(num_bytes_consumed, test_case.cbor_data.size());
   }
 }
@@ -887,12 +878,12 @@ TEST(CBORReaderTest, TestReadUnsupportedFloatingPointNumbers) {
     SCOPED_TRACE(testing::Message()
                  << "testing unsupported floating point : "
                  << testing::PrintToString(unsupported_floating_point));
-    CBORReader::DecoderError error_code;
-    base::Optional<CBORValue> cbor =
-        CBORReader::Read(unsupported_floating_point, &error_code);
+    Reader::DecoderError error_code;
+    base::Optional<Value> cbor =
+        Reader::Read(unsupported_floating_point, &error_code);
     EXPECT_FALSE(cbor.has_value());
     EXPECT_EQ(error_code,
-              CBORReader::DecoderError::UNSUPPORTED_FLOATING_POINT_VALUE);
+              Reader::DecoderError::UNSUPPORTED_FLOATING_POINT_VALUE);
   }
 }
 
@@ -932,11 +923,10 @@ TEST(CBORReaderTest, TestIncompleteCBORDataError) {
     SCOPED_TRACE(testing::Message() << "testing incomplete data at index : "
                                     << test_element_index++);
 
-    CBORReader::DecoderError error_code;
-    base::Optional<CBORValue> cbor =
-        CBORReader::Read(incomplete_data, &error_code);
+    Reader::DecoderError error_code;
+    base::Optional<Value> cbor = Reader::Read(incomplete_data, &error_code);
     EXPECT_FALSE(cbor.has_value());
-    EXPECT_EQ(error_code, CBORReader::DecoderError::INCOMPLETE_CBOR_DATA);
+    EXPECT_EQ(error_code, Reader::DecoderError::INCOMPLETE_CBOR_DATA);
   }
 }
 
@@ -955,11 +945,10 @@ TEST(CBORReaderTest, TestUnsupportedMapKeyFormatError) {
       // clang-format on
   };
 
-  CBORReader::DecoderError error_code;
-  base::Optional<CBORValue> cbor =
-      CBORReader::Read(kMapWithUintKey, &error_code);
+  Reader::DecoderError error_code;
+  base::Optional<Value> cbor = Reader::Read(kMapWithUintKey, &error_code);
   EXPECT_FALSE(cbor.has_value());
-  EXPECT_EQ(error_code, CBORReader::DecoderError::INCORRECT_MAP_KEY_TYPE);
+  EXPECT_EQ(error_code, Reader::DecoderError::INCORRECT_MAP_KEY_TYPE);
 }
 
 TEST(CBORReaderTest, TestUnknownAdditionalInfoError) {
@@ -988,11 +977,10 @@ TEST(CBORReaderTest, TestUnknownAdditionalInfoError) {
     SCOPED_TRACE(testing::Message()
                  << "testing data at index : " << test_element_index++);
 
-    CBORReader::DecoderError error_code;
-    base::Optional<CBORValue> cbor =
-        CBORReader::Read(incorrect_cbor, &error_code);
+    Reader::DecoderError error_code;
+    base::Optional<Value> cbor = Reader::Read(incorrect_cbor, &error_code);
     EXPECT_FALSE(cbor.has_value());
-    EXPECT_EQ(error_code, CBORReader::DecoderError::UNKNOWN_ADDITIONAL_INFO);
+    EXPECT_EQ(error_code, Reader::DecoderError::UNKNOWN_ADDITIONAL_INFO);
   }
 }
 
@@ -1014,11 +1002,10 @@ TEST(CBORReaderTest, TestTooMuchNestingError) {
   for (const auto& zero_depth_data : kZeroDepthCBORList) {
     SCOPED_TRACE(testing::Message()
                  << "testing zero nested data : " << test_element_index++);
-    CBORReader::DecoderError error_code;
-    base::Optional<CBORValue> cbor =
-        CBORReader::Read(zero_depth_data, &error_code, 0);
+    Reader::DecoderError error_code;
+    base::Optional<Value> cbor = Reader::Read(zero_depth_data, &error_code, 0);
     EXPECT_TRUE(cbor.has_value());
-    EXPECT_EQ(error_code, CBORReader::DecoderError::CBOR_NO_ERROR);
+    EXPECT_EQ(error_code, Reader::DecoderError::CBOR_NO_ERROR);
   }
 
   // Corresponds to a CBOR structure with a nesting depth of 2:
@@ -1037,16 +1024,16 @@ TEST(CBORReaderTest, TestTooMuchNestingError) {
       // clang-format on
   };
 
-  CBORReader::DecoderError error_code;
-  base::Optional<CBORValue> cbor_single_layer_max =
-      CBORReader::Read(kNestedCBORData, &error_code, 1);
+  Reader::DecoderError error_code;
+  base::Optional<Value> cbor_single_layer_max =
+      Reader::Read(kNestedCBORData, &error_code, 1);
   EXPECT_FALSE(cbor_single_layer_max.has_value());
-  EXPECT_EQ(error_code, CBORReader::DecoderError::TOO_MUCH_NESTING);
+  EXPECT_EQ(error_code, Reader::DecoderError::TOO_MUCH_NESTING);
 
-  base::Optional<CBORValue> cbor_double_layer_max =
-      CBORReader::Read(kNestedCBORData, &error_code, 2);
+  base::Optional<Value> cbor_double_layer_max =
+      Reader::Read(kNestedCBORData, &error_code, 2);
   EXPECT_TRUE(cbor_double_layer_max.has_value());
-  EXPECT_EQ(error_code, CBORReader::DecoderError::CBOR_NO_ERROR);
+  EXPECT_EQ(error_code, Reader::DecoderError::CBOR_NO_ERROR);
 }
 
 TEST(CBORReaderTest, TestOutOfOrderKeyError) {
@@ -1093,16 +1080,16 @@ TEST(CBORReaderTest, TestOutOfOrderKeyError) {
   };
 
   int test_element_index = 0;
-  CBORReader::DecoderError error_code;
+  Reader::DecoderError error_code;
   for (const auto& unsorted_map : kMapsWithUnsortedKeys) {
     testing::Message scope_message;
     scope_message << "testing unsorted map : " << test_element_index++;
     SCOPED_TRACE(scope_message);
 
-    base::Optional<CBORValue> cbor =
-        CBORReader::Read(unsorted_map, &error_code);
+    base::Optional<Value> cbor =
+        Reader::Read(unsorted_map, &error_code);
     EXPECT_FALSE(cbor.has_value());
-    EXPECT_EQ(error_code, CBORReader::DecoderError::OUT_OF_ORDER_KEY);
+    EXPECT_EQ(error_code, Reader::DecoderError::OUT_OF_ORDER_KEY);
   }
 }
 
@@ -1130,12 +1117,11 @@ TEST(CBORReaderTest, TestDuplicateKeyError) {
       // clang-format on
   };
 
-  CBORReader::DecoderError error_code;
+  Reader::DecoderError error_code;
 
-  base::Optional<CBORValue> cbor =
-      CBORReader::Read(kMapWithDuplicateKey, &error_code);
+  base::Optional<Value> cbor = Reader::Read(kMapWithDuplicateKey, &error_code);
   EXPECT_FALSE(cbor.has_value());
-  EXPECT_EQ(error_code, CBORReader::DecoderError::OUT_OF_ORDER_KEY);
+  EXPECT_EQ(error_code, Reader::DecoderError::OUT_OF_ORDER_KEY);
 }
 
 // Leveraging Markus Kuhn’s UTF-8 decoder stress test. See
@@ -1151,23 +1137,23 @@ TEST(CBORReaderTest, TestIncorrectStringEncodingError) {
   };
 
   int test_element_index = 0;
-  CBORReader::DecoderError error_code;
+  Reader::DecoderError error_code;
   for (const auto& cbor_byte : utf8_character_encodings) {
     SCOPED_TRACE(testing::Message() << "testing cbor data utf8 encoding : "
                                     << test_element_index++);
 
-    base::Optional<CBORValue> correctly_encoded_cbor =
-        CBORReader::Read(cbor_byte, &error_code);
+    base::Optional<Value> correctly_encoded_cbor =
+        Reader::Read(cbor_byte, &error_code);
     EXPECT_TRUE(correctly_encoded_cbor.has_value());
-    EXPECT_EQ(error_code, CBORReader::DecoderError::CBOR_NO_ERROR);
+    EXPECT_EQ(error_code, Reader::DecoderError::CBOR_NO_ERROR);
   }
 
   // Incorrect UTF8 encoding referenced by section 3.5.3 of the stress test.
   std::vector<uint8_t> impossible_utf_byte{0x64, 0xfe, 0xfe, 0xff, 0xff};
-  base::Optional<CBORValue> incorrectly_encoded_cbor =
-      CBORReader::Read(impossible_utf_byte, &error_code);
+  base::Optional<Value> incorrectly_encoded_cbor =
+      Reader::Read(impossible_utf_byte, &error_code);
   EXPECT_FALSE(incorrectly_encoded_cbor.has_value());
-  EXPECT_EQ(error_code, CBORReader::DecoderError::INVALID_UTF8);
+  EXPECT_EQ(error_code, Reader::DecoderError::INVALID_UTF8);
 }
 
 TEST(CBORReaderTest, TestExtraneousCBORDataError) {
@@ -1189,11 +1175,11 @@ TEST(CBORReaderTest, TestExtraneousCBORDataError) {
     SCOPED_TRACE(testing::Message()
                  << "testing cbor extraneous data : " << test_element_index++);
 
-    CBORReader::DecoderError error_code;
-    base::Optional<CBORValue> cbor =
-        CBORReader::Read(extraneous_cbor_data, &error_code);
+    Reader::DecoderError error_code;
+    base::Optional<Value> cbor =
+        Reader::Read(extraneous_cbor_data, &error_code);
     EXPECT_FALSE(cbor.has_value());
-    EXPECT_EQ(error_code, CBORReader::DecoderError::EXTRANEOUS_DATA);
+    EXPECT_EQ(error_code, Reader::DecoderError::EXTRANEOUS_DATA);
   }
 }
 
@@ -1224,11 +1210,11 @@ TEST(CBORReaderTest, TestUnsupportedSimpleValue) {
                  << "testing unsupported cbor simple value  : "
                  << ::testing::PrintToString(unsupported_simple_val));
 
-    CBORReader::DecoderError error_code;
-    base::Optional<CBORValue> cbor =
-        CBORReader::Read(unsupported_simple_val, &error_code);
+    Reader::DecoderError error_code;
+    base::Optional<Value> cbor =
+        Reader::Read(unsupported_simple_val, &error_code);
     EXPECT_FALSE(cbor.has_value());
-    EXPECT_EQ(error_code, CBORReader::DecoderError::UNSUPPORTED_SIMPLE_VALUE);
+    EXPECT_EQ(error_code, Reader::DecoderError::UNSUPPORTED_SIMPLE_VALUE);
   }
 }
 
@@ -1240,10 +1226,10 @@ TEST(CBORReaderTest, TestSuperLongContentDontCrash) {
       {0xbb, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
   };
   for (const auto& test_case : kTestCases) {
-    CBORReader::DecoderError error_code;
-    base::Optional<CBORValue> cbor = CBORReader::Read(test_case, &error_code);
+    Reader::DecoderError error_code;
+    base::Optional<Value> cbor = Reader::Read(test_case, &error_code);
     EXPECT_FALSE(cbor.has_value());
-    EXPECT_EQ(error_code, CBORReader::DecoderError::INCOMPLETE_CBOR_DATA);
+    EXPECT_EQ(error_code, Reader::DecoderError::INCOMPLETE_CBOR_DATA);
   }
 }
 
diff --git a/chromium/components/cbor/cbor_values.cc b/chromium/components/cbor/values.cc
index 397ce9a42c1..f495a7fd152 100644
--- a/chromium/components/cbor/cbor_values.cc
+++ b/chromium/components/cbor/values.cc
@@ -2,24 +2,24 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "components/cbor/cbor_values.h"
+#include "components/cbor/values.h"
 
 #include <new>
 #include <utility>
 
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_util.h"
-#include "components/cbor/cbor_constants.h"
+#include "components/cbor/constants.h"
 
 namespace cbor {
 
-CBORValue::CBORValue() noexcept : type_(Type::NONE) {}
+Value::Value() noexcept : type_(Type::NONE) {}
 
-CBORValue::CBORValue(CBORValue&& that) noexcept {
+Value::Value(Value&& that) noexcept {
   InternalMoveConstructFrom(std::move(that));
 }
 
-CBORValue::CBORValue(Type type) : type_(type) {
+Value::Value(Type type) : type_(type) {
   // Initialize with the default value.
   switch (type_) {
     case Type::UNSIGNED:
@@ -42,7 +42,7 @@ CBORValue::CBORValue(Type type) : type_(type) {
       NOTREACHED() << constants::kUnsupportedMajorType;
       return;
     case Type::SIMPLE_VALUE:
-      simple_value_ = CBORValue::SimpleValue::UNDEFINED;
+      simple_value_ = Value::SimpleValue::UNDEFINED;
       return;
     case Type::NONE:
       return;
@@ -50,35 +50,34 @@ CBORValue::CBORValue(Type type) : type_(type) {
   NOTREACHED();
 }
 
-CBORValue::CBORValue(SimpleValue in_simple)
+Value::Value(SimpleValue in_simple)
     : type_(Type::SIMPLE_VALUE), simple_value_(in_simple) {
   CHECK(static_cast<int>(in_simple) >= 20 && static_cast<int>(in_simple) <= 23);
 }
 
-CBORValue::CBORValue(bool boolean_value) : type_(Type::SIMPLE_VALUE) {
-  simple_value_ = boolean_value ? CBORValue::SimpleValue::TRUE_VALUE
-                                : CBORValue::SimpleValue::FALSE_VALUE;
+Value::Value(bool boolean_value) : type_(Type::SIMPLE_VALUE) {
+  simple_value_ = boolean_value ? Value::SimpleValue::TRUE_VALUE
+                                : Value::SimpleValue::FALSE_VALUE;
 }
 
-CBORValue::CBORValue(int integer_value)
-    : CBORValue(base::checked_cast<int64_t>(integer_value)) {}
+Value::Value(int integer_value)
+    : Value(base::checked_cast<int64_t>(integer_value)) {}
 
-CBORValue::CBORValue(int64_t integer_value) : integer_value_(integer_value) {
+Value::Value(int64_t integer_value) : integer_value_(integer_value) {
   type_ = integer_value >= 0 ? Type::UNSIGNED : Type::NEGATIVE;
 }
 
-CBORValue::CBORValue(base::span<const uint8_t> in_bytes)
+Value::Value(base::span<const uint8_t> in_bytes)
     : type_(Type::BYTE_STRING),
       bytestring_value_(in_bytes.begin(), in_bytes.end()) {}
 
-CBORValue::CBORValue(BinaryValue&& in_bytes) noexcept
+Value::Value(BinaryValue&& in_bytes) noexcept
     : type_(Type::BYTE_STRING), bytestring_value_(std::move(in_bytes)) {}
 
-CBORValue::CBORValue(const char* in_string, Type type)
-    : CBORValue(base::StringPiece(in_string), type) {}
+Value::Value(const char* in_string, Type type)
+    : Value(base::StringPiece(in_string), type) {}
 
-CBORValue::CBORValue(std::string&& in_string, Type type) noexcept
-    : type_(type) {
+Value::Value(std::string&& in_string, Type type) noexcept : type_(type) {
   switch (type_) {
     case Type::STRING:
       new (&string_value_) std::string();
@@ -94,7 +93,7 @@ CBORValue::CBORValue(std::string&& in_string, Type type) noexcept
   }
 }
 
-CBORValue::CBORValue(base::StringPiece in_string, Type type) : type_(type) {
+Value::Value(base::StringPiece in_string, Type type) : type_(type) {
   switch (type_) {
     case Type::STRING:
       new (&string_value_) std::string();
@@ -110,101 +109,100 @@ CBORValue::CBORValue(base::StringPiece in_string, Type type) : type_(type) {
   }
 }
 
-CBORValue::CBORValue(const ArrayValue& in_array)
-    : type_(Type::ARRAY), array_value_() {
+Value::Value(const ArrayValue& in_array) : type_(Type::ARRAY), array_value_() {
   array_value_.reserve(in_array.size());
   for (const auto& val : in_array)
     array_value_.emplace_back(val.Clone());
 }
 
-CBORValue::CBORValue(ArrayValue&& in_array) noexcept
+Value::Value(ArrayValue&& in_array) noexcept
     : type_(Type::ARRAY), array_value_(std::move(in_array)) {}
 
-CBORValue::CBORValue(const MapValue& in_map) : type_(Type::MAP), map_value_() {
+Value::Value(const MapValue& in_map) : type_(Type::MAP), map_value_() {
   map_value_.reserve(in_map.size());
   for (const auto& it : in_map)
     map_value_.emplace_hint(map_value_.end(), it.first.Clone(),
                             it.second.Clone());
 }
 
-CBORValue::CBORValue(MapValue&& in_map) noexcept
+Value::Value(MapValue&& in_map) noexcept
     : type_(Type::MAP), map_value_(std::move(in_map)) {}
 
-CBORValue& CBORValue::operator=(CBORValue&& that) noexcept {
+Value& Value::operator=(Value&& that) noexcept {
   InternalCleanup();
   InternalMoveConstructFrom(std::move(that));
 
   return *this;
 }
 
-CBORValue::~CBORValue() {
+Value::~Value() {
   InternalCleanup();
 }
 
-CBORValue CBORValue::Clone() const {
+Value Value::Clone() const {
   switch (type_) {
     case Type::NONE:
-      return CBORValue();
+      return Value();
     case Type::UNSIGNED:
     case Type::NEGATIVE:
-      return CBORValue(integer_value_);
+      return Value(integer_value_);
     case Type::BYTE_STRING:
-      return CBORValue(bytestring_value_);
+      return Value(bytestring_value_);
     case Type::STRING:
-      return CBORValue(string_value_);
+      return Value(string_value_);
     case Type::ARRAY:
-      return CBORValue(array_value_);
+      return Value(array_value_);
     case Type::MAP:
-      return CBORValue(map_value_);
+      return Value(map_value_);
     case Type::TAG:
       NOTREACHED() << constants::kUnsupportedMajorType;
-      return CBORValue();
+      return Value();
     case Type::SIMPLE_VALUE:
-      return CBORValue(simple_value_);
+      return Value(simple_value_);
   }
 
   NOTREACHED();
-  return CBORValue();
+  return Value();
 }
 
-CBORValue::SimpleValue CBORValue::GetSimpleValue() const {
+Value::SimpleValue Value::GetSimpleValue() const {
   CHECK(is_simple());
   return simple_value_;
 }
 
-bool CBORValue::GetBool() const {
+bool Value::GetBool() const {
   CHECK(is_bool());
   return simple_value_ == SimpleValue::TRUE_VALUE;
 }
 
-const int64_t& CBORValue::GetInteger() const {
+const int64_t& Value::GetInteger() const {
   CHECK(is_integer());
   return integer_value_;
 }
 
-const int64_t& CBORValue::GetUnsigned() const {
+const int64_t& Value::GetUnsigned() const {
   CHECK(is_unsigned());
   CHECK_GE(integer_value_, 0);
   return integer_value_;
 }
 
-const int64_t& CBORValue::GetNegative() const {
+const int64_t& Value::GetNegative() const {
   CHECK(is_negative());
   CHECK_LT(integer_value_, 0);
   return integer_value_;
 }
 
-const std::string& CBORValue::GetString() const {
+const std::string& Value::GetString() const {
   CHECK(is_string());
   return string_value_;
 }
 
-const CBORValue::BinaryValue& CBORValue::GetBytestring() const {
+const Value::BinaryValue& Value::GetBytestring() const {
   CHECK(is_bytestring());
   return bytestring_value_;
 }
 
-base::StringPiece CBORValue::GetBytestringAsString() const {
+base::StringPiece Value::GetBytestringAsString() const {
   CHECK(is_bytestring());
   const auto& bytestring_value = GetBytestring();
   return base::StringPiece(
@@ -212,17 +210,17 @@ base::StringPiece CBORValue::GetBytestringAsString() const {
       bytestring_value.size());
 }
 
-const CBORValue::ArrayValue& CBORValue::GetArray() const {
+const Value::ArrayValue& Value::GetArray() const {
   CHECK(is_array());
   return array_value_;
 }
 
-const CBORValue::MapValue& CBORValue::GetMap() const {
+const Value::MapValue& Value::GetMap() const {
   CHECK(is_map());
   return map_value_;
 }
 
-void CBORValue::InternalMoveConstructFrom(CBORValue&& that) {
+void Value::InternalMoveConstructFrom(Value&& that) {
   type_ = that.type_;
 
   switch (type_) {
@@ -254,7 +252,7 @@ void CBORValue::InternalMoveConstructFrom(CBORValue&& that) {
   NOTREACHED();
 }
 
-void CBORValue::InternalCleanup() {
+void Value::InternalCleanup() {
   switch (type_) {
     case Type::BYTE_STRING:
       bytestring_value_.~BinaryValue();
diff --git a/chromium/components/cbor/cbor_values.h b/chromium/components/cbor/values.h
index 39f2cca932b..ed9aae23fad 100644
--- a/chromium/components/cbor/cbor_values.h
+++ b/chromium/components/cbor/values.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef COMPONENTS_CBOR_CBOR_VALUES_H_
-#define COMPONENTS_CBOR_CBOR_VALUES_H_
+#ifndef COMPONENTS_CBOR_VALUES_H_
+#define COMPONENTS_CBOR_VALUES_H_
 
 #include <stdint.h>
 
@@ -23,14 +23,14 @@ namespace cbor {
 // This does not support:
 //  * Floating-point numbers.
 //  * Indefinite-length encodings.
-class CBOR_EXPORT CBORValue {
+class CBOR_EXPORT Value {
  public:
   struct Less {
     // Comparison predicate to order keys in a dictionary as required by the
     // canonical CBOR order defined in
     // https://tools.ietf.org/html/rfc7049#section-3.9
     // TODO(808022): Clarify where this stands.
-    bool operator()(const CBORValue& a, const CBORValue& b) const {
+    bool operator()(const Value& a, const Value& b) const {
       // The current implementation only supports integer, text string,
       // and byte string keys.
       DCHECK((a.is_integer() || a.is_string() || a.is_bytestring()) &&
@@ -81,8 +81,8 @@ class CBOR_EXPORT CBORValue {
   };
 
   using BinaryValue = std::vector<uint8_t>;
-  using ArrayValue = std::vector<CBORValue>;
-  using MapValue = base::flat_map<CBORValue, CBORValue, Less>;
+  using ArrayValue = std::vector<Value>;
+  using MapValue = base::flat_map<Value, Value, Less>;
 
   enum class Type {
     UNSIGNED = 0,
@@ -103,39 +103,38 @@ class CBOR_EXPORT CBORValue {
     UNDEFINED = 23,
   };
 
-  CBORValue(CBORValue&& that) noexcept;
-  CBORValue() noexcept;  // A NONE value.
+  Value(Value&& that) noexcept;
+  Value() noexcept;  // A NONE value.
 
-  explicit CBORValue(Type type);
+  explicit Value(Type type);
 
-  explicit CBORValue(SimpleValue in_simple);
-  explicit CBORValue(bool boolean_value);
+  explicit Value(SimpleValue in_simple);
+  explicit Value(bool boolean_value);
 
-  explicit CBORValue(int integer_value);
-  explicit CBORValue(int64_t integer_value);
-  explicit CBORValue(uint64_t integer_value) = delete;
+  explicit Value(int integer_value);
+  explicit Value(int64_t integer_value);
+  explicit Value(uint64_t integer_value) = delete;
 
-  explicit CBORValue(base::span<const uint8_t> in_bytes);
-  explicit CBORValue(BinaryValue&& in_bytes) noexcept;
+  explicit Value(base::span<const uint8_t> in_bytes);
+  explicit Value(BinaryValue&& in_bytes) noexcept;
 
-  explicit CBORValue(const char* in_string, Type type = Type::STRING);
-  explicit CBORValue(std::string&& in_string,
-                     Type type = Type::STRING) noexcept;
-  explicit CBORValue(base::StringPiece in_string, Type type = Type::STRING);
+  explicit Value(const char* in_string, Type type = Type::STRING);
+  explicit Value(std::string&& in_string, Type type = Type::STRING) noexcept;
+  explicit Value(base::StringPiece in_string, Type type = Type::STRING);
 
-  explicit CBORValue(const ArrayValue& in_array);
-  explicit CBORValue(ArrayValue&& in_array) noexcept;
+  explicit Value(const ArrayValue& in_array);
+  explicit Value(ArrayValue&& in_array) noexcept;
 
-  explicit CBORValue(const MapValue& in_map);
-  explicit CBORValue(MapValue&& in_map) noexcept;
+  explicit Value(const MapValue& in_map);
+  explicit Value(MapValue&& in_map) noexcept;
 
-  CBORValue& operator=(CBORValue&& that) noexcept;
+  Value& operator=(Value&& that) noexcept;
 
-  ~CBORValue();
+  ~Value();
 
-  // CBORValue's copy constructor and copy assignment operator are deleted.
+  // Value's copy constructor and copy assignment operator are deleted.
   // Use this to obtain a deep copy explicitly.
-  CBORValue Clone() const;
+  Value Clone() const;
 
   // Returns the type of the value stored by the current Value object.
   Type type() const { return type_; }
@@ -181,11 +180,11 @@ class CBOR_EXPORT CBORValue {
     MapValue map_value_;
   };
 
-  void InternalMoveConstructFrom(CBORValue&& that);
+  void InternalMoveConstructFrom(Value&& that);
   void InternalCleanup();
 
-  DISALLOW_COPY_AND_ASSIGN(CBORValue);
+  DISALLOW_COPY_AND_ASSIGN(Value);
 };
 }  // namespace cbor
 
-#endif  // COMPONENTS_CBOR_CBOR_VALUES_H_
+#endif  // COMPONENTS_CBOR_VALUES_H_
diff --git a/chromium/components/cbor/values_unittest.cc b/chromium/components/cbor/values_unittest.cc
new file mode 100644
index 00000000000..1276b998103
--- /dev/null
+++ b/chromium/components/cbor/values_unittest.cc
@@ -0,0 +1,369 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/cbor/values.h"
+
+#include <string>
+#include <utility>
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace cbor {
+
+TEST(CBORValuesTest, TestNothrow) {
+  static_assert(std::is_nothrow_move_constructible<Value>::value,
+                "IsNothrowMoveConstructible");
+  static_assert(std::is_nothrow_default_constructible<Value>::value,
+                "IsNothrowDefaultConstructible");
+  static_assert(std::is_nothrow_constructible<Value, std::string&&>::value,
+                "IsNothrowMoveConstructibleFromString");
+  static_assert(
+      std::is_nothrow_constructible<Value, Value::BinaryValue&&>::value,
+      "IsNothrowMoveConstructibleFromBytestring");
+  static_assert(
+      std::is_nothrow_constructible<Value, Value::ArrayValue&&>::value,
+      "IsNothrowMoveConstructibleFromArray");
+  static_assert(std::is_nothrow_move_assignable<Value>::value,
+                "IsNothrowMoveAssignable");
+}
+
+// Test constructors
+TEST(CBORValuesTest, ConstructUnsigned) {
+  Value value(37);
+  ASSERT_EQ(Value::Type::UNSIGNED, value.type());
+  EXPECT_EQ(37u, value.GetInteger());
+}
+
+TEST(CBORValuesTest, ConstructNegative) {
+  Value value(-1);
+  ASSERT_EQ(Value::Type::NEGATIVE, value.type());
+  EXPECT_EQ(-1, value.GetInteger());
+}
+
+TEST(CBORValuesTest, ConstructStringFromConstCharPtr) {
+  const char* str = "foobar";
+  Value value(str);
+  ASSERT_EQ(Value::Type::STRING, value.type());
+  EXPECT_EQ("foobar", value.GetString());
+}
+
+TEST(CBORValuesTest, ConstructStringFromStdStringConstRef) {
+  std::string str = "foobar";
+  Value value(str);
+  ASSERT_EQ(Value::Type::STRING, value.type());
+  EXPECT_EQ("foobar", value.GetString());
+}
+
+TEST(CBORValuesTest, ConstructStringFromStdStringRefRef) {
+  std::string str = "foobar";
+  Value value(std::move(str));
+  ASSERT_EQ(Value::Type::STRING, value.type());
+  EXPECT_EQ("foobar", value.GetString());
+}
+
+TEST(CBORValuesTest, ConstructBytestring) {
+  Value value(Value::BinaryValue({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}));
+  ASSERT_EQ(Value::Type::BYTE_STRING, value.type());
+  EXPECT_EQ(Value::BinaryValue({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}),
+            value.GetBytestring());
+}
+
+TEST(CBORValuesTest, ConstructBytestringFromString) {
+  Value value(Value("hello", Value::Type::BYTE_STRING));
+  ASSERT_EQ(Value::Type::BYTE_STRING, value.type());
+  EXPECT_EQ(Value::BinaryValue({'h', 'e', 'l', 'l', 'o'}),
+            value.GetBytestring());
+  EXPECT_EQ("hello", value.GetBytestringAsString());
+}
+
+TEST(CBORValuesTest, ConstructArray) {
+  Value::ArrayValue array;
+  array.emplace_back(Value("foo"));
+  {
+    Value value(array);
+    ASSERT_EQ(Value::Type::ARRAY, value.type());
+    ASSERT_EQ(1u, value.GetArray().size());
+    ASSERT_EQ(Value::Type::STRING, value.GetArray()[0].type());
+    EXPECT_EQ("foo", value.GetArray()[0].GetString());
+  }
+
+  array.back() = Value("bar");
+  {
+    Value value(std::move(array));
+    ASSERT_EQ(Value::Type::ARRAY, value.type());
+    ASSERT_EQ(1u, value.GetArray().size());
+    ASSERT_EQ(Value::Type::STRING, value.GetArray()[0].type());
+    EXPECT_EQ("bar", value.GetArray()[0].GetString());
+  }
+}
+
+TEST(CBORValuesTest, ConstructMap) {
+  Value::MapValue map;
+  const Value key_foo("foo");
+  map[Value("foo")] = Value("bar");
+  {
+    Value value(map);
+    ASSERT_EQ(Value::Type::MAP, value.type());
+    ASSERT_EQ(value.GetMap().count(key_foo), 1u);
+    ASSERT_EQ(Value::Type::STRING, value.GetMap().find(key_foo)->second.type());
+    EXPECT_EQ("bar", value.GetMap().find(key_foo)->second.GetString());
+  }
+
+  map[Value("foo")] = Value("baz");
+  {
+    Value value(std::move(map));
+    ASSERT_EQ(Value::Type::MAP, value.type());
+    ASSERT_EQ(value.GetMap().count(key_foo), 1u);
+    ASSERT_EQ(Value::Type::STRING, value.GetMap().find(key_foo)->second.type());
+    EXPECT_EQ("baz", value.GetMap().find(key_foo)->second.GetString());
+  }
+}
+
+TEST(CBORValuesTest, ConstructSimpleValue) {
+  Value false_value(Value::SimpleValue::FALSE_VALUE);
+  ASSERT_EQ(Value::Type::SIMPLE_VALUE, false_value.type());
+  EXPECT_EQ(Value::SimpleValue::FALSE_VALUE, false_value.GetSimpleValue());
+
+  Value true_value(Value::SimpleValue::TRUE_VALUE);
+  ASSERT_EQ(Value::Type::SIMPLE_VALUE, true_value.type());
+  EXPECT_EQ(Value::SimpleValue::TRUE_VALUE, true_value.GetSimpleValue());
+
+  Value null_value(Value::SimpleValue::NULL_VALUE);
+  ASSERT_EQ(Value::Type::SIMPLE_VALUE, null_value.type());
+  EXPECT_EQ(Value::SimpleValue::NULL_VALUE, null_value.GetSimpleValue());
+
+  Value undefined_value(Value::SimpleValue::UNDEFINED);
+  ASSERT_EQ(Value::Type::SIMPLE_VALUE, undefined_value.type());
+  EXPECT_EQ(Value::SimpleValue::UNDEFINED, undefined_value.GetSimpleValue());
+}
+
+TEST(CBORValuesTest, ConstructSimpleBooleanValue) {
+  Value true_value(true);
+  ASSERT_EQ(Value::Type::SIMPLE_VALUE, true_value.type());
+  EXPECT_TRUE(true_value.GetBool());
+
+  Value false_value(false);
+  ASSERT_EQ(Value::Type::SIMPLE_VALUE, false_value.type());
+  EXPECT_FALSE(false_value.GetBool());
+}
+
+// Test copy constructors
+TEST(CBORValuesTest, CopyUnsigned) {
+  Value value(74);
+  Value copied_value(value.Clone());
+  ASSERT_EQ(value.type(), copied_value.type());
+  EXPECT_EQ(value.GetInteger(), copied_value.GetInteger());
+
+  Value blank;
+
+  blank = value.Clone();
+  ASSERT_EQ(value.type(), blank.type());
+  EXPECT_EQ(value.GetInteger(), blank.GetInteger());
+}
+
+TEST(CBORValuesTest, CopyNegativeInt) {
+  Value value(-74);
+  Value copied_value(value.Clone());
+  ASSERT_EQ(value.type(), copied_value.type());
+  EXPECT_EQ(value.GetInteger(), copied_value.GetInteger());
+
+  Value blank;
+
+  blank = value.Clone();
+  ASSERT_EQ(value.type(), blank.type());
+  EXPECT_EQ(value.GetInteger(), blank.GetInteger());
+}
+
+TEST(CBORValuesTest, CopyString) {
+  Value value("foobar");
+  Value copied_value(value.Clone());
+  ASSERT_EQ(value.type(), copied_value.type());
+  EXPECT_EQ(value.GetString(), copied_value.GetString());
+
+  Value blank;
+
+  blank = value.Clone();
+  ASSERT_EQ(value.type(), blank.type());
+  EXPECT_EQ(value.GetString(), blank.GetString());
+}
+
+TEST(CBORValuesTest, CopyBytestring) {
+  Value value(Value::BinaryValue({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}));
+  Value copied_value(value.Clone());
+  ASSERT_EQ(value.type(), copied_value.type());
+  EXPECT_EQ(value.GetBytestring(), copied_value.GetBytestring());
+
+  Value blank;
+
+  blank = value.Clone();
+  ASSERT_EQ(value.type(), blank.type());
+  EXPECT_EQ(value.GetBytestring(), blank.GetBytestring());
+}
+
+TEST(CBORValuesTest, CopyArray) {
+  Value::ArrayValue array;
+  array.emplace_back(123);
+  Value value(std::move(array));
+
+  Value copied_value(value.Clone());
+  ASSERT_EQ(1u, copied_value.GetArray().size());
+  ASSERT_TRUE(copied_value.GetArray()[0].is_unsigned());
+  EXPECT_EQ(value.GetArray()[0].GetInteger(),
+            copied_value.GetArray()[0].GetInteger());
+
+  Value blank;
+  blank = value.Clone();
+  EXPECT_EQ(1u, blank.GetArray().size());
+}
+
+TEST(CBORValuesTest, CopyMap) {
+  Value::MapValue map;
+  Value key_a("a");
+  map[Value("a")] = Value(123);
+  Value value(std::move(map));
+
+  Value copied_value(value.Clone());
+  EXPECT_EQ(1u, copied_value.GetMap().size());
+  ASSERT_EQ(value.GetMap().count(key_a), 1u);
+  ASSERT_EQ(copied_value.GetMap().count(key_a), 1u);
+  ASSERT_TRUE(copied_value.GetMap().find(key_a)->second.is_unsigned());
+  EXPECT_EQ(value.GetMap().find(key_a)->second.GetInteger(),
+            copied_value.GetMap().find(key_a)->second.GetInteger());
+
+  Value blank;
+  blank = value.Clone();
+  EXPECT_EQ(1u, blank.GetMap().size());
+  ASSERT_EQ(blank.GetMap().count(key_a), 1u);
+  ASSERT_TRUE(blank.GetMap().find(key_a)->second.is_unsigned());
+  EXPECT_EQ(value.GetMap().find(key_a)->second.GetInteger(),
+            blank.GetMap().find(key_a)->second.GetInteger());
+}
+
+TEST(CBORValuesTest, CopySimpleValue) {
+  Value value(Value::SimpleValue::TRUE_VALUE);
+  Value copied_value(value.Clone());
+  EXPECT_EQ(value.type(), copied_value.type());
+  EXPECT_EQ(value.GetSimpleValue(), copied_value.GetSimpleValue());
+
+  Value blank;
+
+  blank = value.Clone();
+  EXPECT_EQ(value.type(), blank.type());
+  EXPECT_EQ(value.GetSimpleValue(), blank.GetSimpleValue());
+}
+
+// Test move constructors and move-assignment
+TEST(CBORValuesTest, MoveUnsigned) {
+  Value value(74);
+  Value moved_value(std::move(value));
+  EXPECT_EQ(Value::Type::UNSIGNED, moved_value.type());
+  EXPECT_EQ(74u, moved_value.GetInteger());
+
+  Value blank;
+
+  blank = Value(654);
+  EXPECT_EQ(Value::Type::UNSIGNED, blank.type());
+  EXPECT_EQ(654u, blank.GetInteger());
+}
+
+TEST(CBORValuesTest, MoveNegativeInteger) {
+  Value value(-74);
+  Value moved_value(std::move(value));
+  EXPECT_EQ(Value::Type::NEGATIVE, moved_value.type());
+  EXPECT_EQ(-74, moved_value.GetInteger());
+
+  Value blank;
+
+  blank = Value(-654);
+  EXPECT_EQ(Value::Type::NEGATIVE, blank.type());
+  EXPECT_EQ(-654, blank.GetInteger());
+}
+
+TEST(CBORValuesTest, MoveString) {
+  Value value("foobar");
+  Value moved_value(std::move(value));
+  EXPECT_EQ(Value::Type::STRING, moved_value.type());
+  EXPECT_EQ("foobar", moved_value.GetString());
+
+  Value blank;
+
+  blank = Value("foobar");
+  EXPECT_EQ(Value::Type::STRING, blank.type());
+  EXPECT_EQ("foobar", blank.GetString());
+}
+
+TEST(CBORValuesTest, MoveBytestring) {
+  const Value::BinaryValue bytes({0xF, 0x0, 0x0, 0xB, 0xA, 0x2});
+  Value value(bytes);
+  Value moved_value(std::move(value));
+  EXPECT_EQ(Value::Type::BYTE_STRING, moved_value.type());
+  EXPECT_EQ(bytes, moved_value.GetBytestring());
+
+  Value blank;
+
+  blank = Value(bytes);
+  EXPECT_EQ(Value::Type::BYTE_STRING, blank.type());
+  EXPECT_EQ(bytes, blank.GetBytestring());
+}
+
+TEST(CBORValuesTest, MoveConstructMap) {
+  Value::MapValue map;
+  const Value key_a("a");
+  map[Value("a")] = Value(123);
+
+  Value value(std::move(map));
+  Value moved_value(std::move(value));
+  ASSERT_EQ(Value::Type::MAP, moved_value.type());
+  ASSERT_EQ(moved_value.GetMap().count(key_a), 1u);
+  ASSERT_TRUE(moved_value.GetMap().find(key_a)->second.is_unsigned());
+  EXPECT_EQ(123u, moved_value.GetMap().find(key_a)->second.GetInteger());
+}
+
+TEST(CBORValuesTest, MoveAssignMap) {
+  Value::MapValue map;
+  const Value key_a("a");
+  map[Value("a")] = Value(123);
+
+  Value blank;
+  blank = Value(std::move(map));
+  ASSERT_TRUE(blank.is_map());
+  ASSERT_EQ(blank.GetMap().count(key_a), 1u);
+  ASSERT_TRUE(blank.GetMap().find(key_a)->second.is_unsigned());
+  EXPECT_EQ(123u, blank.GetMap().find(key_a)->second.GetInteger());
+}
+
+TEST(CBORValuesTest, MoveArray) {
+  Value::ArrayValue array;
+  array.emplace_back(123);
+  Value value(array);
+  Value moved_value(std::move(value));
+  EXPECT_EQ(Value::Type::ARRAY, moved_value.type());
+  EXPECT_EQ(123u, moved_value.GetArray().back().GetInteger());
+
+  Value blank;
+  blank = Value(std::move(array));
+  EXPECT_EQ(Value::Type::ARRAY, blank.type());
+  EXPECT_EQ(123u, blank.GetArray().back().GetInteger());
+}
+
+TEST(CBORValuesTest, MoveSimpleValue) {
+  Value value(Value::SimpleValue::UNDEFINED);
+  Value moved_value(std::move(value));
+  EXPECT_EQ(Value::Type::SIMPLE_VALUE, moved_value.type());
+  EXPECT_EQ(Value::SimpleValue::UNDEFINED, moved_value.GetSimpleValue());
+
+  Value blank;
+
+  blank = Value(Value::SimpleValue::UNDEFINED);
+  EXPECT_EQ(Value::Type::SIMPLE_VALUE, blank.type());
+  EXPECT_EQ(Value::SimpleValue::UNDEFINED, blank.GetSimpleValue());
+}
+
+TEST(CBORValuesTest, SelfSwap) {
+  Value test(1);
+  std::swap(test, test);
+  EXPECT_EQ(test.GetInteger(), 1u);
+}
+
+}  // namespace cbor
diff --git a/chromium/components/cbor/cbor_writer.cc b/chromium/components/cbor/writer.cc
index 5312ab9357f..a522eff4e2b 100644
--- a/chromium/components/cbor/cbor_writer.cc
+++ b/chromium/components/cbor/writer.cc
@@ -2,68 +2,67 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "components/cbor/cbor_writer.h"
+#include "components/cbor/writer.h"
 
 #include <string>
 
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_piece.h"
-#include "components/cbor/cbor_constants.h"
+#include "components/cbor/constants.h"
 
 namespace cbor {
 
-CBORWriter::~CBORWriter() {}
+Writer::~Writer() {}
 
 // static
-base::Optional<std::vector<uint8_t>> CBORWriter::Write(
-    const CBORValue& node,
-    size_t max_nesting_level) {
+base::Optional<std::vector<uint8_t>> Writer::Write(const Value& node,
+                                                   size_t max_nesting_level) {
   std::vector<uint8_t> cbor;
-  CBORWriter writer(&cbor);
+  Writer writer(&cbor);
   if (writer.EncodeCBOR(node, base::checked_cast<int>(max_nesting_level)))
     return cbor;
   return base::nullopt;
 }
 
-CBORWriter::CBORWriter(std::vector<uint8_t>* cbor) : encoded_cbor_(cbor) {}
+Writer::Writer(std::vector<uint8_t>* cbor) : encoded_cbor_(cbor) {}
 
-bool CBORWriter::EncodeCBOR(const CBORValue& node, int max_nesting_level) {
+bool Writer::EncodeCBOR(const Value& node, int max_nesting_level) {
   if (max_nesting_level < 0)
     return false;
 
   switch (node.type()) {
-    case CBORValue::Type::NONE: {
-      StartItem(CBORValue::Type::BYTE_STRING, 0);
+    case Value::Type::NONE: {
+      StartItem(Value::Type::BYTE_STRING, 0);
       return true;
     }
 
     // Represents unsigned integers.
-    case CBORValue::Type::UNSIGNED: {
+    case Value::Type::UNSIGNED: {
       int64_t value = node.GetUnsigned();
-      StartItem(CBORValue::Type::UNSIGNED, static_cast<uint64_t>(value));
+      StartItem(Value::Type::UNSIGNED, static_cast<uint64_t>(value));
       return true;
     }
 
     // Represents negative integers.
-    case CBORValue::Type::NEGATIVE: {
+    case Value::Type::NEGATIVE: {
       int64_t value = node.GetNegative();
-      StartItem(CBORValue::Type::NEGATIVE, static_cast<uint64_t>(-(value + 1)));
+      StartItem(Value::Type::NEGATIVE, static_cast<uint64_t>(-(value + 1)));
       return true;
     }
 
     // Represents a byte string.
-    case CBORValue::Type::BYTE_STRING: {
-      const CBORValue::BinaryValue& bytes = node.GetBytestring();
-      StartItem(CBORValue::Type::BYTE_STRING,
+    case Value::Type::BYTE_STRING: {
+      const Value::BinaryValue& bytes = node.GetBytestring();
+      StartItem(Value::Type::BYTE_STRING,
                 base::strict_cast<uint64_t>(bytes.size()));
       // Add the bytes.
       encoded_cbor_->insert(encoded_cbor_->end(), bytes.begin(), bytes.end());
       return true;
     }
 
-    case CBORValue::Type::STRING: {
+    case Value::Type::STRING: {
       base::StringPiece string = node.GetString();
-      StartItem(CBORValue::Type::STRING,
+      StartItem(Value::Type::STRING,
                 base::strict_cast<uint64_t>(string.size()));
 
       // Add the characters.
@@ -72,9 +71,9 @@ bool CBORWriter::EncodeCBOR(const CBORValue& node, int max_nesting_level) {
     }
 
     // Represents an array.
-    case CBORValue::Type::ARRAY: {
-      const CBORValue::ArrayValue& array = node.GetArray();
-      StartItem(CBORValue::Type::ARRAY, array.size());
+    case Value::Type::ARRAY: {
+      const Value::ArrayValue& array = node.GetArray();
+      StartItem(Value::Type::ARRAY, array.size());
       for (const auto& value : array) {
         if (!EncodeCBOR(value, max_nesting_level - 1))
           return false;
@@ -83,9 +82,9 @@ bool CBORWriter::EncodeCBOR(const CBORValue& node, int max_nesting_level) {
     }
 
     // Represents a map.
-    case CBORValue::Type::MAP: {
-      const CBORValue::MapValue& map = node.GetMap();
-      StartItem(CBORValue::Type::MAP, map.size());
+    case Value::Type::MAP: {
+      const Value::MapValue& map = node.GetMap();
+      StartItem(Value::Type::MAP, map.size());
 
       for (const auto& value : map) {
         if (!EncodeCBOR(value.first, max_nesting_level - 1))
@@ -96,14 +95,14 @@ bool CBORWriter::EncodeCBOR(const CBORValue& node, int max_nesting_level) {
       return true;
     }
 
-    case CBORValue::Type::TAG:
+    case Value::Type::TAG:
       NOTREACHED() << constants::kUnsupportedMajorType;
       return false;
 
     // Represents a simple value.
-    case CBORValue::Type::SIMPLE_VALUE: {
-      const CBORValue::SimpleValue simple_value = node.GetSimpleValue();
-      StartItem(CBORValue::Type::SIMPLE_VALUE,
+    case Value::Type::SIMPLE_VALUE: {
+      const Value::SimpleValue simple_value = node.GetSimpleValue();
+      StartItem(Value::Type::SIMPLE_VALUE,
                 base::checked_cast<uint64_t>(simple_value));
       return true;
     }
@@ -115,13 +114,13 @@ bool CBORWriter::EncodeCBOR(const CBORValue& node, int max_nesting_level) {
   return false;
 }
 
-void CBORWriter::StartItem(CBORValue::Type type, uint64_t size) {
+void Writer::StartItem(Value::Type type, uint64_t size) {
   encoded_cbor_->push_back(base::checked_cast<uint8_t>(
       static_cast<unsigned>(type) << constants::kMajorTypeBitShift));
   SetUint(size);
 }
 
-void CBORWriter::SetAdditionalInformation(uint8_t additional_information) {
+void Writer::SetAdditionalInformation(uint8_t additional_information) {
   DCHECK(!encoded_cbor_->empty());
   DCHECK_EQ(additional_information & constants::kAdditionalInformationMask,
             additional_information);
@@ -129,7 +128,7 @@ void CBORWriter::SetAdditionalInformation(uint8_t additional_information) {
       (additional_information & constants::kAdditionalInformationMask);
 }
 
-void CBORWriter::SetUint(uint64_t value) {
+void Writer::SetUint(uint64_t value) {
   size_t count = GetNumUintBytes(value);
   int shift = -1;
   // Values under 24 are encoded directly in the initial byte.
@@ -164,7 +163,7 @@ void CBORWriter::SetUint(uint64_t value) {
   }
 }
 
-size_t CBORWriter::GetNumUintBytes(uint64_t value) {
+size_t Writer::GetNumUintBytes(uint64_t value) {
   if (value < 24) {
     return 0;
   } else if (value <= 0xFF) {
diff --git a/chromium/components/cbor/cbor_writer.h b/chromium/components/cbor/writer.h
index 89e24da742e..39cd430a2b4 100644
--- a/chromium/components/cbor/cbor_writer.h
+++ b/chromium/components/cbor/writer.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef COMPONENTS_CBOR_CBOR_WRITER_H_
-#define COMPONENTS_CBOR_CBOR_WRITER_H_
+#ifndef COMPONENTS_CBOR_WRITER_H_
+#define COMPONENTS_CBOR_WRITER_H_
 
 #include <stddef.h>
 #include <stdint.h>
@@ -11,7 +11,7 @@
 
 #include "base/optional.h"
 #include "components/cbor/cbor_export.h"
-#include "components/cbor/cbor_values.h"
+#include "components/cbor/values.h"
 
 // A basic Concise Binary Object Representation (CBOR) encoder as defined by
 // https://tools.ietf.org/html/rfc7049. This is a generic encoder that supplies
@@ -47,37 +47,37 @@
 //  3) Indefinite length items must be converted to definite length items.
 //  4) All maps must not have duplicate keys.
 //
-// Current implementation of CBORWriter encoder meets all the requirements of
+// Current implementation of Writer encoder meets all the requirements of
 // canonical CBOR.
 
 namespace cbor {
 
-class CBOR_EXPORT CBORWriter {
+class CBOR_EXPORT Writer {
  public:
   // Default that should be sufficiently large for most use cases.
   static constexpr size_t kDefaultMaxNestingDepth = 16;
 
-  ~CBORWriter();
+  ~Writer();
 
   // Returns the CBOR byte string representation of |node|, unless its nesting
   // depth is greater than |max_nesting_depth|, in which case an empty optional
   // value is returned. The nesting depth of |node| is defined as the number of
-  // arrays/maps that has to be traversed to reach the most nested CBORValue
+  // arrays/maps that has to be traversed to reach the most nested Value
   // contained in |node|. Primitive values and empty containers have nesting
   // depths of 0.
   static base::Optional<std::vector<uint8_t>> Write(
-      const CBORValue& node,
+      const Value& node,
       size_t max_nesting_level = kDefaultMaxNestingDepth);
 
  private:
-  explicit CBORWriter(std::vector<uint8_t>* cbor);
+  explicit Writer(std::vector<uint8_t>* cbor);
 
   // Called recursively to build the CBOR bytestring. When completed,
   // |encoded_cbor_| will contain the CBOR.
-  bool EncodeCBOR(const CBORValue& node, int max_nesting_level);
+  bool EncodeCBOR(const Value& node, int max_nesting_level);
 
   // Encodes the type and size of the data being added.
-  void StartItem(CBORValue::Type type, uint64_t size);
+  void StartItem(Value::Type type, uint64_t size);
 
   // Encodes the additional information for the data.
   void SetAdditionalInformation(uint8_t additional_information);
@@ -92,9 +92,9 @@ class CBOR_EXPORT CBORWriter {
   // Holds the encoded CBOR data.
   std::vector<uint8_t>* encoded_cbor_;
 
-  DISALLOW_COPY_AND_ASSIGN(CBORWriter);
+  DISALLOW_COPY_AND_ASSIGN(Writer);
 };
 
 }  // namespace cbor
 
-#endif  // COMPONENTS_CBOR_CBOR_WRITER_H_
+#endif  // COMPONENTS_CBOR_WRITER_H_
diff --git a/chromium/components/cbor/cbor_writer_unittest.cc b/chromium/components/cbor/writer_unittest.cc
index 955a19b8104..3fb96884373 100644
--- a/chromium/components/cbor/cbor_writer_unittest.cc
+++ b/chromium/components/cbor/writer_unittest.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "components/cbor/cbor_writer.h"
+#include "components/cbor/writer.h"
 
 #include <limits>
 #include <string>
@@ -39,7 +39,7 @@ TEST(CBORWriterTest, TestWriteUint) {
        base::StringPiece("\x1b\x7f\xff\xff\xff\xff\xff\xff\xff")}};
 
   for (const UintTestCase& test_case : kUintTestCases) {
-    auto cbor = CBORWriter::Write(CBORValue(test_case.value));
+    auto cbor = Writer::Write(Value(test_case.value));
     ASSERT_TRUE(cbor.has_value());
     EXPECT_THAT(cbor.value(), testing::ElementsAreArray(test_case.cbor));
   }
@@ -68,7 +68,7 @@ TEST(CBORWriterTest, TestWriteNegativeInteger) {
     SCOPED_TRACE(testing::Message() << "testing  negative int at index: "
                                     << test_case.negative_int);
 
-    auto cbor = CBORWriter::Write(CBORValue(test_case.negative_int));
+    auto cbor = Writer::Write(Value(test_case.negative_int));
     ASSERT_TRUE(cbor.has_value());
     EXPECT_THAT(cbor.value(), testing::ElementsAreArray(test_case.cbor));
   }
@@ -86,7 +86,7 @@ TEST(CBORWriterTest, TestWriteBytes) {
   };
 
   for (const BytesTestCase& test_case : kBytesTestCases) {
-    auto cbor = CBORWriter::Write(CBORValue(test_case.bytes));
+    auto cbor = Writer::Write(Value(test_case.bytes));
     ASSERT_TRUE(cbor.has_value());
     EXPECT_THAT(cbor.value(), testing::ElementsAreArray(test_case.cbor));
   }
@@ -111,7 +111,7 @@ TEST(CBORWriterTest, TestWriteString) {
     SCOPED_TRACE(testing::Message()
                  << "testing encoding string : " << test_case.string);
 
-    auto cbor = CBORWriter::Write(CBORValue(test_case.string));
+    auto cbor = Writer::Write(Value(test_case.string));
     ASSERT_TRUE(cbor.has_value());
     EXPECT_THAT(cbor.value(), testing::ElementsAreArray(test_case.cbor));
   }
@@ -126,11 +126,11 @@ TEST(CBORWriterTest, TestWriteArray) {
         0x18, 0x18, 0x19,
       // clang-format on
   };
-  std::vector<CBORValue> array;
+  std::vector<Value> array;
   for (int64_t i = 1; i <= 25; i++) {
-    array.push_back(CBORValue(i));
+    array.push_back(Value(i));
   }
-  auto cbor = CBORWriter::Write(CBORValue(array));
+  auto cbor = Writer::Write(Value(array));
   ASSERT_TRUE(cbor.has_value());
   EXPECT_THAT(cbor.value(),
               testing::ElementsAreArray(kArrayTestCaseCbor,
@@ -221,42 +221,41 @@ TEST(CBORWriterTest, TestWriteMap) {
         0x62, 0x41, 0x41,  // value "AA"
       // clang-format on
   };
-  CBORValue::MapValue map;
+  Value::MapValue map;
   // Shorter strings sort first in CTAP, thus the “aa” value should be
   // serialised last in the map.
-  map[CBORValue("aa")] = CBORValue("AA");
-  map[CBORValue("e")] = CBORValue("E");
+  map[Value("aa")] = Value("AA");
+  map[Value("e")] = Value("E");
   // The empty string is shorter than all others, so should appear first among
   // the strings.
-  map[CBORValue("")] = CBORValue(".");
+  map[Value("")] = Value(".");
   // Map keys are sorted by major type, by byte length, and then by
   // byte-wise lexical order. So all integer type keys should appear before
   // key "" and all positive integer keys should appear before negative integer
   // keys.
-  map[CBORValue(-1)] = CBORValue("k");
-  map[CBORValue(-24)] = CBORValue("l");
-  map[CBORValue(-25)] = CBORValue("m");
-  map[CBORValue(-256)] = CBORValue("n");
-  map[CBORValue(-257)] = CBORValue("o");
-  map[CBORValue(-65537)] = CBORValue("p");
-  map[CBORValue(int64_t(-4294967296))] = CBORValue("q");
-  map[CBORValue(int64_t(-4294967297))] = CBORValue("r");
-  map[CBORValue(std::numeric_limits<int64_t>::min())] = CBORValue("s");
-  map[CBORValue(CBORValue::BinaryValue{'a'})] = CBORValue(2);
-  map[CBORValue(CBORValue::BinaryValue{'b', 'a', 'r'})] = CBORValue(3);
-  map[CBORValue(CBORValue::BinaryValue{'f', 'o', 'o'})] = CBORValue(4);
-  map[CBORValue(0)] = CBORValue("a");
-  map[CBORValue(23)] = CBORValue("b");
-  map[CBORValue(24)] = CBORValue("c");
-  map[CBORValue(std::numeric_limits<uint8_t>::max())] = CBORValue("d");
-  map[CBORValue(256)] = CBORValue("e");
-  map[CBORValue(std::numeric_limits<uint16_t>::max())] = CBORValue("f");
-  map[CBORValue(65536)] = CBORValue("g");
-  map[CBORValue(int64_t(std::numeric_limits<uint32_t>::max()))] =
-      CBORValue("h");
-  map[CBORValue(int64_t(4294967296))] = CBORValue("i");
-  map[CBORValue(std::numeric_limits<int64_t>::max())] = CBORValue("j");
-  auto cbor = CBORWriter::Write(CBORValue(map));
+  map[Value(-1)] = Value("k");
+  map[Value(-24)] = Value("l");
+  map[Value(-25)] = Value("m");
+  map[Value(-256)] = Value("n");
+  map[Value(-257)] = Value("o");
+  map[Value(-65537)] = Value("p");
+  map[Value(int64_t(-4294967296))] = Value("q");
+  map[Value(int64_t(-4294967297))] = Value("r");
+  map[Value(std::numeric_limits<int64_t>::min())] = Value("s");
+  map[Value(Value::BinaryValue{'a'})] = Value(2);
+  map[Value(Value::BinaryValue{'b', 'a', 'r'})] = Value(3);
+  map[Value(Value::BinaryValue{'f', 'o', 'o'})] = Value(4);
+  map[Value(0)] = Value("a");
+  map[Value(23)] = Value("b");
+  map[Value(24)] = Value("c");
+  map[Value(std::numeric_limits<uint8_t>::max())] = Value("d");
+  map[Value(256)] = Value("e");
+  map[Value(std::numeric_limits<uint16_t>::max())] = Value("f");
+  map[Value(65536)] = Value("g");
+  map[Value(int64_t(std::numeric_limits<uint32_t>::max()))] = Value("h");
+  map[Value(int64_t(4294967296))] = Value("i");
+  map[Value(std::numeric_limits<int64_t>::max())] = Value("j");
+  auto cbor = Writer::Write(Value(map));
   ASSERT_TRUE(cbor.has_value());
   EXPECT_THAT(cbor.value(), testing::ElementsAreArray(
                                 kMapTestCaseCbor, arraysize(kMapTestCaseCbor)));
@@ -275,13 +274,13 @@ TEST(CBORWriterTest, TestWriteMapWithArray) {
           0x03,
       // clang-format on
   };
-  CBORValue::MapValue map;
-  map[CBORValue("a")] = CBORValue(1);
-  CBORValue::ArrayValue array;
-  array.push_back(CBORValue(2));
-  array.push_back(CBORValue(3));
-  map[CBORValue("b")] = CBORValue(array);
-  auto cbor = CBORWriter::Write(CBORValue(map));
+  Value::MapValue map;
+  map[Value("a")] = Value(1);
+  Value::ArrayValue array;
+  array.push_back(Value(2));
+  array.push_back(Value(3));
+  map[Value("b")] = Value(array);
+  auto cbor = Writer::Write(Value(map));
   ASSERT_TRUE(cbor.has_value());
   EXPECT_THAT(cbor.value(),
               testing::ElementsAreArray(kMapArrayTestCaseCbor,
@@ -304,13 +303,13 @@ TEST(CBORWriterTest, TestWriteNestedMap) {
           0x03,
       // clang-format on
   };
-  CBORValue::MapValue map;
-  map[CBORValue("a")] = CBORValue(1);
-  CBORValue::MapValue nested_map;
-  nested_map[CBORValue("c")] = CBORValue(2);
-  nested_map[CBORValue("d")] = CBORValue(3);
-  map[CBORValue("b")] = CBORValue(nested_map);
-  auto cbor = CBORWriter::Write(CBORValue(map));
+  Value::MapValue map;
+  map[Value("a")] = Value(1);
+  Value::MapValue nested_map;
+  nested_map[Value("c")] = Value(2);
+  nested_map[Value("d")] = Value(3);
+  map[Value("b")] = Value(nested_map);
+  auto cbor = Writer::Write(Value(map));
   ASSERT_TRUE(cbor.has_value());
   EXPECT_THAT(cbor.value(),
               testing::ElementsAreArray(kNestedMapTestCase,
@@ -350,14 +349,14 @@ TEST(CBORWriterTest, TestSignedExchangeExample) {
       */
       // clang-format on
   };
-  CBORValue::MapValue map;
-  map[CBORValue(10)] = CBORValue(1);
-  map[CBORValue(100)] = CBORValue(2);
-  map[CBORValue(-1)] = CBORValue(3);
-  map[CBORValue("z")] = CBORValue(4);
-  map[CBORValue("aa")] = CBORValue(5);
-
-  auto cbor = CBORWriter::Write(CBORValue(map));
+  Value::MapValue map;
+  map[Value(10)] = Value(1);
+  map[Value(100)] = Value(2);
+  map[Value(-1)] = Value(3);
+  map[Value("z")] = Value(4);
+  map[Value("aa")] = Value(5);
+
+  auto cbor = Writer::Write(Value(map));
   ASSERT_TRUE(cbor.has_value());
   EXPECT_THAT(cbor.value(),
               testing::ElementsAreArray(kSignedExchangeExample,
@@ -366,16 +365,16 @@ TEST(CBORWriterTest, TestSignedExchangeExample) {
 
 TEST(CBORWriterTest, TestWriteSimpleValue) {
   static const struct {
-    CBORValue::SimpleValue simple_value;
+    Value::SimpleValue simple_value;
     const base::StringPiece cbor;
   } kSimpleTestCase[] = {
-      {CBORValue::SimpleValue::FALSE_VALUE, base::StringPiece("\xf4")},
-      {CBORValue::SimpleValue::TRUE_VALUE, base::StringPiece("\xf5")},
-      {CBORValue::SimpleValue::NULL_VALUE, base::StringPiece("\xf6")},
-      {CBORValue::SimpleValue::UNDEFINED, base::StringPiece("\xf7")}};
+      {Value::SimpleValue::FALSE_VALUE, base::StringPiece("\xf4")},
+      {Value::SimpleValue::TRUE_VALUE, base::StringPiece("\xf5")},
+      {Value::SimpleValue::NULL_VALUE, base::StringPiece("\xf6")},
+      {Value::SimpleValue::UNDEFINED, base::StringPiece("\xf7")}};
 
   for (const auto& test_case : kSimpleTestCase) {
-    auto cbor = CBORWriter::Write(CBORValue(test_case.simple_value));
+    auto cbor = Writer::Write(Value(test_case.simple_value));
     ASSERT_TRUE(cbor.has_value());
     EXPECT_THAT(cbor.value(), testing::ElementsAreArray(test_case.cbor));
   }
@@ -385,33 +384,33 @@ TEST(CBORWriterTest, TestWriteSimpleValue) {
 // depth is expected to be 0 since the CBOR decoder does not need to parse
 // any nested CBOR value elements.
 TEST(CBORWriterTest, TestWriteSingleLayer) {
-  const CBORValue simple_uint = CBORValue(1);
-  const CBORValue simple_string = CBORValue("a");
+  const Value simple_uint = Value(1);
+  const Value simple_string = Value("a");
   const std::vector<uint8_t> byte_data = {0x01, 0x02, 0x03, 0x04};
-  const CBORValue simple_bytestring = CBORValue(byte_data);
-  CBORValue::ArrayValue empty_cbor_array;
-  CBORValue::MapValue empty_cbor_map;
-  const CBORValue empty_array_value = CBORValue(empty_cbor_array);
-  const CBORValue empty_map_value = CBORValue(empty_cbor_map);
-  CBORValue::ArrayValue simple_array;
-  simple_array.push_back(CBORValue(2));
-  CBORValue::MapValue simple_map;
-  simple_map[CBORValue("b")] = CBORValue(3);
-  const CBORValue single_layer_cbor_map = CBORValue(simple_map);
-  const CBORValue single_layer_cbor_array = CBORValue(simple_array);
-
-  EXPECT_TRUE(CBORWriter::Write(simple_uint, 0).has_value());
-  EXPECT_TRUE(CBORWriter::Write(simple_string, 0).has_value());
-  EXPECT_TRUE(CBORWriter::Write(simple_bytestring, 0).has_value());
-
-  EXPECT_TRUE(CBORWriter::Write(empty_array_value, 0).has_value());
-  EXPECT_TRUE(CBORWriter::Write(empty_map_value, 0).has_value());
-
-  EXPECT_FALSE(CBORWriter::Write(single_layer_cbor_array, 0).has_value());
-  EXPECT_TRUE(CBORWriter::Write(single_layer_cbor_array, 1).has_value());
-
-  EXPECT_FALSE(CBORWriter::Write(single_layer_cbor_map, 0).has_value());
-  EXPECT_TRUE(CBORWriter::Write(single_layer_cbor_map, 1).has_value());
+  const Value simple_bytestring = Value(byte_data);
+  Value::ArrayValue empty_cbor_array;
+  Value::MapValue empty_cbor_map;
+  const Value empty_array_value = Value(empty_cbor_array);
+  const Value empty_map_value = Value(empty_cbor_map);
+  Value::ArrayValue simple_array;
+  simple_array.push_back(Value(2));
+  Value::MapValue simple_map;
+  simple_map[Value("b")] = Value(3);
+  const Value single_layer_cbor_map = Value(simple_map);
+  const Value single_layer_cbor_array = Value(simple_array);
+
+  EXPECT_TRUE(Writer::Write(simple_uint, 0).has_value());
+  EXPECT_TRUE(Writer::Write(simple_string, 0).has_value());
+  EXPECT_TRUE(Writer::Write(simple_bytestring, 0).has_value());
+
+  EXPECT_TRUE(Writer::Write(empty_array_value, 0).has_value());
+  EXPECT_TRUE(Writer::Write(empty_map_value, 0).has_value());
+
+  EXPECT_FALSE(Writer::Write(single_layer_cbor_array, 0).has_value());
+  EXPECT_TRUE(Writer::Write(single_layer_cbor_array, 1).has_value());
+
+  EXPECT_FALSE(Writer::Write(single_layer_cbor_map, 0).has_value());
+  EXPECT_TRUE(Writer::Write(single_layer_cbor_map, 1).has_value());
 }
 
 // Major type 5 nested CBOR map value with following structure.
@@ -419,14 +418,14 @@ TEST(CBORWriterTest, TestWriteSingleLayer) {
 //      "b": {"c": 2,
 //            "d": 3}}
 TEST(CBORWriterTest, NestedMaps) {
-  CBORValue::MapValue cbor_map;
-  cbor_map[CBORValue("a")] = CBORValue(1);
-  CBORValue::MapValue nested_map;
-  nested_map[CBORValue("c")] = CBORValue(2);
-  nested_map[CBORValue("d")] = CBORValue(3);
-  cbor_map[CBORValue("b")] = CBORValue(nested_map);
-  EXPECT_TRUE(CBORWriter::Write(CBORValue(cbor_map), 2).has_value());
-  EXPECT_FALSE(CBORWriter::Write(CBORValue(cbor_map), 1).has_value());
+  Value::MapValue cbor_map;
+  cbor_map[Value("a")] = Value(1);
+  Value::MapValue nested_map;
+  nested_map[Value("c")] = Value(2);
+  nested_map[Value("d")] = Value(3);
+  cbor_map[Value("b")] = Value(nested_map);
+  EXPECT_TRUE(Writer::Write(Value(cbor_map), 2).has_value());
+  EXPECT_FALSE(Writer::Write(Value(cbor_map), 1).has_value());
 }
 
 // Testing Write() function for following CBOR structure with depth of 3.
@@ -437,21 +436,21 @@ TEST(CBORWriterTest, NestedMaps) {
 //       "b": {"c": 2,
 //             "d": 3}}]
 TEST(CBORWriterTest, UnbalancedNestedContainers) {
-  CBORValue::ArrayValue cbor_array;
-  CBORValue::MapValue cbor_map;
-  CBORValue::MapValue nested_map;
-
-  cbor_map[CBORValue("a")] = CBORValue(1);
-  nested_map[CBORValue("c")] = CBORValue(2);
-  nested_map[CBORValue("d")] = CBORValue(3);
-  cbor_map[CBORValue("b")] = CBORValue(nested_map);
-  cbor_array.push_back(CBORValue(1));
-  cbor_array.push_back(CBORValue(2));
-  cbor_array.push_back(CBORValue(3));
-  cbor_array.push_back(CBORValue(cbor_map));
-
-  EXPECT_TRUE(CBORWriter::Write(CBORValue(cbor_array), 3).has_value());
-  EXPECT_FALSE(CBORWriter::Write(CBORValue(cbor_array), 2).has_value());
+  Value::ArrayValue cbor_array;
+  Value::MapValue cbor_map;
+  Value::MapValue nested_map;
+
+  cbor_map[Value("a")] = Value(1);
+  nested_map[Value("c")] = Value(2);
+  nested_map[Value("d")] = Value(3);
+  cbor_map[Value("b")] = Value(nested_map);
+  cbor_array.push_back(Value(1));
+  cbor_array.push_back(Value(2));
+  cbor_array.push_back(Value(3));
+  cbor_array.push_back(Value(cbor_map));
+
+  EXPECT_TRUE(Writer::Write(Value(cbor_array), 3).has_value());
+  EXPECT_FALSE(Writer::Write(Value(cbor_array), 2).has_value());
 }
 
 // Testing Write() function for following CBOR structure.
@@ -464,27 +463,27 @@ TEST(CBORWriterTest, UnbalancedNestedContainers) {
 // Since above CBOR contains 5 nesting levels. Thus, Write() is expected to
 // return empty optional object when maximum nesting layer size is set to 4.
 TEST(CBORWriterTest, OverlyNestedCBOR) {
-  CBORValue::MapValue map;
-  CBORValue::MapValue nested_map;
-  CBORValue::MapValue inner_nested_map;
-  CBORValue::ArrayValue inner_array;
-  CBORValue::ArrayValue array;
-
-  map[CBORValue("a")] = CBORValue(1);
-  nested_map[CBORValue("c")] = CBORValue(2);
-  nested_map[CBORValue("d")] = CBORValue(3);
-  inner_nested_map[CBORValue("e")] = CBORValue(4);
-  inner_nested_map[CBORValue("f")] = CBORValue(5);
-  inner_array.push_back(CBORValue(6));
-  array.push_back(CBORValue(6));
-  array.push_back(CBORValue(7));
-  array.push_back(CBORValue(inner_array));
-  inner_nested_map[CBORValue("g")] = CBORValue(array);
-  nested_map[CBORValue("h")] = CBORValue(inner_nested_map);
-  map[CBORValue("b")] = CBORValue(nested_map);
-
-  EXPECT_TRUE(CBORWriter::Write(CBORValue(map), 5).has_value());
-  EXPECT_FALSE(CBORWriter::Write(CBORValue(map), 4).has_value());
+  Value::MapValue map;
+  Value::MapValue nested_map;
+  Value::MapValue inner_nested_map;
+  Value::ArrayValue inner_array;
+  Value::ArrayValue array;
+
+  map[Value("a")] = Value(1);
+  nested_map[Value("c")] = Value(2);
+  nested_map[Value("d")] = Value(3);
+  inner_nested_map[Value("e")] = Value(4);
+  inner_nested_map[Value("f")] = Value(5);
+  inner_array.push_back(Value(6));
+  array.push_back(Value(6));
+  array.push_back(Value(7));
+  array.push_back(Value(inner_array));
+  inner_nested_map[Value("g")] = Value(array);
+  nested_map[Value("h")] = Value(inner_nested_map);
+  map[Value("b")] = Value(nested_map);
+
+  EXPECT_TRUE(Writer::Write(Value(map), 5).has_value());
+  EXPECT_FALSE(Writer::Write(Value(map), 4).has_value());
 }
 
 }  // namespace cbor