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

chrome/browser/renderer_host/browser_render_process_host.cc

 // Copyright (c) 2006-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.
 
 // Represents the browser side of the browser <--> renderer communication
 // channel. There will be one RenderProcessHost per renderer process.
 
 #include "chrome/browser/renderer_host/browser_render_process_host.h"
 
 #include "build/build_config.h"
 
 #include <algorithm>
+#include <limits>
+#include <vector>
+
+#if defined(OS_POSIX)
+#include <utility>  // for pair<>
+#endif
 
 #include "app/app_switches.h"
-#if defined(OS_WIN)
-#include "app/win_util.h"
-#endif
 #include "base/command_line.h"
 #include "base/field_trial.h"
 #include "base/linked_ptr.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/rand_util.h"
 #include "base/scoped_ptr.h"
 #include "base/shared_memory.h"
 #include "base/singleton.h"
@@ skipping 19 matching lines @@
 #include "chrome/common/child_process_info.h"
 #include "chrome/common/logging_chrome.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/process_watcher.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/result_codes.h"
 #include "chrome/renderer/render_process.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "grit/generated_resources.h"
 
-#if defined(OS_LINUX)
+#if defined(OS_WIN)
+#include "app/win_util.h"
+#include "chrome/browser/sandbox_policy.h"
+#elif defined(OS_LINUX)
+#include "base/linux_util.h"
 #include "chrome/browser/zygote_host_linux.h"
 #include "chrome/browser/renderer_host/render_crash_handler_host_linux.h"
 #include "chrome/browser/renderer_host/render_sandbox_host_linux.h"
 #endif
 
 using WebKit::WebCache;
 
-#if defined(OS_WIN)
-
-// TODO(port): see comment by the only usage of RenderViewHost in this file.
-#include "chrome/browser/renderer_host/render_view_host.h"
-
-
-// Once the above TODO is finished, then this block is all Windows-specific
-// files.
-#include "base/win_util.h"
-#include "chrome/browser/sandbox_policy.h"
-#include "sandbox/src/sandbox.h"
-#elif defined(OS_POSIX)
-// TODO(port): Remove temporary scaffolding after porting the above headers.
-#include "chrome/common/temp_scaffolding_stubs.h"
-#endif
-
 #include "third_party/skia/include/core/SkBitmap.h"
 
 
 // This class creates the IO thread for the renderer when running in
 // single-process mode.  It's not used in multi-process mode.
 class RendererMainThread : public base::Thread {
  public:
   explicit RendererMainThread(const std::string& channel_id)
       : base::Thread("Chrome_InProcRendererThread"),
         channel_id_(channel_id),
@@ skipping 303 matching lines @@
     // launch the renderer child with some prefix (usually "gdb --args")
     const std::wstring prefix =
         browser_command_line.GetSwitchValue(switches::kRendererCmdPrefix);
     cmd_line.PrependWrapper(prefix);
   }
 #endif  // OS_POSIX
 
 #if defined(OS_LINUX)
   if (GoogleUpdateSettings::GetCollectStatsConsent())
     cmd_line.AppendSwitchWithValue(switches::kRendererCrashDump,
-                                   ASCIIToWide(google_update::linux_guid));
+                                   ASCIIToWide(google_update::linux_guid +
+                                               "," + base::GetLinuxDistro()));
 #endif
 
   cmd_line.AppendSwitchWithValue(switches::kProcessType,
                                  switches::kRendererProcess);
 
   cmd_line.AppendSwitchWithValue(switches::kProcessChannelID,
                                  ASCIIToWide(channel_id));
 
   const std::wstring& profile_path =
       browser_command_line.GetSwitchValue(switches::kUserDataDir);
