Remove raw DictionaryValue::Set in //components

components/bookmarks/browser/bookmark_codec.cc

 // Copyright 2014 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/bookmarks/browser/bookmark_codec.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 38 matching lines @@
 BookmarkCodec::BookmarkCodec()
     : ids_reassigned_(false),
       ids_valid_(true),
       maximum_id_(0),
       model_sync_transaction_version_(
           BookmarkNode::kInvalidSyncTransactionVersion) {
 }
 
 BookmarkCodec::~BookmarkCodec() {}
 
-base::Value* BookmarkCodec::Encode(BookmarkModel* model) {
+std::unique_ptr<base::Value> BookmarkCodec::Encode(BookmarkModel* model) {
   return Encode(model->bookmark_bar_node(),
                 model->other_node(),
                 model->mobile_node(),
                 model->root_node()->GetMetaInfoMap(),
                 model->root_node()->sync_transaction_version());
 }
 
-base::Value* BookmarkCodec::Encode(
+std::unique_ptr<base::Value> BookmarkCodec::Encode(
     const BookmarkNode* bookmark_bar_node,
     const BookmarkNode* other_folder_node,
     const BookmarkNode* mobile_folder_node,
     const BookmarkNode::MetaInfoMap* model_meta_info_map,
     int64_t sync_transaction_version) {
   ids_reassigned_ = false;
   InitializeChecksum();
-  base::DictionaryValue* roots = new base::DictionaryValue();
+  auto roots = base::MakeUnique<base::DictionaryValue>();
   roots->Set(kRootFolderNameKey, EncodeNode(bookmark_bar_node));
   roots->Set(kOtherBookmarkFolderNameKey, EncodeNode(other_folder_node));
   roots->Set(kMobileBookmarkFolderNameKey, EncodeNode(mobile_folder_node));
   if (model_meta_info_map)
     roots->Set(kMetaInfo, EncodeMetaInfo(*model_meta_info_map));
   if (sync_transaction_version !=
       BookmarkNode::kInvalidSyncTransactionVersion) {
     roots->SetString(kSyncTransactionVersion,
                      base::Int64ToString(sync_transaction_version));
   }
-  base::DictionaryValue* main = new base::DictionaryValue();
+  auto main = base::MakeUnique<base::DictionaryValue>();
   main->SetInteger(kVersionKey, kCurrentVersion);
   FinalizeChecksum();
   // We are going to store the computed checksum. So set stored checksum to be
   // the same as computed checksum.
   stored_checksum_ = computed_checksum_;
-  main->Set(kChecksumKey, new base::Value(computed_checksum_));
-  main->Set(kRootsKey, roots);
-  return main;
+  main->SetString(kChecksumKey, computed_checksum_);
+  main->Set(kRootsKey, std::move(roots));
+  return std::move(main);
 }
 
 bool BookmarkCodec::Decode(BookmarkNode* bb_node,
                            BookmarkNode* other_folder_node,
                            BookmarkNode* mobile_folder_node,
                            int64_t* max_id,
                            const base::Value& value) {
   ids_.clear();
   ids_reassigned_ = false;
   ids_valid_ = true;
@@ skipping 25 matching lines @@
     std::string url = node->url().possibly_invalid_spec();
     value->SetString(kURLKey, url);
     UpdateChecksumWithUrlNode(id, title, url);
   } else {
     value->SetString(kTypeKey, kTypeFolder);
     value->SetString(
         kDateModifiedKey,
         base::Int64ToString(node->date_folder_modified().ToInternalValue()));
     UpdateChecksumWithFolderNode(id, title);
 
-    base::ListValue* child_values = new base::ListValue();
-    value->Set(kChildrenKey, child_values);
+    auto child_values = base::MakeUnique<base::ListValue>();
     for (int i = 0; i < node->child_count(); ++i)
       child_values->Append(EncodeNode(node->GetChild(i)));
+    value->Set(kChildrenKey, std::move(child_values));
   }
   const BookmarkNode::MetaInfoMap* meta_info_map = node->GetMetaInfoMap();
   if (meta_info_map)
     value->Set(kMetaInfo, EncodeMetaInfo(*meta_info_map));
   if (node->sync_transaction_version() !=
       BookmarkNode::kInvalidSyncTransactionVersion) {
     value->SetString(kSyncTransactionVersion,
                      base::Int64ToString(node->sync_transaction_version()));
   }
   return std::move(value);
 }
 
-base::Value* BookmarkCodec::EncodeMetaInfo(
+std::unique_ptr<base::Value> BookmarkCodec::EncodeMetaInfo(
     const BookmarkNode::MetaInfoMap& meta_info_map) {
-  base::DictionaryValue* meta_info = new base::DictionaryValue;
+  auto meta_info = base::MakeUnique<base::DictionaryValue>();
   for (BookmarkNode::MetaInfoMap::const_iterator it = meta_info_map.begin();
       it != meta_info_map.end(); ++it) {
     meta_info->SetStringWithoutPathExpansion(it->first, it->second);
   }
-  return meta_info;
+  return std::move(meta_info);
 }
 
 bool BookmarkCodec::DecodeHelper(BookmarkNode* bb_node,
                                  BookmarkNode* other_folder_node,
                                  BookmarkNode* mobile_folder_node,
                                  const base::Value& value) {
   const base::DictionaryValue* d_value = nullptr;
   if (!value.GetAsDictionary(&d_value))
     return false;  // Unexpected type.
 
@@ skipping 323 matching lines @@
   base::MD5Init(&md5_context_);
 }
 
 void BookmarkCodec::FinalizeChecksum() {
   base::MD5Digest digest;
   base::MD5Final(&digest, &md5_context_);
   computed_checksum_ = base::MD5DigestToBase16(digest);
 }
 
 }  // namespace bookmarks