Changing page_cycler_test to allow us to run all DB perf tests in the...

chrome/test/page_cycler/page_cycler_test.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.
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/eintr_wrapper.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
@@ skipping 133 matching lines @@
         }
         HANDLE_EINTR(close(fd));
       }
     }
   }
   LOG(INFO) << "UBC should be loaded with " << loaded << " files.";
 }
 #endif  // defined(OS_MACOSX)
 
 class PageCyclerTest : public UITest {
+ protected:
+  bool print_times_only_;
 #if defined(OS_MACOSX)
- protected:
   rlim_t fd_limit_;
 #endif
  public:
-  PageCyclerTest() {
+  PageCyclerTest()
+      : print_times_only_(false) {
     show_window_ = true;
 
+
     // Expose garbage collection for the page cycler tests.
     launch_arguments_.AppendSwitchWithValue(switches::kJavaScriptFlags,
                                             L"--expose_gc");
 #if defined(OS_MACOSX)
     static rlim_t initial_fd_limit = GetFileDescriptorLimit();
     fd_limit_ = initial_fd_limit;
 #endif
   }
 
   void SetUp() {
@@ skipping 58 matching lines @@
     ASSERT_FALSE(pages->empty());
     ASSERT_TRUE(tab->GetCookieByName(test_url, "__pc_timings", &cookie));
     timings->assign(cookie);
     ASSERT_FALSE(timings->empty());
   }
 
   // When use_http is true, the test name passed here will be used directly in
   // the path to the test data, so it must be safe for use in a URL without
   // escaping. (No pound (#), question mark (?), semicolon (;), non-ASCII, or
   // other funny stuff.)
-  void RunTestWithSuffix(const char* name, bool use_http, const char* suffix) {
+  void RunTestWithSuffix(const char* graph, const char* name, bool use_http,
+                         const char* suffix) {
     std::wstring pages;
     std::string timings;
     size_t start_size = base::GetSystemCommitCharge();
     RunPageCycler(name, &pages, &timings, use_http);
     if (timings.empty() || HasErrors(timings))
       return;
     size_t stop_size = base::GetSystemCommitCharge();
 
-    PrintMemoryUsageInfo(suffix);
-    PrintIOPerfInfo(suffix);
-    PrintSystemCommitCharge(suffix, stop_size - start_size,
-                            false /* not important */);
+    if (!print_times_only_) {
+      PrintMemoryUsageInfo(suffix);
+      PrintIOPerfInfo(suffix);
+      PrintSystemCommitCharge(suffix, stop_size - start_size,
+                              false /* not important */);
+    }
 
     std::string trace_name = "t" + std::string(suffix);
     wprintf(L"\nPages: [%ls]\n", pages.c_str());
-    PrintResultList("times", "", trace_name, timings, "ms",
+    PrintResultList(graph, "", trace_name, timings, "ms",
                     true /* important */);
   }
 
-  void RunTest(const char* name, bool use_http) {
-    RunTestWithSuffix(name, use_http, "");
+  void RunTest(const char* graph, const char* name, bool use_http) {
+    RunTestWithSuffix(graph, name, use_http, "");
   }
 };
 
 class PageCyclerReferenceTest : public PageCyclerTest {
  public:
   // override the browser directory that is used by UITest::SetUp to cause it
   // to use the reference build instead.
   void SetUp() {
 #if defined(OS_MACOSX)
     fd_limit_ = 1024;
 #endif
 
     FilePath dir;
     PathService::Get(chrome::DIR_TEST_TOOLS, &dir);
     dir = dir.AppendASCII("reference_build");
 #if defined(OS_WIN)
     dir = dir.AppendASCII("chrome");
 #elif defined(OS_LINUX)
     dir = dir.AppendASCII("chrome_linux");
 #elif defined(OS_MACOSX)
     dir = dir.AppendASCII("chrome_mac");
 #endif
     browser_directory_ = dir;
     PageCyclerTest::SetUp();
   }
 
-  void RunTest(const char* name, bool use_http) {
+  void RunTest(const char* graph, const char* name, bool use_http) {
     std::wstring pages;
     std::string timings;
     size_t start_size = base::GetSystemCommitCharge();
     RunPageCycler(name, &pages, &timings, use_http);
     if (timings.empty())
       return;
     size_t stop_size = base::GetSystemCommitCharge();
 
-    PrintMemoryUsageInfo("_ref");
-    PrintIOPerfInfo("_ref");
-    PrintSystemCommitCharge("_ref", stop_size - start_size,
-                            false /* not important */);
+    if (!print_times_only_) {
+      PrintMemoryUsageInfo("_ref");
+      PrintIOPerfInfo("_ref");
+      PrintSystemCommitCharge("_ref", stop_size - start_size,
+                              false /* not important */);
+    }
 
-    PrintResultList("times", "", "t_ref", timings, "ms",
+    PrintResultList(graph, "", "t_ref", timings, "ms",
                     true /* important */);
   }
 };
 
 class PageCyclerExtensionTest : public PageCyclerTest {
  public:
   void SetUp() {}
-  void RunTest(const char* extension_profile, const char* output_suffix,
-               const char* name, bool use_http) {
+  void RunTest(const char* graph, const char* extension_profile,
+               const char* output_suffix, const char* name, bool use_http) {
     // Set up the extension profile directory.
     ASSERT_TRUE(extension_profile != NULL);
     FilePath data_dir;
     PathService::Get(chrome::DIR_TEST_DATA, &data_dir);
     data_dir = data_dir.AppendASCII("extensions").AppendASCII("profiles").
         AppendASCII(extension_profile);
     ASSERT_TRUE(file_util::DirectoryExists(data_dir));
     set_template_user_data(data_dir);
 
     // Now run the test.
     PageCyclerTest::SetUp();
-    PageCyclerTest::RunTestWithSuffix(name, use_http, output_suffix);
+    PageCyclerTest::RunTestWithSuffix(graph, name, use_http, output_suffix);
   }
 };
 
 static FilePath GetDatabaseDataPath(const char* name) {
   FilePath test_path;
   PathService::Get(base::DIR_SOURCE_ROOT, &test_path);
   test_path = test_path.Append(FILE_PATH_LITERAL("tools"));
   test_path = test_path.Append(FILE_PATH_LITERAL("page_cycler"));
   test_path = test_path.Append(FILE_PATH_LITERAL("database"));
   test_path = test_path.AppendASCII(name);
@@ skipping 32 matching lines @@
     }
 
     pos = new_pos + 1;
   } while (pos < timings.length());
 
   return false;
 }
 
 class PageCyclerDatabaseTest : public PageCyclerTest {
  public:
+  PageCyclerDatabaseTest() {
+    print_times_only_ = true;
+  }
+
   virtual FilePath GetDataPath(const char* name) {
     return GetDatabaseDataPath(name);
   }
 
   virtual bool HasErrors(const std::string timings) {
     return HasDatabaseErrors(timings);
   }
 };
 
 class PageCyclerDatabaseReferenceTest : public PageCyclerReferenceTest {
  public:
+  PageCyclerDatabaseReferenceTest() {
+    print_times_only_ = true;
+  }
+
   virtual FilePath GetDataPath(const char* name) {
     return GetDatabaseDataPath(name);
   }
 
   virtual bool HasErrors(const std::string timings) {
     return HasDatabaseErrors(timings);
   }
 };
 
 // This macro simplifies setting up regular and reference build tests.
 #define PAGE_CYCLER_TESTS(test, name, use_http) \
 TEST_F(PageCyclerTest, name) { \
-  RunTest(test, use_http); \
+  RunTest("times", test, use_http); \
 } \
 TEST_F(PageCyclerReferenceTest, name) { \
-  RunTest(test, use_http); \
+  RunTest("times", test, use_http); \
 }
 
 // This macro simplifies setting up regular and reference build tests
 // for HTML5 database tests.
 #define PAGE_CYCLER_DATABASE_TESTS(test, name) \
-TEST_F(PageCyclerDatabaseTest, name) { \
-  RunTest(test, false); \
+TEST_F(PageCyclerDatabaseTest, Database##name##File) { \
+  RunTest(test, test, false); \
 } \
-TEST_F(PageCyclerDatabaseReferenceTest, name) { \
-  RunTest(test, false); \
+TEST_F(PageCyclerDatabaseReferenceTest, Database##name##File) { \
+  RunTest(test, test, false); \
 }
 
 // These are shorthand for File vs. Http tests.
-#define PAGE_CYCLER_FILE_TESTS(test, name)\
+#define PAGE_CYCLER_FILE_TESTS(test, name) \
   PAGE_CYCLER_TESTS(test, name, false)
-#define PAGE_CYCLER_HTTP_TESTS(test, name)\
+#define PAGE_CYCLER_HTTP_TESTS(test, name) \
   PAGE_CYCLER_TESTS(test, name, true)
 
 // This macro lets us define tests with 1 and 10 extensions with 1 content
 // script each. The name for the 10-extension case is changed so as not
 // to run by default on the buildbots.
 #define PAGE_CYCLER_EXTENSIONS_FILE_TESTS(test, name) \
-TEST_F(PageCyclerExtensionTest, name) {  \
-  RunTest("content_scripts1", "_extcs1", test, false); \
+TEST_F(PageCyclerExtensionTest, name) { \
+  RunTest("times", "content_scripts1", "_extcs1", test, false); \
 } \
 TEST_F(PageCyclerExtensionTest, name##10) { \
-  RunTest("content_scripts10", "_extcs10", test, false); \
+  RunTest("times", "content_scripts10", "_extcs10", test, false); \
 }
 
 // file-URL tests
 PAGE_CYCLER_FILE_TESTS("moz", MozFile);
 PAGE_CYCLER_EXTENSIONS_FILE_TESTS("moz", MozFile);
 PAGE_CYCLER_FILE_TESTS("intl1", Intl1File);
 PAGE_CYCLER_FILE_TESTS("intl2", Intl2File);
 PAGE_CYCLER_FILE_TESTS("dom", DomFile);
 PAGE_CYCLER_FILE_TESTS("dhtml", DhtmlFile);
 PAGE_CYCLER_FILE_TESTS("morejs", MorejsFile);
@@ skipping 16 matching lines @@
 PAGE_CYCLER_DATABASE_TESTS("insert-transactions",
                            InsertTransactions);
 PAGE_CYCLER_DATABASE_TESTS("update-transactions",
                            UpdateTransactions);
 PAGE_CYCLER_DATABASE_TESTS("delete-transactions",
                            DeleteTransactions);
 PAGE_CYCLER_DATABASE_TESTS("pseudo-random-transactions",
                            PseudoRandomTransactions);
 
 }  // namespace