Remove base::StringValue

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"
@@ skipping 130 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),
-                        base::MakeUnique<base::StringValue>(event_rlz));
+                        base::MakeUnique<base::Value>(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();
   for (size_t i = 0; i < events_list->GetSize(); ++i) {
     std::string event;
     if (events_list->GetString(i, &event))
       events->push_back(event);
   }
   return true;
 }
 
 bool RlzValueStoreChromeOS::ClearProductEvent(Product product,
                                               const char* event_rlz) {
   DCHECK(CalledOnValidThread());
-  base::StringValue event_value(event_rlz);
+  base::Value event_value(event_rlz);
   return RemoveValueFromList(GetKeyName(kProductEventKey, product),
                              event_value);
 }
 
 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),
-                        base::MakeUnique<base::StringValue>(event_rlz));
+                        base::MakeUnique<base::Value>(event_rlz));
 }
 
 bool RlzValueStoreChromeOS::IsStatefulEvent(Product product,
                                             const char* event_rlz) {
   DCHECK(CalledOnValidThread());
-  base::StringValue event_value(event_rlz);
+  base::Value 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();
 }
 
 bool RlzValueStoreChromeOS::ClearAllStatefulEvents(Product product) {
   DCHECK(CalledOnValidThread());
   rlz_store_->Remove(GetKeyName(kStatefulEventKey, product), NULL);
   return true;
@@ skipping 129 matching lines @@
   g_testing_rlz_store_path_ = directory;
 }
 
 std::string RlzStoreFilenameStr() {
   return GetRlzStorePath().value();
 }
 
 }  // namespace testing
 
 }  // namespace rlz_lib