Add ASYNC_STEP support to trace_event and change START to ASYNC_BEGIN.

base/test/trace_event_analyzer_unittest.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/bind.h"
 #include "base/test/trace_event_analyzer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace trace_analyzer {
@@ skipping 429 matching lines @@
   EXPECT_STREQ("name2", found[0]->name.c_str());
 }
 
 // Test MergeAssociatedEventArgs
 TEST_F(TraceEventAnalyzerTest, MergeAssociatedEventArgs) {
   ManualSetUp();
 
   const char* arg_string = "arg_string";
   BeginTracing();
   {
-    TRACE_EVENT1("cat1", "name1", "arg", arg_string);
+    TRACE_EVENT_BEGIN0("cat1", "name1");
+    TRACE_EVENT_END1("cat1", "name1", "arg", arg_string);
   }
   EndTracing();
 
   scoped_ptr<TraceAnalyzer>
       analyzer(TraceAnalyzer::Create(output_.json_output));
   ASSERT_TRUE(analyzer.get());
   analyzer->AssociateBeginEndEvents();
 
   TraceEventVector found;
-  analyzer->FindEvents(Query::EventName() == Query::String("name1") &&
-      Query::EventPhase() == Query::Phase(TRACE_EVENT_PHASE_END), &found);
+  analyzer->FindEvents(Query::MatchBeginName("name1"), &found);
   ASSERT_EQ(1u, found.size());
   std::string arg_actual;
   EXPECT_FALSE(found[0]->GetArgAsString("arg", &arg_actual));
 
   analyzer->MergeAssociatedEventArgs();
   EXPECT_TRUE(found[0]->GetArgAsString("arg", &arg_actual));
   EXPECT_STREQ(arg_string, arg_actual.c_str());
 }
 
