Use |base::Value| in CloudDeviceDescription.

Bug: 848942
Change-Id: I5e98582e5d1a949c8db25846068655ed2c551068
Reviewed-on: https://chromium-review.googlesource.com/c/1454897
Commit-Queue: Nikita Podguzov <nikitapodguzov@google.com>
Reviewed-by: Lei Zhang <thestig@chromium.org>
Reviewed-by: Vladislav Kuzkokov <vkuzkokov@chromium.org>
Cr-Commit-Position: refs/heads/master@{#629937}

components/cloud_devices/common/cloud_device_description.cc

@@ -15,8 +15,8 @@
 namespace cloud_devices {
 
 CloudDeviceDescription::CloudDeviceDescription()
-    : root_(std::make_unique<base::DictionaryValue>()) {
-  root_->SetString(json::kVersion, json::kVersion10);
+    : root_(base::Value(base::Value::Type::DICTIONARY)) {
+  root_.SetKey(json::kVersion, base::Value(json::kVersion10));
 }
 
 CloudDeviceDescription::~CloudDeviceDescription() = default;
@@ -30,13 +30,10 @@ bool CloudDeviceDescription::InitFromString(const std::string& json) {
 }
 
 bool CloudDeviceDescription::InitFromValue(base::Value ticket) {
-  auto parsed = base::DictionaryValue::From(
-      base::Value::ToUniquePtrValue(std::move(ticket)));
-  if (!parsed)
+  if (!ticket.is_dict())
     return false;
-
-  root_ = std::move(parsed);
-  return IsValidTicket(*root_);
+  root_ = std::move(ticket);
+  return IsValidTicket(root_);
 }
 
 // static
@@ -51,36 +48,24 @@ bool CloudDeviceDescription::IsValidTicket(const base::Value& ticket) {
 std::string CloudDeviceDescription::ToString() const {
   std::string json;
   base::JSONWriter::WriteWithOptions(
-      *root_, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
+      root_, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
   return json;
 }
 
 base::Value CloudDeviceDescription::ToValue() && {
-  return base::Value::FromUniquePtrValue(std::move(root_));
-}
-
-const base::DictionaryValue* CloudDeviceDescription::GetItem(
-    const std::string& path) const {
-  const base::DictionaryValue* value = nullptr;
-  root_->GetDictionary(path, &value);
-  return value;
-}
-
-base::DictionaryValue* CloudDeviceDescription::CreateItem(
-    const std::string& path) {
-  return root_->SetDictionary(path, std::make_unique<base::DictionaryValue>());
+  return std::move(root_);
 }
 
-const base::ListValue* CloudDeviceDescription::GetListItem(
-    const std::string& path) const {
-  const base::ListValue* value = nullptr;
-  root_->GetList(path, &value);
-  return value;
+const base::Value* CloudDeviceDescription::GetItem(
+    const std::vector<base::StringPiece>& path,
+    base::Value::Type type) const {
+  return root_.FindPathOfType(path, type);
 }
 
-base::ListValue* CloudDeviceDescription::CreateListItem(
-    const std::string& path) {
-  return root_->SetList(path, std::make_unique<base::ListValue>());
+base::Value* CloudDeviceDescription::CreateItem(
+    const std::vector<base::StringPiece>& path,
+    base::Value::Type type) {
+  return root_.SetPath(path, base::Value(type));
 }
 
 }  // namespace cloud_devices

components/cloud_devices/common/cloud_device_description.h

@@ -7,8 +7,10 @@
 
 #include <memory>
 #include <string>
+#include <vector>
 
 #include "base/macros.h"
+#include "base/strings/string_piece_forward.h"
 #include "base/values.h"
 
 namespace cloud_devices {
@@ -30,24 +32,18 @@ class CloudDeviceDescription {
 
   base::Value ToValue() &&;
 
-  // Returns dictionary with capability/option.
-  // Returns NULL if missing.
-  const base::DictionaryValue* GetItem(const std::string& path) const;
+  // Returns item of given type with capability/option.
+  // Returns nullptr if missing.
+  const base::Value* GetItem(const std::vector<base::StringPiece>& path,
+                             base::Value::Type type) const;
 
-  // Create dictionary for capability/option.
-  // Never returns NULL.
-  base::DictionaryValue* CreateItem(const std::string& path);
-
-  // Returns list with capability/option.
-  // Returns NULL if missing.
-  const base::ListValue* GetListItem(const std::string& path) const;
-
-  // Create list for capability/option.
-  // Never returns NULL.
-  base::ListValue* CreateListItem(const std::string& path);
+  // Creates item with given type for capability/option.
+  // Returns nullptr if an intermediate Value in the path is not a dictionary.
+  base::Value* CreateItem(const std::vector<base::StringPiece>& path,
+                          base::Value::Type type);
 
  private:
-  std::unique_ptr<base::DictionaryValue> root_;
+  base::Value root_;
 
   DISALLOW_COPY_AND_ASSIGN(CloudDeviceDescription);
 };

components/cloud_devices/common/description_items.h

@@ -19,10 +19,6 @@
 #include "base/stl_util.h"
 #include "components/cloud_devices/common/cloud_device_description.h"
 
-namespace base {
-class DictionaryValue;
-}
-
 namespace cloud_devices {
 
 // All traits below specify how to serialize and validate capabilities and
@@ -35,10 +31,10 @@ namespace cloud_devices {
 //   static std::string GetItemPath();
 //
 //   // Loads ticket item. Returns false if failed.
-//   static bool Load(const base::DictionaryValue& dict, ContentType* option);
+//   static bool Load(const base::Value& dict, ContentType* option);
 //
 //   // Saves ticket item.
-//   static void Save(ContentType option, base::DictionaryValue* dict);
+//   static void Save(ContentType option, base::Value* dict);
 
 // Represents a CDD capability that is stored as a JSON list
 // Ex: "<CAPABILITY_NAME>": [ {<VALUE>}, {<VALUE>}, {<VALUE>} ]

components/cloud_devices/common/description_items_inl.h

@@ -45,16 +45,14 @@ template <class Option, class Traits>
 bool ListCapability<Option, Traits>::LoadFrom(
     const CloudDeviceDescription& description) {
   Reset();
-  const base::ListValue* options =
-      description.GetListItem(Traits::GetCapabilityPath());
-  if (!options)
+  const base::Value* options_value =
+      description.GetItem(Traits::GetCapabilityPath(), base::Value::Type::LIST);
+  if (!options_value)
     return false;
-  for (size_t i = 0; i < options->GetSize(); ++i) {
-    const base::DictionaryValue* option_value = NULL;
-    if (!options->GetDictionary(i, &option_value))
-      return false;  // Every entry must be a dictionary.
+  const base::Value::ListStorage& options = options_value->GetList();
+  for (const base::Value& option_value : options) {
     Option option;
-    if (!Traits::Load(*option_value, &option))
+    if (!option_value.is_dict() || !Traits::Load(option_value, &option))
       return false;
     AddOption(option);
   }
@@ -65,13 +63,12 @@ template <class Option, class Traits>
 void ListCapability<Option, Traits>::SaveTo(
     CloudDeviceDescription* description) const {
   DCHECK(IsValid());
-  base::ListValue* options_list =
-      description->CreateListItem(Traits::GetCapabilityPath());
-  for (size_t i = 0; i < options_.size(); ++i) {
-    std::unique_ptr<base::DictionaryValue> option_value(
-        new base::DictionaryValue);
-    Traits::Save(options_[i], option_value.get());
-    options_list->Append(std::move(option_value));
+  base::Value* options_list = description->CreateItem(
+      Traits::GetCapabilityPath(), base::Value::Type::LIST);
+  for (const Option& option : options_) {
+    base::Value option_value(base::Value::Type::DICTIONARY);
+    Traits::Save(option, &option_value);
+    options_list->GetList().emplace_back(std::move(option_value));
   }
 }
 
@@ -99,22 +96,21 @@ template <class Option, class Traits>
 bool SelectionCapability<Option, Traits>::LoadFrom(
     const CloudDeviceDescription& description) {
   Reset();
-  const base::DictionaryValue* item =
-      description.GetItem(Traits::GetCapabilityPath());
+  const base::Value* item = description.GetItem(Traits::GetCapabilityPath(),
+                                                base::Value::Type::DICTIONARY);
   if (!item)
     return false;
-  const base::ListValue* options = NULL;
-  if (!item->GetList(json::kKeyOption, &options))
+  const base::Value* options_value =
+      item->FindKeyOfType(json::kKeyOption, base::Value::Type::LIST);
+  if (!options_value)
     return false;
-  for (size_t i = 0; i < options->GetSize(); ++i) {
-    const base::DictionaryValue* option_value = NULL;
-    if (!options->GetDictionary(i, &option_value))
-      return false;  // Every entry must be a dictionary.
+  const base::Value::ListStorage& options = options_value->GetList();
+  for (const base::Value& option_value : options) {
     Option option;
-    if (!Traits::Load(*option_value, &option))
+    if (!option_value.is_dict() || !Traits::Load(option_value, &option))
       return false;
-    bool is_default = false;
-    option_value->GetBoolean(json::kKeyIsDefault, &is_default);
+    bool is_default =
+        option_value.FindBoolKey(json::kKeyIsDefault).value_or(false);
     if (is_default && default_idx_ >= 0) {
       return false;  // Multiple defaults.
     }
@@ -127,16 +123,17 @@ template <class Option, class Traits>
 void SelectionCapability<Option, Traits>::SaveTo(
     CloudDeviceDescription* description) const {
   DCHECK(IsValid());
-  auto options_list = std::make_unique<base::ListValue>();
+  base::Value options_list(base::Value::Type::LIST);
   for (size_t i = 0; i < options_.size(); ++i) {
-    auto option_value = std::make_unique<base::DictionaryValue>();
+    base::Value option_value(base::Value::Type::DICTIONARY);
     if (base::checked_cast<int>(i) == default_idx_)
-      option_value->SetBoolean(json::kKeyIsDefault, true);
-    Traits::Save(options_[i], option_value.get());
-    options_list->Append(std::move(option_value));
+      option_value.SetKey(json::kKeyIsDefault, base::Value(true));
+    Traits::Save(options_[i], &option_value);
+    options_list.GetList().emplace_back(std::move(option_value));
   }
-  description->CreateItem(Traits::GetCapabilityPath())
-      ->Set(json::kKeyOption, std::move(options_list));
+  description
+      ->CreateItem(Traits::GetCapabilityPath(), base::Value::Type::DICTIONARY)
+      ->SetKey(json::kKeyOption, std::move(options_list));
 }
 
 template <class Traits>
@@ -152,34 +149,36 @@ template <class Traits>
 bool BooleanCapability<Traits>::LoadFrom(
     const CloudDeviceDescription& description) {
   Reset();
-  const base::DictionaryValue* dict =
-      description.GetItem(Traits::GetCapabilityPath());
+  const base::Value* dict = description.GetItem(Traits::GetCapabilityPath(),
+                                                base::Value::Type::DICTIONARY);
   if (!dict)
     return false;
-  default_value_ = Traits::kDefault;
-  dict->GetBoolean(json::kKeyDefault, &default_value_);
+  default_value_ = dict->FindBoolKey(json::kKeyDefault)
+                       .value_or(static_cast<bool>(Traits::kDefault));
   return true;
 }
 
 template <class Traits>
 void BooleanCapability<Traits>::SaveTo(
     CloudDeviceDescription* description) const {
-  base::DictionaryValue* dict =
-      description->CreateItem(Traits::GetCapabilityPath());
+  base::Value* dict = description->CreateItem(Traits::GetCapabilityPath(),
+                                              base::Value::Type::DICTIONARY);
   if (default_value_ != Traits::kDefault)
-    dict->SetBoolean(json::kKeyDefault, default_value_);
+    dict->SetKey(json::kKeyDefault, base::Value(default_value_));
 }
 
 template <class Traits>
 bool EmptyCapability<Traits>::LoadFrom(
     const CloudDeviceDescription& description) {
-  return description.GetItem(Traits::GetCapabilityPath()) != NULL;
+  return description.GetItem(Traits::GetCapabilityPath(),
+                             base::Value::Type::DICTIONARY) != nullptr;
 }
 
 template <class Traits>
 void EmptyCapability<Traits>::SaveTo(
     CloudDeviceDescription* description) const {
-  description->CreateItem(Traits::GetCapabilityPath());
+  description->CreateItem(Traits::GetCapabilityPath(),
+                          base::Value::Type::DICTIONARY);
 }
 
 template <class Option, class Traits>
@@ -200,8 +199,8 @@ template <class Option, class Traits>
 bool ValueCapability<Option, Traits>::LoadFrom(
     const CloudDeviceDescription& description) {
   Reset();
-  const base::DictionaryValue* option_value =
-      description.GetItem(Traits::GetCapabilityPath());
+  const base::Value* option_value = description.GetItem(
+      Traits::GetCapabilityPath(), base::Value::Type::DICTIONARY);
   if (!option_value)
     return false;
   Option option;
@@ -215,7 +214,8 @@ template <class Option, class Traits>
 void ValueCapability<Option, Traits>::SaveTo(
     CloudDeviceDescription* description) const {
   DCHECK(IsValid());
-  Traits::Save(value(), description->CreateItem(Traits::GetCapabilityPath()));
+  Traits::Save(value(), description->CreateItem(Traits::GetCapabilityPath(),
+                                                base::Value::Type::DICTIONARY));
 }
 
 template <class Option, class Traits>
@@ -236,8 +236,8 @@ template <class Option, class Traits>
 bool TicketItem<Option, Traits>::LoadFrom(
     const CloudDeviceDescription& description) {
   Reset();
-  const base::DictionaryValue* option_value =
-      description.GetItem(Traits::GetTicketItemPath());
+  const base::Value* option_value = description.GetItem(
+      Traits::GetTicketItemPath(), base::Value::Type::DICTIONARY);
   if (!option_value)
     return false;
   Option option;
@@ -251,7 +251,8 @@ template <class Option, class Traits>
 void TicketItem<Option, Traits>::SaveTo(
     CloudDeviceDescription* description) const {
   DCHECK(IsValid());
-  Traits::Save(value(), description->CreateItem(Traits::GetTicketItemPath()));
+  Traits::Save(value(), description->CreateItem(Traits::GetTicketItemPath(),
+                                                base::Value::Type::DICTIONARY));
 }
 
 }  // namespace cloud_devices