Clean up some API in trace_event_analyzer.h and add some getters.

base/test/trace_event_analyzer_unittest.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 "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 52 matching lines @@
   scoped_ptr<TraceAnalyzer>
       analyzer(TraceAnalyzer::Create(output_.json_output));
   ASSERT_TRUE(analyzer.get());
 
   // Search for all events and verify that nothing is returned.
   TraceAnalyzer::TraceEventVector found;
   analyzer->FindEvents(Query::Bool(true), &found);
   EXPECT_EQ(0u, found.size());
 }
 
+TEST_F(TraceEventAnalyzerTest, TraceEvent) {
+  using namespace trace_analyzer;
+  ManualSetUp();
+
+  int int_num = 2;
+  double double_num = 3.5;
+  const char* str = "the string";
+
+  TraceEvent event;
+  event.arg_numbers["false"] = 0.0;
+  event.arg_numbers["true"] = 1.0;
+  event.arg_numbers["int"] = static_cast<double>(int_num);
+  event.arg_numbers["double"] = double_num;
+  event.arg_strings["string"] = str;
+
+  ASSERT_TRUE(event.HasNumberArg("false"));
+  ASSERT_TRUE(event.HasNumberArg("true"));
+  ASSERT_TRUE(event.HasNumberArg("int"));
+  ASSERT_TRUE(event.HasNumberArg("double"));
+  ASSERT_TRUE(event.HasStringArg("string"));
+  ASSERT_FALSE(event.HasNumberArg("notfound"));
+  ASSERT_FALSE(event.HasStringArg("notfound"));
+
+  EXPECT_FALSE(event.GetKnownArgAsBool("false"));
+  EXPECT_TRUE(event.GetKnownArgAsBool("true"));
+  EXPECT_EQ(int_num, event.GetKnownArgAsInt("int"));
+  EXPECT_EQ(double_num, event.GetKnownArgAsDouble("double"));
+  EXPECT_STREQ(str, event.GetKnownArgAsString("string").c_str());
+}
+
 TEST_F(TraceEventAnalyzerTest, QueryEventMember) {
   using namespace trace_analyzer;
   ManualSetUp();
 
   TraceEvent event;
   event.thread.process_id = 3;
   event.thread.thread_id = 4;
   event.timestamp = 1.5;
   event.phase = base::debug::TRACE_EVENT_PHASE_BEGIN;
   event.category = "category";
   event.name = "name";
   event.arg_numbers["num"] = 7.0;
   event.arg_strings["str"] = "the string";
 
   // Other event with all different members:
   TraceEvent other;
   other.thread.process_id = 5;
   other.thread.thread_id = 6;
   other.timestamp = 2.5;
   other.phase = base::debug::TRACE_EVENT_PHASE_END;
   other.category = "category2";
   other.name = "name2";
   other.arg_numbers["num2"] = 8.0;
   other.arg_strings["str2"] = "the string 2";
 
   event.other_event = &other;
-  double duration;
-  ASSERT_TRUE(event.GetAbsTimeToOtherEvent(&duration));
+  ASSERT_TRUE(event.has_other_event());
+  double duration = event.GetAbsTimeToOtherEvent();
 
   Query event_pid = (Query(EVENT_PID) == Query::Int(event.thread.process_id));
   Query event_tid = (Query(EVENT_TID) == Query::Int(event.thread.thread_id));
   Query event_time = (Query(EVENT_TIME) == Query::Double(event.timestamp));
   Query event_duration = (Query(EVENT_DURATION) == Query::Double(duration));
   Query event_phase = (Query(EVENT_PHASE) == Query::Phase(event.phase));
   Query event_category =
       (Query(EVENT_CATEGORY) == Query::String(event.category));
   Query event_name = (Query(EVENT_NAME) == Query::String(event.name));
-  Query event_has_arg1 = Query(EVENT_HAS_ARG, "num");
-  Query event_has_arg2 = Query(EVENT_HAS_ARG, "str");
+  Query event_has_arg1 = Query(EVENT_HAS_NUMBER_ARG, "num");
+  Query event_has_arg2 = Query(EVENT_HAS_STRING_ARG, "str");
   Query event_arg1 =
       (Query(EVENT_ARG, "num") == Query::Double(event.arg_numbers["num"]));
   Query event_arg2 =
       (Query(EVENT_ARG, "str") == Query::String(event.arg_strings["str"]));
   Query event_has_other = Query(EVENT_HAS_OTHER);
   Query other_pid = (Query(OTHER_PID) == Query::Int(other.thread.process_id));
   Query other_tid = (Query(OTHER_TID) == Query::Int(other.thread.thread_id));
   Query other_time = (Query(OTHER_TIME) == Query::Double(other.timestamp));
   Query other_phase = (Query(OTHER_PHASE) == Query::Phase(other.phase));
   Query other_category =
       (Query(OTHER_CATEGORY) == Query::String(other.category));
   Query other_name = (Query(OTHER_NAME) == Query::String(other.name));
-  Query other_has_arg1 = Query(OTHER_HAS_ARG, "num2");
-  Query other_has_arg2 = Query(OTHER_HAS_ARG, "str2");
+  Query other_has_arg1 = Query(OTHER_HAS_NUMBER_ARG, "num2");
+  Query other_has_arg2 = Query(OTHER_HAS_STRING_ARG, "str2");
   Query other_arg1 =
       (Query(OTHER_ARG, "num2") == Query::Double(other.arg_numbers["num2"]));
   Query other_arg2 =
       (Query(OTHER_ARG, "str2") == Query::String(other.arg_strings["str2"]));
 
   EXPECT_TRUE(event_pid.Evaluate(event));
   EXPECT_TRUE(event_tid.Evaluate(event));
   EXPECT_TRUE(event_time.Evaluate(event));
   EXPECT_TRUE(event_duration.Evaluate(event));
   EXPECT_TRUE(event_phase.Evaluate(event));
@@ skipping 357 matching lines @@
   EXPECT_TRUE((Query::Double(1.0) == Query::Double(1.0f)).Evaluate(dummy));
   EXPECT_TRUE((Query::Bool(true) == Query::Int(1)).Evaluate(dummy));
   EXPECT_TRUE((Query::Bool(false) == Query::Int(0)).Evaluate(dummy));
   EXPECT_TRUE((Query::Bool(true) == Query::Double(1.0f)).Evaluate(dummy));
   EXPECT_TRUE((Query::Bool(false) == Query::Double(0.0f)).Evaluate(dummy));
 }
 
 
 }  // namespace trace_analyzer