-// Test AssociateStartFinishEvents
-TEST_F(TraceEventAnalyzerTest, StartFinishAssocations) {
+// Test AssociateAsyncBeginEndEvents
+TEST_F(TraceEventAnalyzerTest, AsyncBeginEndAssocations) {
   ManualSetUp();
 
   BeginTracing();
   {
-    TRACE_EVENT_FINISH0("cat1", "name1", 0xA); // does not match / out of order
-    TRACE_EVENT_START0("cat1", "name1", 0xB);
-    TRACE_EVENT_START0("cat1", "name1", 0xC);
+    TRACE_EVENT_ASYNC_END0("cat1", "name1", 0xA); // no match / out of order
+    TRACE_EVENT_ASYNC_BEGIN0("cat1", "name1", 0xB);
+    TRACE_EVENT_ASYNC_BEGIN0("cat1", "name1", 0xC);
     TRACE_EVENT_INSTANT0("cat1", "name1"); // noise
     TRACE_EVENT0("cat1", "name1"); // noise
-    TRACE_EVENT_FINISH0("cat1", "name1", 0xB);
-    TRACE_EVENT_FINISH0("cat1", "name1", 0xC);
-    TRACE_EVENT_START0("cat1", "name1", 0xA); // does not match / out of order
+    TRACE_EVENT_ASYNC_END0("cat1", "name1", 0xB);
+    TRACE_EVENT_ASYNC_END0("cat1", "name1", 0xC);
+    TRACE_EVENT_ASYNC_BEGIN0("cat1", "name1", 0xA); // no match / out of order
   }
   EndTracing();
 
   scoped_ptr<TraceAnalyzer>
       analyzer(TraceAnalyzer::Create(output_.json_output));
   ASSERT_TRUE(analyzer.get());
-  analyzer->AssociateStartFinishEvents();
+  analyzer->AssociateAsyncBeginEndEvents();
 
   TraceEventVector found;
-  analyzer->FindEvents(Query::MatchStartWithFinish(), &found);
+  analyzer->FindEvents(Query::MatchAsyncBeginWithNext(), &found);
   ASSERT_EQ(2u, found.size());
   EXPECT_STRCASEEQ("B", found[0]->id.c_str());
   EXPECT_STRCASEEQ("C", found[1]->id.c_str());
 }
 
+// Test AssociateAsyncBeginEndEvents
+TEST_F(TraceEventAnalyzerTest, AsyncBeginEndAssocationsWithSteps) {
+  ManualSetUp();
+
+  BeginTracing();
+  {
+    TRACE_EVENT_ASYNC_STEP0("c", "n", 0xA);
+    TRACE_EVENT_ASYNC_END0("c", "n", 0xA);
+    TRACE_EVENT_ASYNC_BEGIN0("c", "n", 0xB);
+    TRACE_EVENT_ASYNC_BEGIN0("c", "n", 0xC);
+    TRACE_EVENT_ASYNC_STEP0("c", "n", 0xB);
+    TRACE_EVENT_ASYNC_STEP0("c", "n", 0xC);
+    TRACE_EVENT_ASYNC_STEP1("c", "n", 0xC, "a", 1);
+    TRACE_EVENT_ASYNC_END0("c", "n", 0xB);
+    TRACE_EVENT_ASYNC_END0("c", "n", 0xC);
+    TRACE_EVENT_ASYNC_BEGIN0("c", "n", 0xA);
+    TRACE_EVENT_ASYNC_STEP0("c", "n", 0xA);
+  }
+  EndTracing();
+
+  scoped_ptr<TraceAnalyzer>
+      analyzer(TraceAnalyzer::Create(output_.json_output));
+  ASSERT_TRUE(analyzer.get());
+  analyzer->AssociateAsyncBeginEndEvents();
+
+  TraceEventVector found;
+  analyzer->FindEvents(Query::MatchAsyncBeginWithNext(), &found);
+  ASSERT_EQ(3u, found.size());
+
+  EXPECT_STRCASEEQ("B", found[0]->id.c_str());
+  EXPECT_EQ(TRACE_EVENT_PHASE_ASYNC_STEP, found[0]->other_event->phase);
+  EXPECT_TRUE(found[0]->other_event->other_event);
+  EXPECT_EQ(TRACE_EVENT_PHASE_ASYNC_END,
+            found[0]->other_event->other_event->phase);
+
+  EXPECT_STRCASEEQ("C", found[1]->id.c_str());
+  EXPECT_EQ(TRACE_EVENT_PHASE_ASYNC_STEP, found[1]->other_event->phase);
+  EXPECT_TRUE(found[1]->other_event->other_event);
+  EXPECT_EQ(TRACE_EVENT_PHASE_ASYNC_STEP,
+            found[1]->other_event->other_event->phase);
+  double arg_actual = 0;
+  EXPECT_TRUE(found[1]->other_event->other_event->GetArgAsNumber(
+                  "a", &arg_actual));
+  EXPECT_EQ(1.0, arg_actual);
+  EXPECT_TRUE(found[1]->other_event->other_event->other_event);
+  EXPECT_EQ(TRACE_EVENT_PHASE_ASYNC_END,
+            found[1]->other_event->other_event->other_event->phase);
+
+  EXPECT_STRCASEEQ("A", found[2]->id.c_str());
+  EXPECT_EQ(TRACE_EVENT_PHASE_ASYNC_STEP, found[2]->other_event->phase);
+}
+
 // Test that the TraceAnalyzer custom associations work.
 TEST_F(TraceEventAnalyzerTest, CustomAssociations) {
   ManualSetUp();
 
   // Add events that begin/end in pipelined ordering with unique ID parameter
   // to match up the begin/end pairs.
   BeginTracing();
   {
     TRACE_EVENT_INSTANT1("cat1", "end", "id", 1);   // no begin match
     TRACE_EVENT_INSTANT1("cat2", "begin", "id", 2); // end is cat4
@@ skipping 24 matching lines @@
   // cat1 has no other_event.
   analyzer->FindEvents(Query::EventCategory() == Query::String("cat1") &&
                        !Query::EventHasOther(), &found);
   EXPECT_EQ(1u, found.size());
 
   // cat6 has no other_event.
   analyzer->FindEvents(Query::EventCategory() == Query::String("cat6") &&
                        !Query::EventHasOther(), &found);
   EXPECT_EQ(1u, found.size());
 
-  // cat2 and cat4 are a associated.
+  // cat2 and cat4 are associated.
   analyzer->FindEvents(Query::EventCategory() == Query::String("cat2") &&
                        Query::OtherCategory() == Query::String("cat4"), &found);
   EXPECT_EQ(1u, found.size());
 
-  // cat4 and cat2 are a associated.
+  // cat4 and cat2 are not associated.
   analyzer->FindEvents(Query::EventCategory() == Query::String("cat4") &&
                        Query::OtherCategory() == Query::String("cat2"), &found);
-  EXPECT_EQ(1u, found.size());
+  EXPECT_EQ(0u, found.size());
 
-  // cat3 and cat5 are a associated.
+  // cat3 and cat5 are associated.
   analyzer->FindEvents(Query::EventCategory() == Query::String("cat3") &&
                        Query::OtherCategory() == Query::String("cat5"), &found);
   EXPECT_EQ(1u, found.size());
 
-  // cat5 and cat3 are a associated.
+  // cat5 and cat3 are not associated.
   analyzer->FindEvents(Query::EventCategory() == Query::String("cat5") &&
                        Query::OtherCategory() == Query::String("cat3"), &found);
-  EXPECT_EQ(1u, found.size());
+  EXPECT_EQ(0u, found.size());
 }
 
 // Verify that Query literals and types are properly casted.
 TEST_F(TraceEventAnalyzerTest, Literals) {
   ManualSetUp();
 
   // Since these queries don't refer to the event data, the dummy event below
   // will never be accessed.
   TraceEvent dummy;
   char char_num = 5;
@@ skipping 160 matching lines @@
   EXPECT_EQ(num_events, CountMatches(event_ptrs, Query::Bool(true)));
   EXPECT_EQ(num_events - 1, CountMatches(event_ptrs, Query::Bool(true),
                                          1, num_events));
   EXPECT_EQ(1u, CountMatches(event_ptrs, query_one));
   EXPECT_EQ(num_events - 1, CountMatches(event_ptrs, !query_one));
   EXPECT_EQ(num_named, CountMatches(event_ptrs, query_named));
 }
 
 
 }  // namespace trace_analyzer