Add Web Page Replay test to page cycler.

chrome/test/perf/page_cycler_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.
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
@@ skipping 11 matching lines @@
 #include "chrome/test/base/chrome_process_util.h"
 #include "chrome/test/base/test_switches.h"
 #include "chrome/test/perf/perf_test.h"
 #include "chrome/test/ui/ui_perf_test.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.h"
 
 #ifndef NDEBUG
 static const int kTestIterations = 2;
 static const int kDatabaseTestIterations = 2;
+static const int kWebPageReplayIterations = 2;
 #else
 static const int kTestIterations = 10;
 // For some unknown reason, the DB perf tests are much much slower on the
 // Vista perf bot, so we have to cut down the number of iterations to 5
 // to make sure each test finishes in less than 10 minutes.
 static const int kDatabaseTestIterations = 5;
+static const int kWebPageReplayIterations = 5;
 #endif
 static const int kIDBTestIterations = 5;
 
 // URL at which data files may be found for HTTP tests.  The document root of
 // this URL's server should point to data/page_cycler/.
 static const char kBaseUrl[] = "http://localhost:8000/";
 
+// The following port numbers must match those in
+//     src/tools/python/google/webpagereplay_utils.py.
+static const char kWebPageReplayHttpPort[] = "8080";
+static const char kWebPageReplayHttpsPort[] = "8413";
+
 namespace {
 
 void PopulateBufferCache(const FilePath& test_dir) {
   // This will recursively walk the directory given and read all the
   // files it finds.  This is done so the system file cache is likely
   // to have as much loaded as possible.  Without this, the tests of
   // this build gets one set of timings and then the reference build
   // test, gets slightly faster ones (even if the reference build is
   // the same binary).  The hope is by forcing all the possible data
   // into the cache we equalize the tests for comparing timing data.
@@ skipping 96 matching lines @@
   }
 
   virtual bool HasErrors(const std::string /*timings*/) {
     return false;
   }
 
   virtual int GetTestIterations() {
     return num_test_iterations_;
   }
 
-  // For HTTP tests, the name must be safe for use in a URL without escaping.
-  void RunPageCycler(const char* name, std::wstring* pages,
-                     std::string* timings, bool use_http) {
+  virtual void GetTestUrl(const char* name, bool use_http, GURL *test_url) {
     FilePath test_path = GetDataPath(name);
     ASSERT_TRUE(file_util::DirectoryExists(test_path))
         << "Missing test directory " << test_path.value();
-
     PopulateBufferCache(test_path);
 
-    GURL test_url;
     if (use_http) {
-      test_url = GURL(std::string(kBaseUrl) + name + "/start.html");
+      *test_url = GURL(std::string(kBaseUrl) + name + "/start.html");
     } else {
       test_path = test_path.Append(FILE_PATH_LITERAL("start.html"));
-      test_url = net::FilePathToFileURL(test_path);
+      *test_url = net::FilePathToFileURL(test_path);
     }
 
     // run N iterations
     GURL::Replacements replacements;
     const std::string query_string =
         "iterations=" + base::IntToString(GetTestIterations()) + "&auto=1";
     replacements.SetQuery(
         query_string.c_str(),
         url_parse::Component(0, query_string.length()));
-    test_url = test_url.ReplaceComponents(replacements);
+    *test_url = test_url->ReplaceComponents(replacements);
+  }
+
+  // For HTTP tests, the name must be safe for use in a URL without escaping.
+  void RunPageCycler(const char* name, std::wstring* pages,
+                     std::string* timings, bool use_http) {
+    GURL test_url;
+    GetTestUrl(name, use_http, &test_url);
 
     scoped_refptr<TabProxy> tab(GetActiveTab());
     ASSERT_TRUE(tab.get());
     ASSERT_EQ(AUTOMATION_MSG_NAVIGATION_SUCCESS, tab->NavigateToURL(test_url));
 
     // Wait for the test to finish.
     ASSERT_TRUE(WaitUntilCookieValue(
         tab.get(), test_url, "__pc_done",
         TestTimeouts::large_test_timeout_ms(), "1"));
 
@@ skipping 240 matching lines @@
 
   virtual bool HasErrors(const std::string timings) {
     return HasDatabaseErrors(timings);
   }
 
   virtual int GetTestIterations() {
     return kIDBTestIterations;
   }
 };
 
+// Web Page Replay is a proxy server to record and serve pages
+// with realistic network delays and bandwidth throttling.
+// runtest.py launches replay.py to support these tests.
+class PageCyclerWebPageReplayTest : public PageCyclerTest {
+ public:
+  PageCyclerWebPageReplayTest() {
+    // These Chrome command-line arguments need to be kept in sync
+    // with src/tools/python/google/webpagereplay_utils.py.
+    FilePath extension_path = GetPageCyclerWprPath("extension");
+    launch_arguments_.AppendSwitchPath(
+        switches::kLoadExtension, extension_path);
+    // TODO(slamm): Instead of kHostResolverRules, add a new switch,
+    //     kTestingFixedDnsPort, and configure Web Page Replay to run
+    //     a DNS proxy on that port to test Chrome's DNS code.
+    launch_arguments_.AppendSwitchASCII(
+        switches::kHostResolverRules, "MAP * 127.0.0.1");
+    launch_arguments_.AppendSwitchASCII(
+        switches::kTestingFixedHttpPort, kWebPageReplayHttpPort);
+    launch_arguments_.AppendSwitchASCII(
+        switches::kTestingFixedHttpsPort, kWebPageReplayHttpsPort);
+    launch_arguments_.AppendSwitch(switches::kEnableExperimentalExtensionApis);
+    launch_arguments_.AppendSwitch(switches::kEnableStatsTable);
+    launch_arguments_.AppendSwitch(switches::kEnableBenchmarking);
+    launch_arguments_.AppendSwitch(switches::kIgnoreCertificateErrors);
+    launch_arguments_.AppendSwitch(switches::kNoProxyServer);
+  }
+
+  FilePath GetPageCyclerWprPath(const char* name) {
+    FilePath wpr_path;
+    PathService::Get(base::DIR_SOURCE_ROOT, &wpr_path);
+    wpr_path = wpr_path.AppendASCII("tools");
+    wpr_path = wpr_path.AppendASCII("page_cycler");
+    wpr_path = wpr_path.AppendASCII("webpagereplay");
+    wpr_path = wpr_path.AppendASCII(name);
+    return wpr_path;
+  }
+
+  virtual int GetTestIterations() OVERRIDE {
+    return kWebPageReplayIterations;
+  }
+
+  virtual void GetTestUrl(const char* name, bool use_http,
+                          GURL *test_url) OVERRIDE {
+    FilePath start_path = GetPageCyclerWprPath("start.html");
+
+    // Add query parameters for iterations and test name.
+    const std::string query_string =
+        "iterations=" + base::IntToString(GetTestIterations()) +
+        "&test=" + name +
+        "&auto=1";
+    GURL::Replacements replacements;
+    replacements.SetQuery(
+        query_string.c_str(),
+        url_parse::Component(0, query_string.length()));
+
+    *test_url = net::FilePathToFileURL(start_path);
+    *test_url = test_url->ReplaceComponents(replacements);
+  }
+
+  void RunTest(const char* graph, const char* name) {
+    FilePath test_path = GetPageCyclerWprPath("tests");
+    test_path = test_path.AppendASCII(name);
+    test_path = test_path.ReplaceExtension(FILE_PATH_LITERAL(".js"));
+    ASSERT_TRUE(file_util::PathExists(test_path))
+        << "Missing test file " << test_path.value();
+
+    const bool use_http = false;  // always use a file
+    PageCyclerTest::RunTestWithSuffix(graph, name, use_http, "");
+  }
+};
+
 // This macro simplifies setting up regular and reference build tests.
 #define PAGE_CYCLER_TESTS(test, name, use_http) \
 TEST_F(PageCyclerTest, name) { \
   RunTest("times", test, use_http); \
 } \
 TEST_F(PageCyclerReferenceTest, name) { \
   RunTest("times", test, use_http); \
 }
 
 // This macro simplifies setting up regular and reference build tests
@@ skipping 34 matching lines @@
 }
 
 // This macro lets us define tests with an extension that listens to the
 // webrequest.onBeforeRequest. It measures the effect that a blocking event
 // for every request has on page cycle time.
 #define PAGE_CYCLER_EXTENSIONS_WEBREQUEST_FILE_TESTS(test, name) \
 TEST_F(PageCyclerExtensionWebRequestTest, name) { \
   RunTest("times", "extension_webrequest", "_extwr", test, false); \
 }
 
+#define PAGE_CYCLER_WEBPAGEREPLAY_TESTS(test, name) \
+TEST_F(PageCyclerWebPageReplayTest, name) { \
+  RunTest("times", test); \
+}
+
 // file-URL tests
 PAGE_CYCLER_FILE_TESTS("moz", MozFile);
 PAGE_CYCLER_EXTENSIONS_FILE_TESTS("moz", MozFile);
 PAGE_CYCLER_EXTENSIONS_WEBREQUEST_FILE_TESTS("moz", MozFile)
 PAGE_CYCLER_FILE_TESTS("intl1", Intl1File);
 PAGE_CYCLER_FILE_TESTS("intl2", Intl2File);
 PAGE_CYCLER_EXTENSIONS_WEBREQUEST_FILE_TESTS("intl2", Intl2File);
 PAGE_CYCLER_FILE_TESTS("dom", DomFile);
 PAGE_CYCLER_FILE_TESTS("dhtml", DhtmlFile);
 PAGE_CYCLER_FILE_TESTS("morejs", MorejsFile);
 PAGE_CYCLER_EXTENSIONS_FILE_TESTS("morejs", MorejsFile);
 // added more tests here:
 PAGE_CYCLER_FILE_TESTS("alexa_us", Alexa_usFile);
 PAGE_CYCLER_FILE_TESTS("moz2", Moz2File);
 PAGE_CYCLER_FILE_TESTS("morejsnp", MorejsnpFile);
 PAGE_CYCLER_FILE_TESTS("bloat", BloatFile);
 
 // http (localhost) tests
 PAGE_CYCLER_HTTP_TESTS("moz", MozHttp);
 PAGE_CYCLER_HTTP_TESTS("intl1", Intl1Http);
 PAGE_CYCLER_HTTP_TESTS("intl2", Intl2Http);
 PAGE_CYCLER_HTTP_TESTS("dom", DomHttp);
 PAGE_CYCLER_HTTP_TESTS("bloat", BloatHttp);
 
+// Web Page Replay (simulated network) tests.
+// Windows is unsupported because of issues with loopback adapter and
+// dummynet is unavailable on Vista and above.
+#if !defined(OS_WIN)
+PAGE_CYCLER_WEBPAGEREPLAY_TESTS("2012Q2", 2012Q2);
+#endif
+
 // HTML5 database tests
 // These tests are _really_ slow on XP/Vista.
 #if !defined(OS_WIN)
 PAGE_CYCLER_DATABASE_TESTS("select-transactions",
                            SelectTransactions);
 PAGE_CYCLER_DATABASE_TESTS("select-readtransactions",
                            SelectReadTransactions);
 PAGE_CYCLER_DATABASE_TESTS("select-readtransactions-read-results",
                            SelectReadTransactionsReadResults);
 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);
 #endif
 
 // Indexed DB tests.
 PAGE_CYCLER_IDB_TESTS("basic_insert", BasicInsert);
 
 }  // namespace