Make crash reporting client_id accessible through child_process_logging.

chrome/app/breakpad_linux.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.
 
 #define SYS_SEGMENTNAME "syscalls" // For linux_syscall_support.h
 
 #include "chrome/app/breakpad_linux.h"
 
 #include <fcntl.h>
 #include <stdlib.h>
 #include <sys/socket.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/uio.h>
 #include <time.h>
 #include <unistd.h>
 
 #include <algorithm>
 #include <string>
 
 #include "base/command_line.h"
 #include "base/eintr_wrapper.h"
 #include "base/file_path.h"
 #include "base/global_descriptors_posix.h"
+#include "base/linux_util.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "breakpad/src/client/linux/handler/exception_handler.h"
 #include "breakpad/src/client/linux/minidump_writer/directory_reader.h"
 #include "breakpad/src/common/linux/linux_libc_support.h"
 #include "breakpad/src/common/linux/linux_syscall_support.h"
 #include "breakpad/src/common/linux/memory.h"
+#include "chrome/common/child_process_logging.h"
 #include "chrome/common/chrome_descriptors.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info_posix.h"
 #include "chrome/common/env_vars.h"
-#include "chrome/installer/util/google_update_settings.h"
 
 // Some versions of gcc are prone to warn about unused return values. In cases
 // where we either a) know the call cannot fail, or b) there is nothing we
 // can do when a call fails, we mark the return code as ignored. This avoids
 // spurious compiler warnings.
 #define IGNORE_RET(x) do { if (x); } while (0)
 
 static const char kUploadURL[] =
     "https://clients2.google.com/cr/report";
 
@@ skipping 524 matching lines @@
     static const char msg[] = "Cannot upload crash dump: cannot exec "
                               "/usr/bin/wget\n";
     sys_write(2, msg, sizeof(msg) - 1);
     sys__exit(1);
   }
 
   HANDLE_EINTR(sys_waitpid(child, NULL, 0));
   return child;
 }
 
-// This is defined in chrome/browser/google_update_settings_posix.cc, it's the
-// static string containing the user's unique GUID. We send this in the crash
-// report.
-namespace google_update {
-extern std::string posix_guid;
-}
-
-// This is defined in base/linux_util.cc, it's the static string containing the
-// user's distro info. We send this in the crash report.
-namespace base {
-extern std::string linux_distro;
-}
-
 static bool CrashDone(const char* dump_path,
                       const char* minidump_id,
                       const bool upload,
                       const bool succeeded) {
   // WARNING: this code runs in a compromised context. It may not call into
   // libc nor allocate memory normally.
   if (!succeeded)
     return false;
 
   google_breakpad::PageAllocator allocator;
   const unsigned dump_path_len = my_strlen(dump_path);
   const unsigned minidump_id_len = my_strlen(minidump_id);
   char *const path = reinterpret_cast<char*>(allocator.Alloc(
       dump_path_len + 1 /* '/' */ + minidump_id_len +
       4 /* ".dmp" */ + 1 /* NUL */));
   memcpy(path, dump_path, dump_path_len);
   path[dump_path_len] = '/';
   memcpy(path + dump_path_len + 1, minidump_id, minidump_id_len);
   memcpy(path + dump_path_len + 1 + minidump_id_len, ".dmp", 4);
   path[dump_path_len + 1 + minidump_id_len + 4] = 0;
 
   BreakpadInfo info;
   info.filename = path;
   info.process_type = "browser";
   info.process_type_length = 7;
   info.crash_url = NULL;
   info.crash_url_length = 0;
-  info.guid = google_update::posix_guid.data();
-  info.guid_length = google_update::posix_guid.length();
-  info.distro = base::linux_distro.data();
-  info.distro_length = base::linux_distro.length();
+  info.guid = child_process_logging::g_client_id;
+  info.guid_length = my_strlen(child_process_logging::g_client_id);
+  info.distro = base::g_linux_distro;
+  info.distro_length = my_strlen(base::g_linux_distro);
   info.upload = upload;
   HandleCrashDump(info);
 
   return true;
 }
 
 // Wrapper script, do not add more code here.
 static bool CrashDoneNoUpload(const char* dump_path,
                       const char* minidump_id,
                       void* context,
@@ skipping 16 matching lines @@
     PathService::Get(chrome::DIR_CRASH_DUMPS, &dumps_path);
     new google_breakpad::ExceptionHandler(dumps_path.value().c_str(), NULL,
                                           CrashDoneNoUpload, NULL,
                                           true /* install handlers */);
   } else {
     new google_breakpad::ExceptionHandler("/tmp", NULL, CrashDoneUpload, NULL,
                                           true /* install handlers */);
   }
 }
 
