Add support for multiple browser instances reliability tests.

chrome/test/reliability/page_load_test.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.
 //
 // This file provides reliablity test which runs under UI test framework. The
 // test is intended to run within QEMU environment.
 //
 // Usage 1: reliability_test
 // Upon invocation, it visits a hard coded list of sample URLs. This is mainly
 // used by buildbot, to verify reliability_test itself runs ok.
@@ skipping 13 matching lines @@
 // --iterations=num: goes through the list of URLs constructed in usage 2 or 3
 //                   num times.
 // --continuousload: continuously visits the list of URLs without restarting
 //                    browser for each page load.
 // --memoryusage: prints out memory usage when visiting each page.
 // --endurl=url: visits the specified url in the end.
 // --logfile=filepath: saves the visit log to the specified path.
 // --nopagedown: won't simulate page down key presses after page load.
 // --noclearprofile: do not clear profile dir before firing up each time.
 // --savedebuglog: save Chrome, V8, and test debug log for each page loaded.
+// --searchdumpsbypid: Look for crash dumps by browser process id.
+//                     "crash_dir/pid/"
 
 #include <fstream>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/file_version_info.h"
 #include "base/i18n/time_formatting.h"
@@ skipping 14 matching lines @@
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/json_pref_store.h"
 #include "chrome/common/logging_chrome.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/automation/automation_proxy.h"
 #include "chrome/test/automation/browser_proxy.h"
 #include "chrome/test/automation/tab_proxy.h"
 #include "chrome/test/automation/window_proxy.h"
+#include "chrome/test/base/chrome_process_util.h"
 #include "chrome/test/ui/ui_test.h"
 #include "net/base/net_util.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "v8/include/v8-testing.h"
 
 namespace {
 
 // See comments at the beginning of the file for the definition of switches.
 const char kSiteSwitch[] = "site";
 const char kStartPageSwitch[] = "startpage";
 const char kEndPageSwitch[] = "endpage";
 const char kListSwitch[] = "list";
 const char kStartIndexSwitch[] = "startline";
 const char kEndIndexSwitch[] = "endline";
 const char kIterationSwitch[] = "iterations";
 const char kContinuousLoadSwitch[] = "continuousload";
 const char kMemoryUsageSwitch[] = "memoryusage";
 const char kEndURLSwitch[] = "endurl";
 const char kLogFileSwitch[] = "logfile";
 const char kNoPageDownSwitch[] = "nopagedown";
 const char kNoClearProfileSwitch[] = "noclearprofile";
 const char kSaveDebugLogSwitch[] = "savedebuglog";
 const char kStressOptSwitch[] = "stress-opt";
 const char kStressDeoptSwitch[] = "stress-deopt";
+const char kSearchDumpsByPid[] = "search-dumps-by-pid";
 
 const char kDefaultServerUrl[] = "http://urllist.com";
 std::string g_server_url;
 const char kTestPage1[] = "page1.html";
 const char kTestPage2[] = "page2.html";
 
 // These are copied from v8 definitions as we cannot include them.
 const char kV8LogFileSwitch[] = "logfile";
 const char kV8LogFileDefaultName[] = "v8.log";
 
@@ skipping 11 matching lines @@
 bool g_continuous_load = false;
 bool g_browser_existing = false;
 bool g_page_down = true;
 bool g_clear_profile = true;
 std::string g_end_url;
 FilePath g_log_file_path;
 bool g_save_debug_log = false;
 FilePath g_chrome_log_path;
 FilePath g_v8_log_path;
 FilePath g_test_log_path;
 bool g_stand_alone = false;

[sky, 2012/11/02 15:03:04]

None of the these are global. They shouldn't have g_. You can fix that
separately if you want.

 bool g_stress_opt = false;
 bool g_stress_deopt = false;
+bool g_search_dumps_by_pid = false;
 
 void ReportHandler(const std::string& str) {
   // Ignore report events.
 }
 
 void SetPageRange(const CommandLine& parsed_command_line) {
   // If calling into this function, we are running as a standalone program.
   g_stand_alone = true;
 
   // Since we use --enable-dcheck for reliability tests, suppress the error
@@ skipping 81 matching lines @@
             parsed_command_line.GetSwitchValuePath(switches::kJavaScriptFlags));
         if (v8_command_line.HasSwitch(kV8LogFileSwitch)) {
           g_v8_log_path = v8_command_line.GetSwitchValuePath(kV8LogFileSwitch);
           if (!file_util::AbsolutePath(&g_v8_log_path))
             g_v8_log_path = FilePath();
         }
       }
     }
   }
 
