Include output of "lsb_release -d" in crash reports....

chrome/browser/renderer_host/render_crash_handler_host_linux.cc

 // Copyright (c) 2009 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 "chrome/browser/renderer_host/render_crash_handler_host_linux.h"
 
 #include <dirent.h>
 #include <stdint.h>
 #include <string.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <sys/uio.h>
 #include <unistd.h>
 
+#include <string>
 #include <vector>
 
 #include "base/eintr_wrapper.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
 #include "breakpad/linux/exception_handler.h"
 #include "breakpad/linux/linux_dumper.h"
@@ skipping 170 matching lines @@
   // block so that they can't lie about their pid.
 
   // The length of the control message:
   static const unsigned kControlMsgSize =
       CMSG_SPACE(sizeof(int)) + CMSG_SPACE(sizeof(struct ucred));
   // The length of the regular payload:
   static const unsigned kCrashContextSize =
       sizeof(google_breakpad::ExceptionHandler::CrashContext);
 
   struct msghdr msg = {0};
-  struct iovec iov[3];
+  struct iovec iov[4];
   char crash_context[kCrashContextSize];
   char guid[kGuidSize + 1];
   char crash_url[kMaxActiveURLSize + 1];
+  char distro[kDistroSize + 1];
   char control[kControlMsgSize];
   const ssize_t expected_msg_size = sizeof(crash_context) + sizeof(guid) +
-      sizeof(crash_url);
+      sizeof(crash_url) + sizeof(distro);
 
   iov[0].iov_base = crash_context;
   iov[0].iov_len = sizeof(crash_context);
   iov[1].iov_base = guid;
   iov[1].iov_len = sizeof(guid);
   iov[2].iov_base = crash_url;
   iov[2].iov_len = sizeof(crash_url);
+  iov[3].iov_base = distro;
+  iov[3].iov_len = sizeof(distro);
   msg.msg_iov = iov;
-  msg.msg_iovlen = 3;
+  msg.msg_iovlen = 4;
   msg.msg_control = control;
   msg.msg_controllen = kControlMsgSize;
 
   const ssize_t msg_size = HANDLE_EINTR(recvmsg(browser_socket_, &msg, 0));
   if (msg_size != expected_msg_size) {
     LOG(ERROR) << "Error reading from death signal socket. Crash dumping"
                << " is disabled."
                << " msg_size:" << msg_size
                << " errno:" << errno;
     file_descriptor_watcher_.StopWatchingFileDescriptor();
@@ skipping 13 matching lines @@
   // Walk the control payload an extract the file descriptor and validated pid.
   pid_t crashing_pid = -1;
   int signal_fd = -1;
   for (struct cmsghdr *hdr = CMSG_FIRSTHDR(&msg); hdr;
        hdr = CMSG_NXTHDR(&msg, hdr)) {
     if (hdr->cmsg_level != SOL_SOCKET)
       continue;
     if (hdr->cmsg_type == SCM_RIGHTS) {
       const unsigned len = hdr->cmsg_len -
           (((uint8_t*)CMSG_DATA(hdr)) - (uint8_t*)hdr);
-      DCHECK(len % sizeof(int) == 0);
+      DCHECK_EQ(len % sizeof(int), 0u);
       const unsigned num_fds = len / sizeof(int);
       if (num_fds > 1 || num_fds == 0) {
         // A nasty renderer could try and send us too many descriptors and
         // force a leak.
         LOG(ERROR) << "Death signal contained too many descriptors;"
                    << " num_fds:" << num_fds;
         for (unsigned i = 0; i < num_fds; ++i)
           HANDLE_EINTR(close(reinterpret_cast<int*>(CMSG_DATA(hdr))[i]));
         return;
       } else {
@@ skipping 48 matching lines @@
   memset(&msg, 0, sizeof(msg));
   struct iovec done_iov;
   done_iov.iov_base = const_cast<char*>("\x42");
   done_iov.iov_len = 1;
   msg.msg_iov = &done_iov;
   msg.msg_iovlen = 1;
 
   HANDLE_EINTR(sendmsg(signal_fd, &msg, MSG_DONTWAIT | MSG_NOSIGNAL));
   HANDLE_EINTR(close(signal_fd));
 
-  UploadCrashDump(minidump_filename.c_str(),
-                  "renderer", 8,
-                  crash_url, strlen(crash_url),
-                  guid, strlen(guid));
+  BreakpadInfo info;
+  info.filename = minidump_filename.c_str();
+  info.process_type = "renderer";
+  info.process_type_length = 8;
+  info.crash_url = crash_url;
+  info.crash_url_length = strlen(crash_url);
+  info.guid = guid;
+  info.guid_length = strlen(guid);
+  info.distro = distro;
+  info.distro_length = strlen(distro);
+  UploadCrashDump(info);
 }
 
 void RenderCrashHandlerHostLinux::WillDestroyCurrentMessageLoop() {
   file_descriptor_watcher_.StopWatchingFileDescriptor();
 }