-// This is defined in chrome/common/child_process_logging_linux.cc, it's the
-// static string containing the current active URL. We send this in the crash
-// report.
-namespace child_process_logging {
-extern std::string active_url;
-}
-
 // Currently Non-Browser = Renderer and Plugins
 static bool
 NonBrowserCrashHandler(const void* crash_context, size_t crash_context_size,
                        void* context) {
   const int fd = reinterpret_cast<intptr_t>(context);
   int fds[2] = { -1, -1 };
   if (sys_socketpair(AF_UNIX, SOCK_STREAM, 0, fds) < 0) {
     static const char msg[] = "Failed to create socket for crash dumping.\n";
     sys_write(2, msg, sizeof(msg)-1);
     return false;
   }
   char guid[kGuidSize + 1] = {0};
   char crash_url[kMaxActiveURLSize + 1] = {0};
   char distro[kDistroSize + 1] = {0};
-  const size_t guid_len = std::min(google_update::posix_guid.size(),
-                                   kGuidSize);
+  const size_t guid_len =
+      std::min(my_strlen(child_process_logging::g_client_id), kGuidSize);
   const size_t crash_url_len =
-      std::min(child_process_logging::active_url.size(), kMaxActiveURLSize);
+      std::min(my_strlen(child_process_logging::g_active_url),
+               kMaxActiveURLSize);
   const size_t distro_len =
-      std::min(base::linux_distro.size(), kDistroSize);
-  memcpy(guid, google_update::posix_guid.data(), guid_len);
-  memcpy(crash_url, child_process_logging::active_url.data(), crash_url_len);
-  memcpy(distro, base::linux_distro.data(), distro_len);
+      std::min(my_strlen(base::g_linux_distro), kDistroSize);
+  memcpy(guid, child_process_logging::g_client_id, guid_len);
+  memcpy(crash_url, child_process_logging::g_active_url, crash_url_len);
+  memcpy(distro, base::g_linux_distro, distro_len);
 
   char b;  // Dummy variable for sys_read below.
   const char* b_addr = &b;  // Get the address of |b| so we can create the
                             // expected /proc/[pid]/syscall content in the
                             // browser to convert namespace tids.
 
   // The length of the control message:
   static const unsigned kControlMsgSize = CMSG_SPACE(2*sizeof(int));
 
   struct kernel_msghdr msg;
@@ skipping 67 matching lines @@
     // dir. Instead, we set a command line flag for these processes.
     // Even though plugins are not chrooted, we share the same code path for
     // simplicity.
     if (!parsed_command_line.HasSwitch(switches::kEnableCrashReporter))
       return;
     // Get the guid and linux distro from the command line switch.
     std::string switch_value =
         parsed_command_line.GetSwitchValueASCII(switches::kEnableCrashReporter);
     size_t separator = switch_value.find(",");
     if (separator != std::string::npos) {
-      google_update::posix_guid = switch_value.substr(0, separator);
-      base::linux_distro = switch_value.substr(separator + 1);
+      child_process_logging::SetClientId(switch_value.substr(0, separator));
+      base::SetLinuxDistro(switch_value.substr(separator + 1));
     } else {
-      google_update::posix_guid = switch_value;
+      child_process_logging::SetClientId(switch_value);
     }
     EnableNonBrowserCrashDumping();
   }
 
   // Set the base process uptime value.
   struct timeval tv;
   if (!gettimeofday(&tv, NULL))
     uptime = timeval_to_ms(&tv);
   else
     uptime = 0;
 }
 
 bool IsCrashReporterEnabled() {
   return is_crash_reporter_enabled;
 }