Add support for multiple browser instances reliability tests.

chrome/tools/crash_service/crash_service.cc

 // 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 "chrome/tools/crash_service/crash_service.h"
 
 #include <windows.h>
 
 #include <fstream>
 #include <map>
 #include <sddl.h>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
+#include "base/string_number_conversions.h"
 #include "base/win/windows_version.h"
 #include "breakpad/src/client/windows/crash_generation/client_info.h"
 #include "breakpad/src/client/windows/crash_generation/crash_generation_server.h"
 #include "breakpad/src/client/windows/sender/crash_report_sender.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 
 namespace {
 
 const wchar_t kTestPipeName[] = L"\\\\.\\pipe\\ChromeCrashServices";
@@ skipping 112 matching lines @@
 
   DumpJobInfo(DWORD process_id, CrashService* service,
               const CrashMap& crash_map, const std::wstring& path)
       : pid(process_id), self(service), map(crash_map), dump_path(path) {
   }
 };
 
 }  // namespace
 
 // Command line switches:
-const char CrashService::kMaxReports[]  = "max-reports";
-const char CrashService::kNoWindow[]    = "no-window";
-const char CrashService::kReporterTag[] = "reporter";
-const char CrashService::kDumpsDir[]    = "dumps-dir";
-const char CrashService::kPipeName[]    = "pipe-name";
+const char CrashService::kMaxReports[]        = "max-reports";
+const char CrashService::kNoWindow[]          = "no-window";
+const char CrashService::kReporterTag[]       = "reporter";
+const char CrashService::kDumpsDir[]          = "dumps-dir";
+const char CrashService::kPipeName[]          = "pipe-name";
+const char CrashService::kArchiveDumpsByPid[] = "archive-dumps-by-pid";
+
+bool CrashService::archive_dumps_by_pid_ = false;
 
 CrashService::CrashService(const std::wstring& report_dir)
     : report_path_(report_dir),
       sender_(NULL),
       dumper_(NULL),
       requests_handled_(0),
       requests_sent_(0),
       clients_connected_(0),
       clients_terminated_(0) {
   chrome::RegisterPathProvider();
@@ skipping 32 matching lines @@
   FilePath dumps_path;
   if (cmd_line.HasSwitch(kDumpsDir)) {
     dumps_path = FilePath(cmd_line.GetSwitchValueNative(kDumpsDir));
   } else {
     if (!PathService::Get(chrome::DIR_CRASH_DUMPS, &dumps_path)) {
       LOG(ERROR) << "could not get DIR_CRASH_DUMPS";
       return false;
     }
   }
 
+  if (cmd_line.HasSwitch(kArchiveDumpsByPid))
+    archive_dumps_by_pid_ = true;
+
   // We can override the send reports quota with a command line switch.
   if (cmd_line.HasSwitch(kMaxReports))
     max_reports = _wtoi(cmd_line.GetSwitchValueNative(kMaxReports).c_str());
 
   // Allow the global pipe name to be overridden for better testability.
   if (cmd_line.HasSwitch(kPipeName))
     pipe_name = cmd_line.GetSwitchValueNative(kPipeName);
 
 #ifdef _WIN64
   pipe_name += L"-x64";
@@ skipping 148 matching lines @@
     return;
   }
 
   CrashMap map;
   CustomInfoToMap(client_info, self->reporter_tag_, &map);
 
   if (!WriteCustomInfoToFile(*file_path, map)) {
     LOG(ERROR) << "could not write custom info file";
   }
 
+  // Move dump file to the directory under client pid.
+  FilePath dump_path = FilePath(*file_path);
+  if (archive_dumps_by_pid_) {
+    FilePath dump_path_with_pid(dump_path.DirName());
+    dump_path_with_pid = dump_path_with_pid.Append(base::Int64ToString16(pid));
+    file_util::CreateDirectoryW(dump_path_with_pid);
+    dump_path_with_pid = dump_path_with_pid.Append(dump_path.BaseName());
+    file_util::Move(dump_path, dump_path_with_pid);
+  }
+
   if (!self->sender_)
     return;
 
   // Send the crash dump using a worker thread. This operation has retry
   // logic in case there is no internet connection at the time.
-  DumpJobInfo* dump_job = new DumpJobInfo(pid, self, map, *file_path);
+  DumpJobInfo* dump_job = new DumpJobInfo(pid, self, map,
+                                          dump_path.value());
   if (!::QueueUserWorkItem(&CrashService::AsyncSendDump,
                            dump_job, WT_EXECUTELONGFUNCTION)) {
     LOG(ERROR) << "could not queue job";
   }
 }
 
 // We are going to try sending the report several times. If we can't send,
 // we sleep from one minute to several hours depending on the retry round.
 unsigned long CrashService::AsyncSendDump(void* context) {
   if (!context)
@@ skipping 95 matching lines @@
                                                              SDDL_REVISION,
                                                              &sec_desc, NULL)) {
     if (::GetSecurityDescriptorSacl(sec_desc, &sacl_present, &sacl,
                                     &sacl_defaulted)) {
       return sec_desc;
     }
   }
 
   return NULL;
 }