Change more base::ListValue methods to use std::unique_ptr.

rlz/chromeos/lib/rlz_value_store_chromeos.cc

 // Copyright (c) 2012 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 "rlz/chromeos/lib/rlz_value_store_chromeos.h"
 
 #include "base/base_paths.h"
 #include "base/files/file_util.h"
 #include "base/files/important_file_writer.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/path_service.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "rlz/lib/lib_values.h"
 #include "rlz/lib/recursive_cross_process_lock_posix.h"
 #include "rlz/lib/rlz_lib.h"
 
 namespace rlz_lib {
 
@@ skipping 117 matching lines @@
 bool RlzValueStoreChromeOS::ClearAccessPointRlz(AccessPoint access_point) {
   DCHECK(CalledOnValidThread());
   rlz_store_->Remove(GetKeyName(kAccessPointKey, access_point), NULL);
   return true;
 }
 
 bool RlzValueStoreChromeOS::AddProductEvent(Product product,
                                             const char* event_rlz) {
   DCHECK(CalledOnValidThread());
   return AddValueToList(GetKeyName(kProductEventKey, product),
-                        new base::StringValue(event_rlz));
+                        base::MakeUnique<base::StringValue>(event_rlz));
 }
 
 bool RlzValueStoreChromeOS::ReadProductEvents(
     Product product,
     std::vector<std::string>* events) {
   DCHECK(CalledOnValidThread());
   base::ListValue* events_list = NULL; ;
   if (!rlz_store_->GetList(GetKeyName(kProductEventKey, product), &events_list))
     return false;
   events->clear();
@@ skipping 16 matching lines @@
 bool RlzValueStoreChromeOS::ClearAllProductEvents(Product product) {
   DCHECK(CalledOnValidThread());
   rlz_store_->Remove(GetKeyName(kProductEventKey, product), NULL);
   return true;
 }
 
 bool RlzValueStoreChromeOS::AddStatefulEvent(Product product,
                                              const char* event_rlz) {
   DCHECK(CalledOnValidThread());
   return AddValueToList(GetKeyName(kStatefulEventKey, product),
-                        new base::StringValue(event_rlz));
+                        base::MakeUnique<base::StringValue>(event_rlz));
 }
 
 bool RlzValueStoreChromeOS::IsStatefulEvent(Product product,
                                             const char* event_rlz) {
   DCHECK(CalledOnValidThread());
   base::StringValue event_value(event_rlz);
   base::ListValue* events_list = NULL;
   return rlz_store_->GetList(GetKeyName(kStatefulEventKey, product),
                              &events_list) &&
       events_list->Find(event_value) != events_list->end();
@@ skipping 38 matching lines @@
   if (!serializer.Serialize(*copy.get())) {
     LOG(ERROR) << "Failed to serialize RLZ data";
     NOTREACHED();
     return;
   }
   if (!base::ImportantFileWriter::WriteFileAtomically(store_path_, json_data))
     LOG(ERROR) << "Error writing RLZ store";
 }
 
 bool RlzValueStoreChromeOS::AddValueToList(const std::string& list_name,
-                                           base::Value* value) {
+                                           std::unique_ptr<base::Value> value) {
   base::ListValue* list_value = NULL;
   if (!rlz_store_->GetList(list_name, &list_value)) {
     list_value = new base::ListValue;
     rlz_store_->Set(list_name, list_value);
   }
-  list_value->AppendIfNotPresent(value);
+  list_value->AppendIfNotPresent(std::move(value));
   return true;
 }
 
 bool RlzValueStoreChromeOS::RemoveValueFromList(const std::string& list_name,
                                                 const base::Value& value) {
   base::ListValue* list_value = NULL;
   if (!rlz_store_->GetList(list_name, &list_value))
     return false;
   size_t index;
   list_value->Remove(value, &index);
@@ skipping 70 matching lines @@
   g_testing_rlz_store_path_ = directory;
 }
 
 std::string RlzStoreFilenameStr() {
   return GetRlzStorePath().value();
 }
 
 }  // namespace testing
 
 }  // namespace rlz_lib