Fix static initializers in RlzValueStoreChromeOS.

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/lazy_instance.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"
 
@@ skipping 12 matching lines @@
 
 // RLZ store filename.
 const base::FilePath::CharType kRLZDataFileName[] =
     FILE_PATH_LITERAL("RLZ Data");
 
 // RLZ store lock filename
 const base::FilePath::CharType kRLZLockFileName[] =
     FILE_PATH_LITERAL("RLZ Data.lock");
 
 // RLZ store path for testing.
-base::FilePath g_testing_rlz_store_path_;
+base::LazyInstance<base::FilePath>::Leaky g_testing_rlz_store_path =
+    LAZY_INSTANCE_INITIALIZER;
+
+base::FilePath GetRlzStorePathCommon() {
+  base::FilePath homedir;
+  PathService::Get(base::DIR_HOME, &homedir);
+  return g_testing_rlz_store_path.Get().empty()
+             ? homedir
+             : g_testing_rlz_store_path.Get();
+}
 
 // Returns file path of the RLZ storage.
 base::FilePath GetRlzStorePath() {
-  base::FilePath homedir;
-  PathService::Get(base::DIR_HOME, &homedir);
-  return g_testing_rlz_store_path_.empty() ?
-      homedir.Append(kRLZDataFileName) :
-      g_testing_rlz_store_path_.Append(kRLZDataFileName);
+  return GetRlzStorePathCommon().Append(kRLZDataFileName);
 }
 
 // Returns file path of the RLZ storage lock file.
 base::FilePath GetRlzStoreLockPath() {
-  base::FilePath homedir;
-  PathService::Get(base::DIR_HOME, &homedir);
-  return g_testing_rlz_store_path_.empty() ?
-      homedir.Append(kRLZLockFileName) :
-      g_testing_rlz_store_path_.Append(kRLZLockFileName);
+  return GetRlzStorePathCommon().Append(kRLZLockFileName);
 }
 
 // Returns the dictionary key for storing access point-related prefs.
 std::string GetKeyName(const std::string& key, AccessPoint access_point) {
   std::string brand = SupplementaryBranding::GetBrand();
   if (brand.empty())
     brand = kNoSupplementaryBrand;
   return key + "." + GetAccessPointName(access_point) + "." + brand;
 }
 
@@ skipping 76 matching lines @@
                                             const char* event_rlz) {
   DCHECK(CalledOnValidThread());
   return AddValueToList(GetKeyName(kProductEventKey, product),
                         base::MakeUnique<base::Value>(event_rlz));
 }
 
 bool RlzValueStoreChromeOS::ReadProductEvents(
     Product product,
     std::vector<std::string>* events) {
   DCHECK(CalledOnValidThread());
-  base::ListValue* events_list = NULL; ;
+  base::ListValue* events_list = nullptr;
   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;
 }
@@ skipping 135 matching lines @@
   }
 
   // This is the topmost lock, create a new store object.
   DCHECK(!g_store);
   g_store = new RlzValueStoreChromeOS(GetRlzStorePath());
   store_.reset(g_store);
 }
 
 ScopedRlzValueStoreLock::~ScopedRlzValueStoreLock() {
   --g_lock_depth;
-  DCHECK(g_lock_depth >= 0);
+  DCHECK_GE(g_lock_depth, 0);
 
   if (g_lock_depth > 0) {
     // Other locks are still using store_, so don't free it yet.
     ignore_result(store_.release());
     return;
   }
 
   g_store = NULL;
 
   g_recursive_lock.ReleaseLock();
 }
 
 RlzValueStore* ScopedRlzValueStoreLock::GetStore() {
   return store_.get();
 }
 
 namespace testing {
 
 void SetRlzStoreDirectory(const base::FilePath& directory) {
-  g_testing_rlz_store_path_ = directory;
+  g_testing_rlz_store_path.Get() = directory;
 }
 
 std::string RlzStoreFilenameStr() {
   return GetRlzStorePath().value();
 }
 
 }  // namespace testing
 
 }  // namespace rlz_lib