Add tests to capture traces of StartupTest.ProfilingScript1 with

chrome/test/perf/startup_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/environment.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/sys_info.h"
 #include "base/test/test_file_util.h"
 #include "base/test/test_timeouts.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/env_vars.h"
 #include "chrome/test/automation/automation_proxy.h"
 #include "chrome/test/base/test_switches.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "chrome/test/perf/perf_test.h"
 #include "chrome/test/ui/ui_perf_test.h"
+#include "content/public/common/content_switches.h"
 #include "net/base/net_util.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace {
 
 class StartupTest : public UIPerfTest {
  public:
-  StartupTest() {
+  StartupTest() : tracing_enabled_(false) {
     show_window_ = true;
   }
   virtual void SetUp() {
     collect_profiling_stats_ = false;
   }
   virtual void TearDown() {}
 
   enum TestColdness {
     WARM,
     COLD
@@ skipping 17 matching lines @@
   // Setup the command line arguments to capture profiling data for tasks.
   void SetUpWithProfiling() {
     profiling_file_ = ui_test_utils::GetTestFilePath(
         base::FilePath(base::FilePath::kCurrentDirectory),
         base::FilePath(FILE_PATH_LITERAL("task_profile.json")));
     launch_arguments_.AppendSwitchPath(switches::kProfilingOutputFile,
                                        profiling_file_);
     collect_profiling_stats_ = true;
   }
 
+  // Set the command line arguments to enable tracing.
+  void SetUpWithTracing(std::string trace_file_prefix) {
+    tracing_enabled_ = true;
+    trace_file_prefix_ = trace_file_prefix;
+    launch_arguments_.AppendSwitch(switches::kTraceStartup);
+    launch_arguments_.AppendSwitchASCII(switches::kTraceStartupDuration,
+                                        "1");
+  }
+
+  // Pause after running a test with tracing, to wait for the trace to
+  // be written.
+  void PauseForTracing() {
+    if (tracing_enabled_) {
+#if defined(OS_MACOSX)
+      sleep(1);

[Zhenyao Mo, 2013/03/15 02:51:47]

are you sure you want 1 ms?  (sleep is ms instead of sec, right?)

[ccameron, 2013/03/15 07:56:21]

This one behaves as seconds (I tested it)
http://linux.die.net/man/3/sleep
But, that said, it's a platform-specific call, so I didn't want to allow it
outside of Mac.

+#else
+      NOTREACHED();
+#endif
+    }
+  }
+
+  // Set the command line arguments to use force-compositing-mode.
+  void SetUpWithForceCompositingMode() {
+    launch_arguments_.AppendSwitch(switches::kForceCompositingMode);
+  }
+
   // Load a complex html file on startup represented by |which_tab|.
   void SetUpWithComplexFileURL(unsigned int which_tab) {
     const char* const kTestPageCyclerDomains[] = {
         "www.google.com", "www.nytimes.com",
         "www.yahoo.com", "espn.go.com", "www.amazon.com"
     };
     unsigned int which_el = which_tab % arraysize(kTestPageCyclerDomains);
     const char* this_domain = kTestPageCyclerDomains[which_el];
 
     base::FilePath page_cycler_path;
@@ skipping 100 matching lines @@
 
     struct TimingInfo {
       TimeDelta end_to_end;
       float first_start_ms;
       float last_stop_ms;
       float first_stop_ms;
       float nth_tab_stop_ms;
     };
     TimingInfo timings[kNumCyclesMax];
 
+    CommandLine launch_arguments_without_trace_file(launch_arguments_);
     for (int i = 0; i < numCycles; ++i) {
+      if (tracing_enabled_) {
+        std::stringstream tracing_enabled_file;
+        tracing_enabled_file << trace_file_prefix_ << i;
+        launch_arguments_ = launch_arguments_without_trace_file;
+        launch_arguments_.AppendSwitchASCII(switches::kTraceStartupFile,
+                                            tracing_enabled_file.str());
+      }
       if (test_cold == COLD) {
         base::FilePath dir_app;
         ASSERT_TRUE(PathService::Get(chrome::DIR_APP, &dir_app));
 
         base::FilePath chrome_exe(dir_app.Append(GetExecutablePath()));
         ASSERT_TRUE(EvictFileFromSystemCacheWrapper(chrome_exe));
 #if defined(OS_WIN)
         // chrome.dll is windows specific.
         base::FilePath chrome_dll(
             dir_app.Append(FILE_PATH_LITERAL("chrome.dll")));
@@ skipping 23 matching lines @@
           timings[i].last_stop_ms = max_stop;
           timings[i].first_stop_ms = times[0];
           timings[i].nth_tab_stop_ms = times[nth_timed_tab];
         } else {
           // Browser might not support initial load times.
           // Only use end-to-end time for this test.
           num_tabs = 0;
         }
       }
       timings[i].end_to_end = end_time - browser_launch_time();
+      PauseForTracing();
       UITest::TearDown();
 
       if (i == 0) {
         // Re-use the profile data after first run so that the noise from
         // creating databases doesn't impact all the runs.
         clear_profile_ = false;
         // Clear template_user_data_ so we don't try to copy it over each time
         // through.
         set_template_user_data(base::FilePath());
       }
@@ skipping 42 matching lines @@
         for (int i = 0; i < numCycles; ++i)
           base::StringAppendF(&times, "%.2f,", timings[i].last_stop_ms);
         perf_test::PrintResultList(graph, "", name.c_str(), times, "ms",
                                    important);
       }
     }
   }
 
   base::FilePath profiling_file_;
   bool collect_profiling_stats_;
+  bool tracing_enabled_;
+  std::string trace_file_prefix_;
 };
 
 TEST_F(StartupTest, PerfWarm) {
   RunStartupTest("warm", "t", WARM, IMPORTANT,
                  UITestBase::DEFAULT_THEME, 0, 0);
 }
 
 TEST_F(StartupTest, PerfReferenceWarm) {
   UseReferenceBuild();
   RunStartupTest("warm", "t_ref", WARM, IMPORTANT,
@@ skipping 152 matching lines @@
                  UITestBase::COMPLEX_THEME, 0, 0);
 }
 
 TEST_F(StartupTest, ProfilingScript1) {
   SetUpWithFileURL();
   SetUpWithProfiling();
   RunStartupTest("warm", "profiling_scripts1", WARM, NOT_IMPORTANT,
                  UITestBase::DEFAULT_THEME, 1, 0);
 }
 
+#if defined(OS_MACOSX)
+TEST_F(StartupTest, TracedProfilingScript1) {
+  SetUpWithFileURL();
+  SetUpWithProfiling();
+  SetUpWithTracing("startup_trace_sw_");
+  RunStartupTest("warm", "traced_profiling_scripts1", WARM, NOT_IMPORTANT,
+                 UITestBase::DEFAULT_THEME, 1, 0);
+}
+
+TEST_F(StartupTest, TracedProfilingScript1FCM) {
+  SetUpWithFileURL();
+  SetUpWithProfiling();
+  SetUpWithForceCompositingMode();
+  SetUpWithTracing("startup_trace_fcm_");
+  RunStartupTest("warm", "traced_profiling_scripts1_fcm", WARM, NOT_IMPORTANT,
+                 UITestBase::DEFAULT_THEME, 1, 0);
+}
+#endif
+
 }  // namespace