Move Singleton and related structs to namespace base

base/linux_util.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 "base/linux_util.h"
 
 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <stdlib.h>
@@ skipping 19 matching lines @@
   STATE_DID_NOT_CHECK  = 0,
   STATE_CHECK_STARTED  = 1,
   STATE_CHECK_FINISHED = 2,
 };
 
 // Helper class for GetLinuxDistro().
 class LinuxDistroHelper {
  public:
   // Retrieves the Singleton.
   static LinuxDistroHelper* GetInstance() {
-    return Singleton<LinuxDistroHelper>::get();
+    return base::Singleton<LinuxDistroHelper>::get();
   }
 
   // The simple state machine goes from:
   // STATE_DID_NOT_CHECK -> STATE_CHECK_STARTED -> STATE_CHECK_FINISHED.
   LinuxDistroHelper() : state_(STATE_DID_NOT_CHECK) {}
   ~LinuxDistroHelper() {}
 
   // Retrieve the current state, if we're in STATE_DID_NOT_CHECK,
   // we automatically move to STATE_CHECK_STARTED so nobody else will
   // do the check.
@@ skipping 48 matching lines @@
   if (STATE_CHECK_STARTED == state)
     return "Unknown"; // Don't wait for other thread to finish.
   DCHECK_EQ(state, STATE_DID_NOT_CHECK);
   // We do this check only once per process. If it fails, there's
   // little reason to believe it will work if we attempt to run
   // lsb_release again.
   std::vector<std::string> argv;
   argv.push_back("lsb_release");
   argv.push_back("-d");
   std::string output;
-  base::GetAppOutput(CommandLine(argv), &output);
+  GetAppOutput(CommandLine(argv), &output);
   if (output.length() > 0) {
     // lsb_release -d should return: Description:<tab>Distro Info
     const char field[] = "Description:\t";
     if (output.compare(0, strlen(field), field) == 0) {
       SetLinuxDistro(output.substr(strlen(field)));
     }
   }
   distro_state_singleton->CheckFinished();
   return g_linux_distro;
 #else
   NOTIMPLEMENTED();
   return "Unknown";
 #endif
 }
 
 void SetLinuxDistro(const std::string& distro) {
   std::string trimmed_distro;
-  base::TrimWhitespaceASCII(distro, base::TRIM_ALL, &trimmed_distro);
-  base::strlcpy(g_linux_distro, trimmed_distro.c_str(), kDistroSize);
+  TrimWhitespaceASCII(distro, TRIM_ALL, &trimmed_distro);
+  strlcpy(g_linux_distro, trimmed_distro.c_str(), kDistroSize);
 }
 
 pid_t FindThreadIDWithSyscall(pid_t pid, const std::string& expected_data,
                               bool* syscall_supported) {
   char buf[256];
   snprintf(buf, sizeof(buf), "/proc/%d/task", pid);
 
   if (syscall_supported != NULL)
     *syscall_supported = false;
 
@@ skipping 31 matching lines @@
 
     if (0 == strncmp(expected_data.c_str(), syscall_data.get(),
                      expected_data.length())) {
       return current_tid;
     }
   }
   return -1;
 }
 
 }  // namespace base