chrome/test/perf/feature_startup_test.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/path_service.h"
   6 #include "base/strings/stringprintf.h"
   7 #include "base/time/time.h"
   8 #include "chrome/app/chrome_command_ids.h"
   9 #include "chrome/common/chrome_paths.h"
  10 #include "chrome/common/chrome_switches.h"
  11 #include "chrome/test/automation/automation_proxy.h"
  12 #include "chrome/test/automation/browser_proxy.h"
  13 #include "chrome/test/automation/window_proxy.h"
  14 #include "chrome/test/perf/perf_test.h"
  15 #include "chrome/test/perf/perf_ui_test_suite.h"
  16 #include "chrome/test/ui/ui_perf_test.h"
  17 #include "net/base/net_util.h"
  18 #include "testing/perf/perf_test.h"
  19 #include "ui/gfx/rect.h"
  20
  21 using base::TimeDelta;
  22
  23 namespace {
  24
  25 class NewTabUIStartupTest : public UIPerfTest {
  26  public:
  27   NewTabUIStartupTest() {
  28     show_window_ = true;
  29   }
  30
  31   virtual void SetUp() {}
  32   virtual void TearDown() {}
  33
  34   static const int kNumCycles = 5;
  35
  36   void PrintTimings(const char* label, TimeDelta timings[kNumCycles],
  37                     bool important) {
  38     std::string times;
  39     for (int i = 0; i < kNumCycles; ++i)
  40       base::StringAppendF(&times, "%.2f,", timings[i].InMillisecondsF());
  41     perf_test::PrintResultList(
  42         "new_tab", std::string(), label, times, "ms", important);
  43   }
  44
  45   void InitProfile(PerfUITestSuite::ProfileType profile_type) {
  46     // Install the location of the test profile file.
  47     set_template_user_data(
  48         PerfUITestSuite::GetPathForProfileType(profile_type));
  49   }
  50
  51   // Run the test, by bringing up a browser and timing the new tab startup.
  52   // |want_warm| is true if we should output warm-disk timings, false if
  53   // we should report cold timings.
  54   void RunStartupTest(const char* label, bool want_warm, bool important,
  55                       PerfUITestSuite::ProfileType profile_type) {
  56     InitProfile(profile_type);
  57
  58     TimeDelta timings[kNumCycles];
  59     for (int i = 0; i < kNumCycles; ++i) {
  60       UITest::SetUp();
  61
  62       // Switch to the "new tab" tab, which should be any new tab after the
  63       // first (the first is about:blank).
  64       scoped_refptr<BrowserProxy> window(automation()->GetBrowserWindow(0));
  65       ASSERT_TRUE(window.get());
  66
  67       // We resize the window so that we hit the normal layout of the NTP and
  68       // not the small layout mode.
  69 #if defined(OS_WIN)
  70       // TODO(port): SetBounds returns false when not implemented.
  71       // It is OK to comment out the resize since it will still be useful to
  72       // test the default size of the window.
  73       ASSERT_TRUE(window->GetWindow().get()->SetBounds(gfx::Rect(1000, 1000)));
  74 #endif
  75       int tab_count = -1;
  76       ASSERT_TRUE(window->GetTabCount(&tab_count));
  77       ASSERT_EQ(1, tab_count);
  78
  79       // Hit ctl-t and wait for the tab to load.
  80       ASSERT_TRUE(window->RunCommand(IDC_NEW_TAB));
  81       ASSERT_TRUE(window->GetTabCount(&tab_count));
  82       ASSERT_EQ(2, tab_count);
  83       int load_time;
  84       ASSERT_TRUE(automation()->WaitForInitialNewTabUILoad(&load_time));
  85
  86       if (want_warm) {
  87         // Bring up a second tab, now that we've already shown one tab.
  88         ASSERT_TRUE(window->RunCommand(IDC_NEW_TAB));
  89         ASSERT_TRUE(window->GetTabCount(&tab_count));
  90         ASSERT_EQ(3, tab_count);
  91         ASSERT_TRUE(automation()->WaitForInitialNewTabUILoad(&load_time));
  92       }
  93       timings[i] = TimeDelta::FromMilliseconds(load_time);
  94
  95       window = NULL;
  96       UITest::TearDown();
  97     }
  98
  99     PrintTimings(label, timings, important);
 100   }
 101
 102   void RunNewTabTimingTest() {
 103     InitProfile(PerfUITestSuite::DEFAULT_THEME);
 104
 105     TimeDelta scriptstart_times[kNumCycles];
 106     TimeDelta domcontentloaded_times[kNumCycles];
 107     TimeDelta onload_times[kNumCycles];
 108
 109     for (int i = 0; i < kNumCycles; ++i) {
 110       UITest::SetUp();
 111
 112       // Switch to the "new tab" tab, which should be any new tab after the
 113       // first (the first is about:blank).
 114       scoped_refptr<BrowserProxy> window(automation()->GetBrowserWindow(0));
 115       ASSERT_TRUE(window.get());
 116
 117       // We resize the window so that we hit the normal layout of the NTP and
 118       // not the small layout mode.
 119 #if defined(OS_WIN)
 120       // TODO(port): SetBounds returns false when not implemented.
 121       // It is OK to comment out the resize since it will still be useful to
 122       // test the default size of the window.
 123       ASSERT_TRUE(window->GetWindow().get()->SetBounds(gfx::Rect(1000, 1000)));
 124 #endif
 125       int tab_count = -1;
 126       ASSERT_TRUE(window->GetTabCount(&tab_count));
 127       ASSERT_EQ(1, tab_count);
 128
 129       // Hit ctl-t and wait for the tab to load.
 130       ASSERT_TRUE(window->RunCommand(IDC_NEW_TAB));
 131       ASSERT_TRUE(window->GetTabCount(&tab_count));
 132       ASSERT_EQ(2, tab_count);
 133       int duration;
 134       ASSERT_TRUE(automation()->WaitForInitialNewTabUILoad(&duration));
 135
 136       // Collect the timing information.
 137       ASSERT_TRUE(automation()->GetMetricEventDuration("Tab.NewTabScriptStart",
 138           &duration));
 139       scriptstart_times[i] = TimeDelta::FromMilliseconds(duration);
 140
 141       ASSERT_TRUE(automation()->GetMetricEventDuration(
 142           "Tab.NewTabDOMContentLoaded", &duration));
 143       domcontentloaded_times[i] = TimeDelta::FromMilliseconds(duration);
 144
 145       ASSERT_TRUE(automation()->GetMetricEventDuration("Tab.NewTabOnload",
 146           &duration));
 147       onload_times[i] = TimeDelta::FromMilliseconds(duration);
 148
 149       window = NULL;
 150       UITest::TearDown();
 151     }
 152
 153     PrintTimings("script_start", scriptstart_times, false /* important */);
 154     PrintTimings("domcontent_loaded", domcontentloaded_times,
 155                  false /* important */);
 156     PrintTimings("onload", onload_times, false /* important */);
 157   }
 158 };
 159
 160 // FLAKY: http://crbug.com/69940
 161 TEST_F(NewTabUIStartupTest, DISABLED_PerfRefCold) {
 162   UseReferenceBuild();
 163   RunStartupTest("tab_cold_ref", false /* cold */, true /* important */,
 164                  PerfUITestSuite::DEFAULT_THEME);
 165 }
 166
 167 // FLAKY: http://crbug.com/69940
 168 TEST_F(NewTabUIStartupTest, DISABLED_PerfCold) {
 169   RunStartupTest("tab_cold", false /* cold */, true /* important */,
 170                  PerfUITestSuite::DEFAULT_THEME);
 171 }
 172
 173 // FLAKY: http://crbug.com/69940
 174 TEST_F(NewTabUIStartupTest, DISABLED_PerfRefWarm) {
 175   UseReferenceBuild();
 176   RunStartupTest("tab_warm_ref", true /* warm */, true /* not important */,
 177                  PerfUITestSuite::DEFAULT_THEME);
 178 }
 179
 180 // FLAKY: http://crbug.com/69940
 181 TEST_F(NewTabUIStartupTest, DISABLED_PerfWarm) {
 182   RunStartupTest("tab_warm", true /* warm */, true /* not important */,
 183                  PerfUITestSuite::DEFAULT_THEME);
 184 }
 185
 186 // FLAKY: http://crbug.com/69940
 187 TEST_F(NewTabUIStartupTest, DISABLED_ComplexThemeCold) {
 188   RunStartupTest("tab_complex_theme_cold", false /* cold */,
 189                  false /* not important */,
 190                  PerfUITestSuite::COMPLEX_THEME);
 191 }
 192
 193 // FLAKY: http://crbug.com/69940
 194 TEST_F(NewTabUIStartupTest, DISABLED_NewTabTimingTestsCold) {
 195   RunNewTabTimingTest();
 196 }
 197
 198 }  // namespace