Use std::unique_ptr to transfer base::Value ownership in extensions::ValueStoreChange

extensions/browser/value_store/leveldb_value_store.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/value_store/leveldb_value_store.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 175 matching lines @@
   leveldb::WriteBatch batch;
   std::unique_ptr<ValueStoreChangeList> changes(new ValueStoreChangeList());
 
   for (const std::string& key : keys) {
     std::unique_ptr<base::Value> old_value;
     status.Merge(Read(key, &old_value));
     if (!status.ok())
       return MakeWriteResult(status);
 
     if (old_value) {
-      changes->push_back(ValueStoreChange(key, old_value.release(), NULL));
+      changes->push_back(ValueStoreChange(key, std::move(old_value), nullptr));
       batch.Delete(key);
     }
   }
 
   leveldb::Status ldb_status = db()->Write(leveldb::WriteOptions(), &batch);
   if (!ldb_status.ok() && !ldb_status.IsNotFound()) {
     status.Merge(ToValueStoreError(ldb_status));
     return MakeWriteResult(status);
   }
   return MakeWriteResult(std::move(changes), status);
 }
 
 ValueStore::WriteResult LeveldbValueStore::Clear() {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   std::unique_ptr<ValueStoreChangeList> changes(new ValueStoreChangeList());
 
   ReadResult read_result = Get();
   if (!read_result->status().ok())
     return MakeWriteResult(read_result->status());
 
   base::DictionaryValue& whole_db = read_result->settings();
   while (!whole_db.empty()) {
     std::string next_key = base::DictionaryValue::Iterator(whole_db).key();
     std::unique_ptr<base::Value> next_value;
     whole_db.RemoveWithoutPathExpansion(next_key, &next_value);
-    changes->push_back(ValueStoreChange(next_key, next_value.release(), NULL));
+    changes->push_back(
+        ValueStoreChange(next_key, std::move(next_value), nullptr));
   }
 
   DeleteDbFile();
   return MakeWriteResult(std::move(changes), read_result->status());
 }
 
 bool LeveldbValueStore::WriteToDbForTest(leveldb::WriteBatch* batch) {
   Status status = EnsureDbIsOpen();
   if (!status.ok())
     return false;
@@ skipping 39 matching lines @@
     ValueStoreChangeList* changes) {
   bool write_new_value = true;
 
   if (!(options & NO_GENERATE_CHANGES)) {
     std::unique_ptr<base::Value> old_value;
     Status status = Read(key, &old_value);
     if (!status.ok())
       return status;
     if (!old_value || !old_value->Equals(&value)) {
       changes->push_back(
-          ValueStoreChange(key, old_value.release(), value.DeepCopy()));
+          ValueStoreChange(key, std::move(old_value), value.CreateDeepCopy()));
     } else {
       write_new_value = false;
     }
   }
 
   if (write_new_value) {
     std::string value_as_json;
     if (!base::JSONWriter::Write(value, &value_as_json))
       return Status(OTHER_ERROR, kCannotSerialize);
     batch->Put(key, value_as_json);
   }
 
   return Status();
 }
 
 ValueStore::Status LeveldbValueStore::WriteToDb(leveldb::WriteBatch* batch) {
   return ToValueStoreError(db()->Write(write_options(), batch));
 }