base: Remove LazyInstance with AtExit from process_linux.cc

base/process/process_linux.cc

 // Copyright (c) 2011 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 "base/process/process.h"
 
 #include <errno.h>
 #include <sys/resource.h>
 
 #include "base/files/file_util.h"
@@ skipping 42 matching lines @@
     background_file =
         base::FilePath(base::StringPrintf(kControlPath, kBackground));
     base::FileSystemType foreground_type;
     base::FileSystemType background_type;
     enabled =
         base::GetFileSystemType(foreground_file, &foreground_type) &&
         base::GetFileSystemType(background_file, &background_type) &&
         foreground_type == FILE_SYSTEM_CGROUP &&
         background_type == FILE_SYSTEM_CGROUP;
   }
+
+  static CGroups& Get() {
+    static auto& groups = *new CGroups;
+    return groups;
+  }
 };
-
-base::LazyInstance<CGroups>::DestructorAtExit g_cgroups =
-    LAZY_INSTANCE_INITIALIZER;
 #else
 const int kBackgroundPriority = 5;
 #endif  // defined(OS_CHROMEOS)
 
 struct CheckForNicePermission {
   CheckForNicePermission() : can_reraise_priority(false) {
     // We won't be able to raise the priority if we don't have the right rlimit.
     // The limit may be adjusted in /etc/security/limits.conf for PAM systems.
     struct rlimit rlim;
     if ((getrlimit(RLIMIT_NICE, &rlim) == 0) &&
         (20 - kForegroundPriority) <= static_cast<int>(rlim.rlim_cur)) {
         can_reraise_priority = true;
     }
   };
 
   bool can_reraise_priority;
 };
 
 }  // namespace
 
 // static
 bool Process::CanBackgroundProcesses() {
 #if defined(OS_CHROMEOS)
-  if (g_cgroups.Get().enabled)
+  if (CGroups::Get().enabled)
     return true;
 #endif  // defined(OS_CHROMEOS)
 
   static LazyInstance<CheckForNicePermission>::DestructorAtExit
       check_for_nice_permission = LAZY_INSTANCE_INITIALIZER;
   return check_for_nice_permission.Get().can_reraise_priority;
 }
 
 bool Process::IsProcessBackgrounded() const {
   DCHECK(IsValid());
 
 #if defined(OS_CHROMEOS)
-  if (g_cgroups.Get().enabled) {
+  if (CGroups::Get().enabled) {
     // Used to allow reading the process priority from proc on thread launch.
     base::ThreadRestrictions::ScopedAllowIO allow_io;
     std::string proc;
     if (base::ReadFileToString(
             base::FilePath(StringPrintf(kProcPath, process_)), &proc)) {
       return IsProcessBackgroundedCGroup(proc);
     }
     return false;
   }
 #endif  // defined(OS_CHROMEOS)
 
   return GetPriority() == kBackgroundPriority;
 }
 
 bool Process::SetProcessBackgrounded(bool background) {
   DCHECK(IsValid());
 
 #if defined(OS_CHROMEOS)
-  if (g_cgroups.Get().enabled) {
+  if (CGroups::Get().enabled) {
     std::string pid = IntToString(process_);
-    const base::FilePath file =
-        background ?
-            g_cgroups.Get().background_file : g_cgroups.Get().foreground_file;
+    const base::FilePath file = background ? CGroups::Get().background_file
+                                           : CGroups::Get().foreground_file;
     return base::WriteFile(file, pid.c_str(), pid.size()) > 0;
   }
 #endif  // defined(OS_CHROMEOS)
 
   if (!CanBackgroundProcesses())
     return false;
 
   int priority = background ? kBackgroundPriority : kForegroundPriority;
   int result = setpriority(PRIO_PROCESS, process_, priority);
   DPCHECK(result == 0);
@@ skipping 57 matching lines @@
         return kNullProcessId;
       }
       return value;
     }
   }
   return kNullProcessId;
 }
 #endif  // defined(OS_CHROMEOS)
 
 }  // namespace base