Make crash reporting client_id accessible through child_process_logging.

base/linux_util.cc

 // Copyright (c) 2010 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 <glib.h>
@@ skipping 108 matching lines @@
   }
 
   *inode_out = inode_ul;
   return true;
 }
 
 }  // namespace
 
 namespace base {
 
+// Account for the terminating null character.
+static const int kDistroSize = 128 + 1;
+
 // We use this static string to hold the Linux distro info. If we
 // crash, the crash handler code will send this in the crash dump.
-std::string linux_distro =
+char g_linux_distro[kDistroSize] =
 #if defined(OS_CHROMEOS)
     "CrOS";
 #else  // if defined(OS_LINUX)
     "Unknown";
 #endif
 
 std::string GetLinuxDistro() {
 #if defined(OS_CHROMEOS)
-  return linux_distro;
+  return g_linux_distro;
 #elif defined(OS_LINUX)
   LinuxDistroHelper* distro_state_singleton = LinuxDistroHelper::Get();
   LinuxDistroState state = distro_state_singleton->State();
   if (STATE_DID_NOT_CHECK == state) {
     // 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);
     if (output.length() > 0) {
       // lsb_release -d should return: Description:<tab>Distro Info
       static const std::string field = "Description:\t";
       if (output.compare(0, field.length(), field) == 0) {
-        linux_distro = output.substr(field.length());
-        TrimWhitespaceASCII(linux_distro, TRIM_ALL, &linux_distro);
+        SetLinuxDistro(output.substr(field.length()));
       }
     }
     distro_state_singleton->CheckFinished();
-    return linux_distro;
+    return g_linux_distro;
   } else if (STATE_CHECK_STARTED == state) {
     // If the distro check above is in progress in some other thread, we're
     // not going to wait for the results.
     return "Unknown";
   } else {
     // In STATE_CHECK_FINISHED, no more writing to |linux_distro|.
-    return linux_distro;
+    return g_linux_distro;
   }
 #else
   NOTIMPLEMENTED();
 #endif
 }
 
+void SetLinuxDistro(const std::string& distro) {
+  std::string trimmed_distro;
+  TrimWhitespaceASCII(distro, TRIM_ALL, &trimmed_distro);
+  base::strlcpy(g_linux_distro, trimmed_distro.c_str(), kDistroSize);
+}
+
 bool FileDescriptorGetInode(ino_t* inode_out, int fd) {
   DCHECK(inode_out);
 
   struct stat buf;
   if (fstat(fd, &buf) < 0)
     return false;
 
   if (!S_ISSOCK(buf.st_mode))
     return false;
 
@@ skipping 95 matching lines @@
 
     if (0 == strncmp(expected_data.c_str(), syscall_data.get(),
                      expected_data.length())) {
       return current_tid;
     }
   }
   return -1;
 }
 
 }  // namespace base