chrome/test/base/tracing_browsertest.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 "chrome/test/base/tracing.h"
   6
   7 #include "base/location.h"
   8 #include "base/run_loop.h"
   9 #include "base/single_thread_task_runner.h"
  10 #include "base/thread_task_runner_handle.h"
  11 #include "base/trace_event/memory_dump_manager.h"
  12 #include "base/trace_event/trace_event.h"
  13 #include "chrome/browser/ui/browser.h"
  14 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  15 #include "chrome/test/base/in_process_browser_test.h"
  16 #include "chrome/test/base/ui_test_utils.h"
  17 #include "content/public/browser/render_view_host.h"
  18 #include "content/public/browser/web_contents.h"
  19 #include "content/public/test/browser_test_utils.h"
  20 #include "testing/gtest/include/gtest/gtest.h"
  21
  22 namespace {
  23
  24 using base::trace_event::MemoryDumpManager;
  25 using base::trace_event::MemoryDumpType;
  26 using tracing::BeginTracingWithWatch;
  27 using tracing::WaitForWatchEvent;
  28 using tracing::EndTracing;
  29
  30 const char g_category[] = "test_tracing";
  31 const char g_event[] = "TheEvent";
  32
  33 class TracingBrowserTest : public InProcessBrowserTest {
  34  protected:
  35   // Execute some no-op javascript on the current tab - this triggers a trace
  36   // event in RenderFrameImpl::OnJavaScriptExecuteRequestForTests (from the
  37   // renderer process).
  38   void ExecuteJavascriptOnCurrentTab() {
  39     content::RenderViewHost* rvh = browser()->tab_strip_model()->
  40         GetActiveWebContents()->GetRenderViewHost();
  41     ASSERT_TRUE(rvh);
  42     ASSERT_TRUE(content::ExecuteScript(rvh, ";"));
  43   }
  44 };
  45
  46 void AddEvents(int num) {
  47   for (int i = 0; i < num; ++i)
  48     TRACE_EVENT_INSTANT0(g_category, g_event, TRACE_EVENT_SCOPE_THREAD);
  49 }
  50
  51 IN_PROC_BROWSER_TEST_F(TracingBrowserTest, BeginTracingWithWatch) {
  52   base::TimeDelta no_timeout;
  53   base::TimeDelta short_timeout = base::TimeDelta::FromMilliseconds(5);
  54   std::string json_events;
  55
  56   // One event before wait.
  57   ASSERT_TRUE(BeginTracingWithWatch(g_category, g_category, g_event, 1));
  58   AddEvents(1);
  59   EXPECT_TRUE(WaitForWatchEvent(no_timeout));
  60   ASSERT_TRUE(EndTracing(&json_events));
  61
  62   // One event after wait.
  63   ASSERT_TRUE(BeginTracingWithWatch(g_category, g_category, g_event, 1));
  64   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
  65                                                 base::Bind(&AddEvents, 1));
  66   EXPECT_TRUE(WaitForWatchEvent(no_timeout));
  67   ASSERT_TRUE(EndTracing(&json_events));
  68
  69   // Not enough events timeout.
  70   ASSERT_TRUE(BeginTracingWithWatch(g_category, g_category, g_event, 2));
  71   AddEvents(1);
  72   EXPECT_FALSE(WaitForWatchEvent(short_timeout));
  73   ASSERT_TRUE(EndTracing(&json_events));
  74
  75   // Multi event before wait.
  76   ASSERT_TRUE(BeginTracingWithWatch(g_category, g_category, g_event, 5));
  77   AddEvents(5);
  78   EXPECT_TRUE(WaitForWatchEvent(no_timeout));
  79   ASSERT_TRUE(EndTracing(&json_events));
  80
  81   // Multi event after wait.
  82   ASSERT_TRUE(BeginTracingWithWatch(g_category, g_category, g_event, 5));
  83   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
  84                                                 base::Bind(&AddEvents, 5));
  85   EXPECT_TRUE(WaitForWatchEvent(no_timeout));
  86   ASSERT_TRUE(EndTracing(&json_events));
  87
  88   // Child process events from same process.
  89   ASSERT_TRUE(BeginTracingWithWatch(g_category, g_category,
  90                                     "OnJavaScriptExecuteRequestForTests", 2));
  91   ASSERT_NO_FATAL_FAILURE(ExecuteJavascriptOnCurrentTab());
  92   ASSERT_NO_FATAL_FAILURE(ExecuteJavascriptOnCurrentTab());
  93   EXPECT_TRUE(WaitForWatchEvent(no_timeout));
  94   ASSERT_TRUE(EndTracing(&json_events));
  95
  96   // Child process events from different processes.
  97   GURL url1("chrome://tracing/");
  98   GURL url2("chrome://credits/");
  99   ASSERT_TRUE(BeginTracingWithWatch(g_category, g_category,
 100                                     "OnJavaScriptExecuteRequestForTests", 2));
 101   // Open two tabs to different URLs to encourage two separate renderer
 102   // processes. Each will fire an event that will be counted towards the total.
 103   ui_test_utils::NavigateToURLWithDisposition(browser(), url1,
 104       NEW_FOREGROUND_TAB, ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 105   ASSERT_NO_FATAL_FAILURE(ExecuteJavascriptOnCurrentTab());
 106   ui_test_utils::NavigateToURLWithDisposition(browser(), url2,
 107       NEW_FOREGROUND_TAB, ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 108   ASSERT_NO_FATAL_FAILURE(ExecuteJavascriptOnCurrentTab());
 109   EXPECT_TRUE(WaitForWatchEvent(no_timeout));
 110   ASSERT_TRUE(EndTracing(&json_events));
 111 }
 112
 113 IN_PROC_BROWSER_TEST_F(TracingBrowserTest, TestMemoryInfra) {
 114   std::string json_events;
 115   base::TimeDelta no_timeout;
 116
 117   GURL url1("about:blank");
 118   ui_test_utils::NavigateToURLWithDisposition(
 119       browser(), url1, NEW_FOREGROUND_TAB,
 120       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 121   ASSERT_NO_FATAL_FAILURE(ExecuteJavascriptOnCurrentTab());
 122
 123   // Begin tracing and watch for multiple periodic dump trace events.
 124   std::string event_name = base::trace_event::MemoryDumpTypeToString(
 125       MemoryDumpType::PERIODIC_INTERVAL);
 126   ASSERT_TRUE(BeginTracingWithWatch(MemoryDumpManager::kTraceCategoryForTesting,
 127                                     MemoryDumpManager::kTraceCategoryForTesting,
 128                                     event_name, 10));
 129
 130   GURL url2("chrome://credits/");
 131   ui_test_utils::NavigateToURLWithDisposition(
 132       browser(), url2, NEW_FOREGROUND_TAB,
 133       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
 134   ASSERT_NO_FATAL_FAILURE(ExecuteJavascriptOnCurrentTab());
 135
 136   EXPECT_TRUE(WaitForWatchEvent(no_timeout));
 137   ASSERT_TRUE(EndTracing(&json_events));
 138
 139   // Expect the basic memory dumps to be present in the trace.
 140   EXPECT_NE(std::string::npos, json_events.find("process_totals"));
 141
 142   EXPECT_NE(std::string::npos, json_events.find("v8"));
 143   EXPECT_NE(std::string::npos, json_events.find("blink_gc"));
 144 }
 145 }  // namespace