Remove raw base::DictionaryValue::Set in //extensions

extensions/browser/computed_hashes.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 "extensions/browser/computed_hashes.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/base64.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
+#include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "crypto/secure_hash.h"
 #include "crypto/sha2.h"
 
 namespace {
 const char kBlockHashesKey[] = "block_hashes";
 const char kBlockSizeKey[] = "block_size";
 const char kFileHashesKey[] = "file_hashes";
 const char kPathKey[] = "path";
@@ skipping 104 matching lines @@
 
 ComputedHashes::Writer::Writer() : file_list_(new base::ListValue) {
 }
 
 ComputedHashes::Writer::~Writer() {
 }
 
 void ComputedHashes::Writer::AddHashes(const base::FilePath& relative_path,
                                        int block_size,
                                        const std::vector<std::string>& hashes) {
-  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
-  base::ListValue* block_hashes = new base::ListValue();
+  auto block_hashes = base::MakeUnique<base::ListValue>();
+  block_hashes->GetList().reserve(hashes.size());
+  for (const auto& hash : hashes) {
+    std::string encoded;
+    base::Base64Encode(hash, &encoded);
+    block_hashes->GetList().emplace_back(std::move(encoded));
+  }
+
+  auto dict = base::MakeUnique<base::DictionaryValue>();
   dict->SetString(kPathKey,
                   relative_path.NormalizePathSeparatorsTo('/').AsUTF8Unsafe());
   dict->SetInteger(kBlockSizeKey, block_size);
-  dict->Set(kBlockHashesKey, block_hashes);
+  dict->Set(kBlockHashesKey, std::move(block_hashes));
   file_list_->Append(std::move(dict));
-
-  for (std::vector<std::string>::const_iterator i = hashes.begin();
-       i != hashes.end();
-       ++i) {
-    std::string encoded;
-    base::Base64Encode(*i, &encoded);
-    block_hashes->AppendString(encoded);
-  }
 }
 
 bool ComputedHashes::Writer::WriteToFile(const base::FilePath& path) {
   std::string json;
   base::DictionaryValue top_dictionary;
   top_dictionary.SetInteger(kVersionKey, kVersion);
-  top_dictionary.Set(kFileHashesKey, file_list_.release());
+  top_dictionary.Set(kFileHashesKey, std::move(file_list_));
 
   if (!base::JSONWriter::Write(top_dictionary, &json))
     return false;
   int written = base::WriteFile(path, json.data(), json.size());
   if (static_cast<unsigned>(written) != json.size()) {
     LOG(ERROR) << "Error writing " << path.AsUTF8Unsafe()
                << " ; write result:" << written << " expected:" << json.size();
     return false;
   }
   return true;
@@ skipping 20 matching lines @@
 
     // If |contents| is empty, then we want to just exit here.
     if (bytes_to_read == 0)
       break;
 
     offset += bytes_to_read;
   } while (offset < contents.size());
 }
 
 }  // namespace extensions