Add some TraceAnalyzer utility methods to simplify test code

chrome/test/perf/rendering/latency_tests.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/command_line.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
@@ skipping 94 matching lines @@
 // Don't analyze end frames that may be inaccurate.
 const int kIgnoreEndFrames = 4;
 // Minimum frames to produce an answer.
 const int kMinimumFramesForAnalysis = 5;
 
 class LatencyTest
     : public BrowserPerfTest,
       public ::testing::WithParamInterface<int> {
  public:
   explicit LatencyTest(LatencyTestMode mode) :
-      query_instant_(Query::EventPhase() ==
-                     Query::Phase(TRACE_EVENT_PHASE_INSTANT)),
+      query_instant_(Query::EventPhaseIs(TRACE_EVENT_PHASE_INSTANT)),
       // These queries are initialized in RunTest.
       query_begin_swaps_(Query::Bool(false)),
       query_end_swaps_(Query::Bool(false)),
       query_inputs_(Query::Bool(false)),
       query_blits_(Query::Bool(false)),
       query_clears_(Query::Bool(false)),
       mouse_x_(0),
       tab_width_(0),
       mode_(mode),
       delay_time_us_(0),
@@ skipping 146 matching lines @@
 
 #if defined(OS_WIN)
   // Latency test doesn't work on WinXP. crbug.com/128066
   if (base::win::OSInfo::GetInstance()->version() == base::win::VERSION_XP)
     return;
 #endif
 
   // Construct queries for searching trace events via TraceAnalyzer.
   if (use_gpu_) {
     query_begin_swaps_ = query_instant_ &&
-        Query::EventName() == Query::String("SwapBuffersLatency") &&
+        Query::EventNameIs("SwapBuffersLatency") &&
         Query::EventArg("width") != Query::Int(kWebGLCanvasWidth);
     query_end_swaps_ = query_instant_ &&
-        Query::EventName() == Query::String("CompositorSwapBuffersComplete");
+        Query::EventNameIs("CompositorSwapBuffersComplete");
   } else if (mode_ == kSoftware) {
     // Software updates need to have x=0 and y=0 to contain the input color.
     query_begin_swaps_ = query_instant_ &&
-        Query::EventName() == Query::String("UpdateRect") &&
+        Query::EventNameIs("UpdateRect") &&
         Query::EventArg("x+y") == Query::Int(0);
     query_end_swaps_ = query_instant_ &&
-        Query::EventName() == Query::String("UpdateRectComplete") &&
+        Query::EventNameIs("UpdateRectComplete") &&
         Query::EventArg("x+y") == Query::Int(0);
   }
   query_inputs_ = query_instant_ &&
-      Query::EventName() == Query::String("MouseEventBegin");
+      Query::EventNameIs("MouseEventBegin");
   query_blits_ = query_instant_ &&
-      Query::EventName() == Query::String("DoBlit") &&
+      Query::EventNameIs("DoBlit") &&
       Query::EventArg("width") == Query::Int(kWebGLCanvasWidth);
   query_clears_ = query_instant_ &&
-      Query::EventName() == Query::String("DoClear") &&
+      Query::EventNameIs("DoClear") &&
       Query::EventArg("green") == Query::Int(kClearColorGreen);
   Query query_width_swaps = Query::Bool(false);
   if (use_gpu_) {
     query_width_swaps = query_begin_swaps_;
   } else if (mode_ == kSoftware) {
     query_width_swaps = query_instant_ &&
-        Query::EventName() == Query::String("UpdateRectWidth") &&
+        Query::EventNameIs("UpdateRectWidth") &&
         Query::EventArg("width") > Query::Int(kWebGLCanvasWidth);
   }
 
   // Set path to test html.
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_path_));
   test_path_ = test_path_.Append(FILE_PATH_LITERAL("perf"));
   test_path_ = test_path_.Append(FILE_PATH_LITERAL("latency_suite.html"));
   ASSERT_TRUE(file_util::PathExists(test_path_))
       << "Missing test file: " << test_path_.value();
 
   // Run once with defaults to measure the frame times.
   delay_time_us_ = 0;
   // kNumFrames may be very high, but we only need a few frames to measure
   // average frame times.
   num_frames_ = 30;
   int initial_flags = 0;
   if (mode_ == kSoftware) {
     // For the first run, run software with kPaintHeavy (which toggles the
     // background color every frame) to force an update each RAF. Otherwise it
     // won't trigger an UpdateRect each frame and we won't be able to measure
     // framerate, because there are no inputs during the first run.
     initial_flags = static_cast<int>(kPaintHeavy);
   }
   RunTestInternal(GetUrl(initial_flags), false, 0);
 
   // Get width of tab so that we know the limit of x coordinates for the
   // injected mouse inputs.
-  const TraceEvent* swap_event = analyzer_->FindOneEvent(query_width_swaps);
+  const TraceEvent* swap_event = analyzer_->FindFirstOf(query_width_swaps);
   ASSERT_TRUE(swap_event);
   tab_width_ = swap_event->GetKnownArgAsInt("width");
   // Keep printf output clean by limiting input coords to three digits:
   tab_width_ = (tab_width_ < 1000) ? tab_width_ : 999;
   // Sanity check the tab_width -- it should be more than 100 pixels.
   EXPECT_GT(tab_width_, 100);
 
   int mean_frame_time_us = 0;
   GetMeanFrameTimeMicros(&mean_frame_time_us);
   if (verbose_)
@@ skipping 17 matching lines @@
       printf("Mode: %s\n", GetUrlModeString(i).c_str());
     printf("URL: %s\n", url.c_str());
 
     // Do the actual test with input events.
     RunTestInternal(url, true, delay_us);
     latencies_[test_flags_] = CalculateLatency();
 
     if (mode_ == kWebGLThread) {
       // Print vsync info when in threaded mode.
       Query query_vsync =
-          Query::EventName() ==
-              Query::String("CCThreadProxy::onVSyncParametersChanged") &&
+          Query::EventNameIs("CCThreadProxy::onVSyncParametersChanged") &&
           Query::EventHasNumberArg("monotonicTimebase") &&
           Query::EventHasNumberArg("intervalInSeconds");
 
-      const TraceEvent* vsync_info = analyzer_->FindOneEvent(query_vsync);
+      const TraceEvent* vsync_info = analyzer_->FindFirstOf(query_vsync);
       if (vsync_info) {
         double timebase = vsync_info->GetKnownArgAsDouble("monotonicTimebase");
         double interval = vsync_info->GetKnownArgAsDouble("intervalInSeconds");
         printf("VSync scheduling: timebase = %f; interval = %f\n",
                timebase, interval);
       }
     }
   }
 
   // Print summary if more than 1 behavior was tested in this run. This is only
@@ skipping 331 matching lines @@
     kInputHeavy | kInputDirty | kRafHeavy, \
     kInputHeavy | kInputDirty | kRafHeavy | kPaintHeavy, \
     kInputDirty | kPaintHeavy, \
     kInputDirty | kRafHeavy | kPaintHeavy)
 
 INSTANTIATE_TEST_CASE_P(, LatencyTestWebGL, LATENCY_SUITE_MODES());
 INSTANTIATE_TEST_CASE_P(, LatencyTestWebGLThread, LATENCY_SUITE_MODES());
 INSTANTIATE_TEST_CASE_P(, LatencyTestSW, LATENCY_SUITE_MODES());
 
 }  // namespace