1// Copyright (c) 2012 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#include "rlz/chromeos/lib/rlz_value_store_chromeos.h" 6 7#include "base/base_paths.h" 8#include "base/file_util.h" 9#include "base/files/important_file_writer.h" 10#include "base/json/json_file_value_serializer.h" 11#include "base/json/json_string_value_serializer.h" 12#include "base/logging.h" 13#include "base/path_service.h" 14#include "base/sequenced_task_runner.h" 15#include "base/strings/string_number_conversions.h" 16#include "base/values.h" 17#include "rlz/lib/lib_values.h" 18#include "rlz/lib/recursive_cross_process_lock_posix.h" 19#include "rlz/lib/rlz_lib.h" 20 21namespace rlz_lib { 22 23namespace { 24 25// Key names. 26const char kPingTimeKey[] = "ping_time"; 27const char kAccessPointKey[] = "access_points"; 28const char kProductEventKey[] = "product_events"; 29const char kStatefulEventKey[] = "stateful_events"; 30 31// Brand name used when there is no supplementary brand name. 32const char kNoSupplementaryBrand[] = "_"; 33 34// RLZ store filename. 35const base::FilePath::CharType kRLZDataFileName[] = 36 FILE_PATH_LITERAL("RLZ Data"); 37 38// RLZ store lock filename 39const base::FilePath::CharType kRLZLockFileName[] = 40 FILE_PATH_LITERAL("RLZ Data.lock"); 41 42// RLZ store path for testing. 43base::FilePath g_testing_rlz_store_path_; 44 45// Returns file path of the RLZ storage. 46base::FilePath GetRlzStorePath() { 47 base::FilePath homedir; 48 PathService::Get(base::DIR_HOME, &homedir); 49 return g_testing_rlz_store_path_.empty() ? 50 homedir.Append(kRLZDataFileName) : 51 g_testing_rlz_store_path_.Append(kRLZDataFileName); 52} 53 54// Returns file path of the RLZ storage lock file. 55base::FilePath GetRlzStoreLockPath() { 56 base::FilePath homedir; 57 PathService::Get(base::DIR_HOME, &homedir); 58 return g_testing_rlz_store_path_.empty() ? 59 homedir.Append(kRLZLockFileName) : 60 g_testing_rlz_store_path_.Append(kRLZLockFileName); 61} 62 63// Returns the dictionary key for storing access point-related prefs. 64std::string GetKeyName(std::string key, AccessPoint access_point) { 65 std::string brand = SupplementaryBranding::GetBrand(); 66 if (brand.empty()) 67 brand = kNoSupplementaryBrand; 68 return key + "." + GetAccessPointName(access_point) + "." + brand; 69} 70 71// Returns the dictionary key for storing product-related prefs. 72std::string GetKeyName(std::string key, Product product) { 73 std::string brand = SupplementaryBranding::GetBrand(); 74 if (brand.empty()) 75 brand = kNoSupplementaryBrand; 76 return key + "." + GetProductName(product) + "." + brand; 77} 78 79} // namespace 80 81RlzValueStoreChromeOS::RlzValueStoreChromeOS(const base::FilePath& store_path) 82 : rlz_store_(new base::DictionaryValue), 83 store_path_(store_path), 84 read_only_(true) { 85 ReadStore(); 86} 87 88RlzValueStoreChromeOS::~RlzValueStoreChromeOS() { 89 WriteStore(); 90} 91 92bool RlzValueStoreChromeOS::HasAccess(AccessType type) { 93 DCHECK(CalledOnValidThread()); 94 return type == kReadAccess || !read_only_; 95} 96 97bool RlzValueStoreChromeOS::WritePingTime(Product product, int64 time) { 98 DCHECK(CalledOnValidThread()); 99 rlz_store_->SetString(GetKeyName(kPingTimeKey, product), 100 base::Int64ToString(time)); 101 return true; 102} 103 104bool RlzValueStoreChromeOS::ReadPingTime(Product product, int64* time) { 105 DCHECK(CalledOnValidThread()); 106 std::string ping_time; 107 return rlz_store_->GetString(GetKeyName(kPingTimeKey, product), &ping_time) && 108 base::StringToInt64(ping_time, time); 109} 110 111bool RlzValueStoreChromeOS::ClearPingTime(Product product) { 112 DCHECK(CalledOnValidThread()); 113 rlz_store_->Remove(GetKeyName(kPingTimeKey, product), NULL); 114 return true; 115} 116 117bool RlzValueStoreChromeOS::WriteAccessPointRlz(AccessPoint access_point, 118 const char* new_rlz) { 119 DCHECK(CalledOnValidThread()); 120 rlz_store_->SetString( 121 GetKeyName(kAccessPointKey, access_point), new_rlz); 122 return true; 123} 124 125bool RlzValueStoreChromeOS::ReadAccessPointRlz(AccessPoint access_point, 126 char* rlz, 127 size_t rlz_size) { 128 DCHECK(CalledOnValidThread()); 129 std::string rlz_value; 130 rlz_store_->GetString(GetKeyName(kAccessPointKey, access_point), &rlz_value); 131 if (rlz_value.size() < rlz_size) { 132 strncpy(rlz, rlz_value.c_str(), rlz_size); 133 return true; 134 } 135 if (rlz_size > 0) 136 *rlz = '\0'; 137 return false; 138} 139 140bool RlzValueStoreChromeOS::ClearAccessPointRlz(AccessPoint access_point) { 141 DCHECK(CalledOnValidThread()); 142 rlz_store_->Remove(GetKeyName(kAccessPointKey, access_point), NULL); 143 return true; 144} 145 146bool RlzValueStoreChromeOS::AddProductEvent(Product product, 147 const char* event_rlz) { 148 DCHECK(CalledOnValidThread()); 149 return AddValueToList(GetKeyName(kProductEventKey, product), 150 new base::StringValue(event_rlz)); 151} 152 153bool RlzValueStoreChromeOS::ReadProductEvents( 154 Product product, 155 std::vector<std::string>* events) { 156 DCHECK(CalledOnValidThread()); 157 base::ListValue* events_list = NULL; ; 158 if (!rlz_store_->GetList(GetKeyName(kProductEventKey, product), &events_list)) 159 return false; 160 events->clear(); 161 for (size_t i = 0; i < events_list->GetSize(); ++i) { 162 std::string event; 163 if (events_list->GetString(i, &event)) 164 events->push_back(event); 165 } 166 return true; 167} 168 169bool RlzValueStoreChromeOS::ClearProductEvent(Product product, 170 const char* event_rlz) { 171 DCHECK(CalledOnValidThread()); 172 base::StringValue event_value(event_rlz); 173 return RemoveValueFromList(GetKeyName(kProductEventKey, product), 174 event_value); 175} 176 177bool RlzValueStoreChromeOS::ClearAllProductEvents(Product product) { 178 DCHECK(CalledOnValidThread()); 179 rlz_store_->Remove(GetKeyName(kProductEventKey, product), NULL); 180 return true; 181} 182 183bool RlzValueStoreChromeOS::AddStatefulEvent(Product product, 184 const char* event_rlz) { 185 DCHECK(CalledOnValidThread()); 186 return AddValueToList(GetKeyName(kStatefulEventKey, product), 187 new base::StringValue(event_rlz)); 188} 189 190bool RlzValueStoreChromeOS::IsStatefulEvent(Product product, 191 const char* event_rlz) { 192 DCHECK(CalledOnValidThread()); 193 base::StringValue event_value(event_rlz); 194 base::ListValue* events_list = NULL; 195 return rlz_store_->GetList(GetKeyName(kStatefulEventKey, product), 196 &events_list) && 197 events_list->Find(event_value) != events_list->end(); 198} 199 200bool RlzValueStoreChromeOS::ClearAllStatefulEvents(Product product) { 201 DCHECK(CalledOnValidThread()); 202 rlz_store_->Remove(GetKeyName(kStatefulEventKey, product), NULL); 203 return true; 204} 205 206void RlzValueStoreChromeOS::CollectGarbage() { 207 DCHECK(CalledOnValidThread()); 208 NOTIMPLEMENTED(); 209} 210 211void RlzValueStoreChromeOS::ReadStore() { 212 int error_code = 0; 213 std::string error_msg; 214 JSONFileValueSerializer serializer(store_path_); 215 scoped_ptr<base::Value> value( 216 serializer.Deserialize(&error_code, &error_msg)); 217 switch (error_code) { 218 case JSONFileValueSerializer::JSON_NO_SUCH_FILE: 219 read_only_ = false; 220 break; 221 case JSONFileValueSerializer::JSON_NO_ERROR: 222 read_only_ = false; 223 rlz_store_.reset(static_cast<base::DictionaryValue*>(value.release())); 224 break; 225 default: 226 LOG(ERROR) << "Error reading RLZ store: " << error_msg; 227 } 228} 229 230void RlzValueStoreChromeOS::WriteStore() { 231 std::string json_data; 232 JSONStringValueSerializer serializer(&json_data); 233 serializer.set_pretty_print(true); 234 scoped_ptr<base::DictionaryValue> copy( 235 rlz_store_->DeepCopyWithoutEmptyChildren()); 236 if (!serializer.Serialize(*copy.get())) { 237 LOG(ERROR) << "Failed to serialize RLZ data"; 238 NOTREACHED(); 239 return; 240 } 241 if (!base::ImportantFileWriter::WriteFileAtomically(store_path_, json_data)) 242 LOG(ERROR) << "Error writing RLZ store"; 243} 244 245bool RlzValueStoreChromeOS::AddValueToList(std::string list_name, 246 base::Value* value) { 247 base::ListValue* list_value = NULL; 248 if (!rlz_store_->GetList(list_name, &list_value)) { 249 list_value = new base::ListValue; 250 rlz_store_->Set(list_name, list_value); 251 } 252 list_value->AppendIfNotPresent(value); 253 return true; 254} 255 256bool RlzValueStoreChromeOS::RemoveValueFromList(std::string list_name, 257 const base::Value& value) { 258 base::ListValue* list_value = NULL; 259 if (!rlz_store_->GetList(list_name, &list_value)) 260 return false; 261 size_t index; 262 list_value->Remove(value, &index); 263 return true; 264} 265 266namespace { 267 268// RlzValueStoreChromeOS keeps its data in memory and only writes it to disk 269// when ScopedRlzValueStoreLock goes out of scope. Hence, if several 270// ScopedRlzValueStoreLocks are nested, they all need to use the same store 271// object. 272 273RecursiveCrossProcessLock g_recursive_lock = 274 RECURSIVE_CROSS_PROCESS_LOCK_INITIALIZER; 275 276// This counts the nesting depth of |ScopedRlzValueStoreLock|. 277int g_lock_depth = 0; 278 279// This is the shared store object. Non-|NULL| only when |g_lock_depth > 0|. 280RlzValueStoreChromeOS* g_store = NULL; 281 282} // namespace 283 284ScopedRlzValueStoreLock::ScopedRlzValueStoreLock() { 285 bool got_cross_process_lock = 286 g_recursive_lock.TryGetCrossProcessLock(GetRlzStoreLockPath()); 287 // At this point, we hold the in-process lock, no matter the value of 288 // |got_cross_process_lock|. 289 290 ++g_lock_depth; 291 if (!got_cross_process_lock) { 292 // Acquiring cross-process lock failed, so simply return here. 293 // In-process lock will be released in dtor. 294 DCHECK(!g_store); 295 return; 296 } 297 298 if (g_lock_depth > 1) { 299 // Reuse the already existing store object. 300 DCHECK(g_store); 301 store_.reset(g_store); 302 return; 303 } 304 305 // This is the topmost lock, create a new store object. 306 DCHECK(!g_store); 307 g_store = new RlzValueStoreChromeOS(GetRlzStorePath()); 308 store_.reset(g_store); 309} 310 311ScopedRlzValueStoreLock::~ScopedRlzValueStoreLock() { 312 --g_lock_depth; 313 DCHECK(g_lock_depth >= 0); 314 315 if (g_lock_depth > 0) { 316 // Other locks are still using store_, so don't free it yet. 317 ignore_result(store_.release()); 318 return; 319 } 320 321 g_store = NULL; 322 323 g_recursive_lock.ReleaseLock(); 324} 325 326RlzValueStore* ScopedRlzValueStoreLock::GetStore() { 327 return store_.get(); 328} 329 330namespace testing { 331 332void SetRlzStoreDirectory(const base::FilePath& directory) { 333 g_testing_rlz_store_path_ = directory; 334} 335 336std::string RlzStoreFilenameStr() { 337 return GetRlzStorePath().value(); 338} 339 340} // namespace testing 341 342} // namespace rlz_lib 343