@@ skipping 29 matching lines @@
       mapping.push_back(std::pair<uint32_t, int>(kPrimaryIPCChannel, ipcfd));
       const int crash_signal_fd =
           Singleton<RenderCrashHandlerHostLinux>()->GetDeathSignalSocket();
       if (crash_signal_fd >= 0) {
         mapping.push_back(std::pair<uint32_t, int>(kCrashDumpSignal,
                                                    crash_signal_fd));
       }
       process = Singleton<ZygoteHost>()->ForkRenderer(cmd_line.argv(), mapping);
       zygote_child_ = true;
     } else {
-#endif
+#endif  // defined(OS_LINUX)
       // NOTE: This code is duplicated with plugin_process_host.cc, but
       // there's not a good place to de-duplicate it.
       base::file_handle_mapping_vector fds_to_map;
       const int ipcfd = channel_->GetClientFileDescriptor();
       fds_to_map.push_back(std::make_pair(ipcfd, kPrimaryIPCChannel + 3));
 #if defined(OS_LINUX)
       const int crash_signal_fd =
           Singleton<RenderCrashHandlerHostLinux>()->GetDeathSignalSocket();
       if (crash_signal_fd >= 0) {
         fds_to_map.push_back(std::make_pair(crash_signal_fd,
                                             kCrashDumpSignal + 3));
       }
       const int sandbox_fd =
           Singleton<RenderSandboxHostLinux>()->GetRendererSocket();
       fds_to_map.push_back(std::make_pair(sandbox_fd, kSandboxIPCChannel + 3));
-#endif
+#endif  // defined(OS_LINUX)
       base::LaunchApp(cmd_line.argv(), fds_to_map, false, &process);
       zygote_child_ = false;
 #if defined(OS_LINUX)
     }
-#endif
-#endif
+#endif  // defined(OS_LINUX)
+#endif  // defined(OS_WIN)
 
     if (!process) {
       channel_.reset();
       return false;
     }
     process_.set_handle(process);
     SetProcessID(process_.pid());
   }
 
   resource_message_filter->Init(pid());
@@ skipping 33 matching lines @@
                                                IPC::Message* msg) {
   return widget_helper_->WaitForPaintMsg(render_widget_id, max_delay, msg);
 }
 
 void BrowserRenderProcessHost::ReceivedBadMessage(uint16 msg_type) {
   BadMessageTerminateProcess(msg_type, process_.handle());
 }
 
 void BrowserRenderProcessHost::WidgetRestored() {
   // Verify we were properly backgrounded.
-  DCHECK(backgrounded_ == (visible_widgets_ == 0));
+  DCHECK_EQ(backgrounded_, (visible_widgets_ == 0));
   visible_widgets_++;
   visited_link_updater_->Update(this);
   SetBackgrounded(false);
 }
 
 void BrowserRenderProcessHost::WidgetHidden() {
   // On startup, the browser will call Hide
   if (backgrounded_)
     return;
 
-  DCHECK(backgrounded_ == (visible_widgets_ == 0));
+  DCHECK_EQ(backgrounded_, (visible_widgets_ == 0));
   visible_widgets_--;
-  DCHECK(visible_widgets_ >= 0);
+  DCHECK_GE(visible_widgets_, 0);
   if (visible_widgets_ == 0) {
     DCHECK(!backgrounded_);
     SetBackgrounded(true);
   }
 }
 
 void BrowserRenderProcessHost::AddWord(const std::wstring& word) {
   base::Thread* io_thread = g_browser_process->io_thread();
   if (profile()->GetSpellChecker()) {
     io_thread->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
@@ skipping 357 matching lines @@
     bool should_set_backgrounded = true;
 
 #if defined(OS_WIN)
     // The cbstext.dll loads as a global GetMessage hook in the browser process
     // and intercepts/unintercepts the kernel32 API SetPriorityClass in a
     // background thread. If the UI thread invokes this API just when it is
     // intercepted the stack is messed up on return from the interceptor
     // which causes random crashes in the browser process. Our hack for now
     // is to not invoke the SetPriorityClass API if the dll is loaded.
     should_set_backgrounded = (GetModuleHandle(L"cbstext.dll") == NULL);
-#endif // OS_WIN
+#endif  // OS_WIN
 
     if (should_set_backgrounded) {
       bool rv = process_.SetProcessBackgrounded(backgrounded);
       if (!rv) {
         return;
       }
     }
 
     // Now tune the memory footprint of the renderer.
     // If the OS needs to page, we'd rather it page idle renderers.
@@ skipping 46 matching lines @@
 void BrowserRenderProcessHost::OnExtensionRemoveListener(
     const std::string& event_name) {
   ExtensionMessageService::GetInstance(profile()->GetRequestContext())->
       RemoveEventListener(event_name, pid());
 }
 
 void BrowserRenderProcessHost::OnExtensionCloseChannel(int port_id) {
   ExtensionMessageService::GetInstance(profile()->GetRequestContext())->
       CloseChannel(port_id);
 }