Added trace query code and wired tracing through BrowserProxy so tests can run traces.

chrome/test/perf/frame_rate/frame_rate_tests.cc

 // Copyright (c) 2011 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 <map>
 
+#include "base/debug/trace_event_test_utils.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/test/test_timeouts.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/test/automation/automation_proxy.h"
+#include "chrome/test/automation/browser_proxy.h"
 #include "chrome/test/automation/tab_proxy.h"
 #include "chrome/test/ui/javascript_test_util.h"
 #include "chrome/test/ui/ui_perf_test.h"
 #include "net/base/net_util.h"
 
 namespace {
 
 class FrameRateTest : public UIPerfTest {
  public:
   FrameRateTest() {
@@ skipping 22 matching lines @@
     // and allow the frame rate test to use the GPU, we must pass
     // kAllowWebUICompositing.
     launch_arguments_.AppendSwitch(switches::kAllowWebUICompositing);
 
     UIPerfTest::SetUp();
   }
 
   void RunTest(const std::string& name,
                const std::string& suffix,
                bool make_body_composited) {
+    using namespace base::debug;
+    using namespace base::debug::trace;
+
     FilePath test_path = GetDataPath(name);
     ASSERT_TRUE(file_util::DirectoryExists(test_path))
         << "Missing test directory: " << test_path.value();
 
     test_path = test_path.Append(FILE_PATH_LITERAL("test.html"));
 
     scoped_refptr<TabProxy> tab(GetActiveTab());
     ASSERT_TRUE(tab.get());
 
     ASSERT_EQ(AUTOMATION_MSG_NAVIGATION_SUCCESS,
               tab->NavigateToURL(net::FilePathToFileURL(test_path)));
 
     if (make_body_composited) {
       ASSERT_TRUE(tab->NavigateToURLAsync(
           GURL("javascript:__make_body_composited();")));
     }
 
+    // Create a browser proxy.
+    scoped_refptr<BrowserProxy> browser = automation()->GetBrowserWindow(0);
+
+    // Start tracing category "test_frame_rate_tests".
+    ASSERT_TRUE(browser->BeginTracing("test_frame_rate_tests"));
+
     // Start the tests.
     ASSERT_TRUE(tab->NavigateToURLAsync(GURL("javascript:__start_all();")));
 
     // Block until the tests completes.
     ASSERT_TRUE(WaitUntilJavaScriptCondition(
         tab, L"", L"window.domAutomationController.send(!__running_all);",
         TestTimeouts::large_test_timeout_ms()));
 
+    // Stop tracing.
+    std::string json_events;
+    ASSERT_TRUE(browser->EndTracing(&json_events));
+
     // Read out the results.
     std::wstring json;
     ASSERT_TRUE(tab->ExecuteAndExtractString(
         L"",
         L"window.domAutomationController.send("
         L"JSON.stringify(__calc_results_total()));",
         &json));
 
     std::map<std::string, std::string> results;
     ASSERT_TRUE(JsonDictionaryToMap(WideToUTF8(json), &results));
 
     ASSERT_TRUE(results.find("mean") != results.end());
     ASSERT_TRUE(results.find("sigma") != results.end());
     ASSERT_TRUE(results.find("gestures") != results.end());
     ASSERT_TRUE(results.find("means") != results.end());
     ASSERT_TRUE(results.find("sigmas") != results.end());
 
-    std::string trace_name = "fps" + suffix;
+    // Check trace for GPU accleration.
+    TraceAnalyzer analyzer(json_events);
+    const TestTraceEvent* gpu_event =
+        analyzer.FindEvent(Query(EVENT_NAME) == "SwapBuffers" &&
+                           Query(EVENT_ARG, "is_GPU"));
+
+    // Verify that sanity-check DoDeferredUpdate event exists.
+    ASSERT_TRUE(analyzer.FindEvent(Query(EVENT_NAME) == "DoDeferredUpdate"));
+
+    // If GPU acceleration is requested, set the appropriate suffix. _swfb means
+    // software fallback (GPU acceleration requested but not available).
+    std::string gpu_suffix = gpu_event ? "_gpu" :
+                             make_body_composited ? "_swfb" : "";
+
+    std::string trace_name = "fps" + suffix + gpu_suffix;
     printf("GESTURES %s: %s= [%s] [%s] [%s]\n", name.c_str(),
                                                 trace_name.c_str(),
                                                 results["gestures"].c_str(),
                                                 results["means"].c_str(),
                                                 results["sigmas"].c_str());
 
     std::string mean_and_error = results["mean"] + "," + results["sigma"];
     PrintResultMeanAndError(name, "", trace_name, mean_and_error,
                             "frames-per-second", true);
   }
@@ skipping 28 matching lines @@
   RunTest(#content, "_ref", false); \
 } \
 TEST_F(FrameRateTest_Reference, content ## _comp) { \
   RunTest(#content, "_comp_ref", true); \
 }
 
 FRAME_RATE_TEST_WITH_AND_WITHOUT_ACCELERATED_COMPOSITING(blank);
 FRAME_RATE_TEST_WITH_AND_WITHOUT_ACCELERATED_COMPOSITING(googleblog);
 
 }  // namespace