-  if (parsed_command_line.HasSwitch(kStressOptSwitch)) {
+  if (parsed_command_line.HasSwitch(kStressOptSwitch))
     g_stress_opt = true;
-  }
-  if (parsed_command_line.HasSwitch(kStressDeoptSwitch)) {
+
+  if (parsed_command_line.HasSwitch(kStressDeoptSwitch))
     g_stress_deopt = true;
-  }
+
+  if (parsed_command_line.HasSwitch(kSearchDumpsByPid))
+    g_search_dumps_by_pid = true;
 }
 
 class PageLoadTest : public UITest {
  public:
   enum NavigationResult {
     NAVIGATION_ERROR = 0,
     NAVIGATION_SUCCESS,
     NAVIGATION_AUTH_NEEDED,
     NAVIGATION_TIME_OUT,
   };
@@ skipping 73 matching lines @@
     test_log << base::TimeFormatFriendlyDateAndTime(time_now) << std::endl;
 
     // Make sure the browser is running.
     EnsureBrowserAndServer();
 
     // Log Browser Launched time.
     time_now = base::Time::Now();
     test_log << "browser_launched_seconds=";
     test_log << (time_now.ToDoubleT() - time_start) << std::endl;
 
+    // Create crash dump directory with pid.
+    if (g_search_dumps_by_pid) {
+      actual_crash_dumps_dir_path_ = FilePath(crash_dumps_dir_path_);
+      ChromeProcessList processes =
+          GetRunningChromeProcesses(browser_process_id());
+      if (!processes.empty())
+        actual_crash_dumps_dir_path_ = actual_crash_dumps_dir_path_.Append(
+            base::Int64ToString16(*processes.begin()));
+    }
+
     int result = AUTOMATION_MSG_NAVIGATION_ERROR;
     // This is essentially what NavigateToURL does except we don't fire
     // assertion when page loading fails. We log the result instead.
     {
       // TabProxy should be released before Browser is closed.
       scoped_refptr<TabProxy> tab_proxy(GetActiveTab());
       if (tab_proxy.get())
         result = tab_proxy->NavigateToURL(url);
 
       if (result == AUTOMATION_MSG_NAVIGATION_SUCCESS) {
@@ skipping 350 matching lines @@
     FilePath crash_dump_file_path(crash_dumps_dir_path_);
     crash_dump_file_path = crash_dump_file_path.Append(crash_dump_file_name);
     FilePath crash_text_file_path =
         crash_dump_file_path.ReplaceExtension(FILE_PATH_LITERAL("txt"));
 
     ASSERT_TRUE(file_util::DieFileDie(crash_dump_file_path, false));
     ASSERT_TRUE(file_util::DieFileDie(crash_text_file_path, false));
   }
 
   bool HasNewCrashDumps() {
-    file_util::FileEnumerator enumerator(crash_dumps_dir_path_,
+    file_util::FileEnumerator enumerator(actual_crash_dumps_dir_path_,
                                          false,  // not recursive
                                          file_util::FileEnumerator::FILES);
     for (FilePath path = enumerator.Next(); !path.value().empty();
          path = enumerator.Next()) {
       if (path.MatchesExtension(FILE_PATH_LITERAL(".dmp")) &&
           !crash_dumps_[path.BaseName()]) {
         return true;
       }
     }
 
     return false;
   }
 
   // Check whether there are new .dmp files. Return the list and optionally
   // delete them afterwards.
   void CollectNewCrashDumps(std::vector<FilePath>& new_crash_dumps,
                             NavigationMetrics* metrics,
                             bool delete_dumps) {
     int num_dumps = 0;
-
-    file_util::FileEnumerator enumerator(crash_dumps_dir_path_,
+    file_util::FileEnumerator enumerator(actual_crash_dumps_dir_path_,
                                          false,  // not recursive
                                          file_util::FileEnumerator::FILES);
     for (FilePath path = enumerator.Next(); !path.value().empty();
          path = enumerator.Next()) {
       if (path.MatchesExtension(FILE_PATH_LITERAL(".dmp")) &&
           !crash_dumps_[path.BaseName()]) {
         crash_dumps_[path.BaseName()] = true;
-        FilePath crash_dump_file_path(crash_dumps_dir_path_);
+        FilePath crash_dump_file_path(actual_crash_dumps_dir_path_);
         crash_dump_file_path = crash_dump_file_path.Append(path.BaseName());
         new_crash_dumps.push_back(crash_dump_file_path);
         if (delete_dumps)
           DeleteCrashDump(path.BaseName());
         num_dumps++;
       }
     }
     if (metrics)
       metrics->crash_dump_count = num_dumps;
   }
@@ skipping 39 matching lines @@
     FilePath test_dir;
     PathService::Get(chrome::DIR_TEST_DATA, &test_dir);
     test_dir = test_dir.AppendASCII("reliability");
     test_dir = test_dir.AppendASCII("sample_pages");
     return test_dir;
   }
 
   // The pathname of Chrome's crash dumps directory.
   FilePath crash_dumps_dir_path_;
 
+  // The actual crash dumps directory that will be used.
+  FilePath actual_crash_dumps_dir_path_;
+
   // The set of all the crash dumps we have seen.  Each crash generates a
   // .dmp and a .txt file in the crash dumps directory.  We only store the
   // .dmp files in this set.
   //
   // The set is implemented as a std::map.  The key is the file name, and
   // the value is false (the file is not in the set) or true (the file is
   // in the set).  The initial value for any key in std::map is 0 (false),
   // which in this case means a new file is not in the set initially,
   // exactly the semantics we want.
   std::map<FilePath, bool> crash_dumps_;
@@ skipping 17 matching lines @@
   if (!g_end_url.empty()) {
     NavigateToURLLogResult(
         g_end_url, log_file, NULL, g_continuous_load, false);
   }
 
   log_file.close();
 }
 
 }  // namespace