Cleanup: Move some const char definitions to the .cc file. (try 2)

base/linux_util.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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 <glib.h>
 #include <stdlib.h>
@@ skipping 84 matching lines @@
   buf[n] = 0;
 
   if (memcmp(kSocketLinkPrefix, buf, sizeof(kSocketLinkPrefix) - 1)) {
     if (log) {
       DLOG(WARNING) << "The descriptor passed from the crashing process wasn't "
                       " a UNIX domain socket.";
     }
     return false;
   }
 
-  char *endptr;
+  char* endptr;
   const unsigned long long int inode_ul =
       strtoull(buf + sizeof(kSocketLinkPrefix) - 1, &endptr, 10);
   if (*endptr != ']')
     return false;
 
   if (inode_ul == ULLONG_MAX) {
     if (log) {
       DLOG(WARNING) << "Failed to parse a socket's inode number: the number "
                        "was too large. Please report this bug: " << buf;
     }
     return false;
   }
 
   *inode_out = inode_ul;
   return true;
 }
 
 }  // namespace
 
 namespace base {
 
+const char kFindInodeSwitch[] = "--find-inode";
+
+// This should be kept in sync with sandbox/linux/suid/sandbox.c
+const long kSUIDSandboxApiNumber = 1;
+const char kSandboxEnvironmentApiRequest[] = "SBX_CHROME_API_RQ";
+const char kSandboxEnvironmentApiProvides[] = "SBX_CHROME_API_PRV";
+
 // 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.
 char g_linux_distro[kDistroSize] =
 #if defined(OS_CHROMEOS) && defined(USE_AURA)
     "CrOS Aura";
 #elif defined(OS_CHROMEOS)
     "CrOS";
@@ skipping 66 matching lines @@
   DIR* proc = opendir("/proc");
   if (!proc) {
     DLOG(WARNING) << "Cannot open /proc";
     return false;
   }
 
   std::vector<pid_t> pids;
 
   struct dirent* dent;
   while ((dent = readdir(proc))) {
-    char *endptr;
+    char* endptr;
     const unsigned long int pid_ul = strtoul(dent->d_name, &endptr, 10);
     if (pid_ul == ULONG_MAX || *endptr)
       continue;
     pids.push_back(pid_ul);
   }
   closedir(proc);
 
   for (std::vector<pid_t>::const_iterator
        i = pids.begin(); i != pids.end(); ++i) {
     const pid_t current_pid = *i;
@@ skipping 40 matching lines @@
 
   DIR* task = opendir(buf);
   if (!task) {
     DLOG(WARNING) << "Cannot open " << buf;
     return -1;
   }
 
   std::vector<pid_t> tids;
   struct dirent* dent;
   while ((dent = readdir(task))) {
-    char *endptr;
+    char* endptr;
     const unsigned long int tid_ul = strtoul(dent->d_name, &endptr, 10);
     if (tid_ul == ULONG_MAX || *endptr)
       continue;
     tids.push_back(tid_ul);
   }
   closedir(task);
 
   scoped_array<char> syscall_data(new char[expected_data.length()]);
   for (std::vector<pid_t>::const_iterator
        i = tids.begin(); i != tids.end(); ++i) {
@@ skipping 12 matching lines @@
 
     if (0 == strncmp(expected_data.c_str(), syscall_data.get(),
                      expected_data.length())) {
       return current_tid;
     }
   }
   return -1;
 }
 
 }  // namespace base