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

Review URL: http://codereview.chromium.org/8438058

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@108672 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 126 insertions, 29 deletions

diff --git a/base/test/trace_event_analyzer.cc b/base/test/trace_event_analyzer.cc
index 3e0f373..0a2a15a 100644
--- a/base/test/trace_event_analyzer.cc
+++ b/base/test/trace_event_analyzer.cc
@@ -72,12 +72,8 @@ bool TraceEvent::SetFromJSON(const base::Value* event_value) {
   return false;
 }
 
-bool TraceEvent::GetAbsTimeToOtherEvent(double* duration) const {
-  if (!other_event)
-    return false;
-
-  *duration = fabs(other_event->timestamp - timestamp);
-  return true;
+double TraceEvent::GetAbsTimeToOtherEvent() const {
+  return fabs(other_event->timestamp - timestamp);
 }
 
 bool TraceEvent::GetArgAsString(const std::string& name,
@@ -100,6 +96,46 @@ bool TraceEvent::GetArgAsNumber(const std::string& name,
   return false;
 }
 
+bool TraceEvent::HasStringArg(const std::string& name) const {
+  return (arg_strings.find(name) != arg_strings.end());
+}
+
+bool TraceEvent::HasNumberArg(const std::string& name) const {
+  return (arg_numbers.find(name) != arg_numbers.end());
+}
+
+std::string TraceEvent::GetKnownArgAsString(const std::string& name) const {
+  std::string arg_string;
+  if (GetArgAsString(name, &arg_string))
+    return arg_string;
+  NOTREACHED();
+  return "";
+}
+
+double TraceEvent::GetKnownArgAsDouble(const std::string& name) const {
+  double arg_double;
+  if (GetArgAsNumber(name, &arg_double))
+    return arg_double;
+  NOTREACHED();
+  return 0;
+}
+
+int TraceEvent::GetKnownArgAsInt(const std::string& name) const {
+  double arg_double;
+  if (GetArgAsNumber(name, &arg_double))
+    return static_cast<int>(arg_double);
+  NOTREACHED();
+  return 0;
+}
+
+bool TraceEvent::GetKnownArgAsBool(const std::string& name) const {
+  double arg_double;
+  if (GetArgAsNumber(name, &arg_double))
+    return (arg_double != 0.0);
+  NOTREACHED();
+  return false;
+}
+
 // QueryNode
 
 QueryNode::QueryNode(const Query& query) : query_(query) {
@@ -386,9 +422,8 @@ base::debug::TraceValue Query::GetMemberValue(const TraceEvent& event) const {
       return the_event->timestamp;
     case EVENT_DURATION:
       {
-        double duration;
-        if (the_event->GetAbsTimeToOtherEvent(&duration))
-          return duration;
+        if (the_event->has_other_event())
+          return the_event->GetAbsTimeToOtherEvent();
         else
           return base::debug::TraceValue();
       }
@@ -401,13 +436,12 @@ base::debug::TraceValue Query::GetMemberValue(const TraceEvent& event) const {
     case EVENT_NAME:
     case OTHER_NAME:
       return the_event->name;
-    case EVENT_HAS_ARG:
-    case OTHER_HAS_ARG:
-      // Search for the argument name and return true if found.
-      return static_cast<double>((the_event->arg_strings.find(string_) !=
-                                  the_event->arg_strings.end()) ||
-                                 (the_event->arg_numbers.find(string_) !=
-                                  the_event->arg_numbers.end()) ? 1 : 0);
+    case EVENT_HAS_STRING_ARG:
+    case OTHER_HAS_STRING_ARG:
+      return (the_event->HasStringArg(string_) ? 1.0 : 0.0);
+    case EVENT_HAS_NUMBER_ARG:
+    case OTHER_HAS_NUMBER_ARG:
+      return (the_event->HasNumberArg(string_) ? 1.0 : 0.0);
     case EVENT_ARG:
     case OTHER_ARG:
       {
diff --git a/base/test/trace_event_analyzer.h b/base/test/trace_event_analyzer.h
index 4bf4884..577b185 100644
--- a/base/test/trace_event_analyzer.h
+++ b/base/test/trace_event_analyzer.h
@@ -123,14 +123,28 @@ struct TraceEvent {
   bool has_other_event() const { return other_event; }
 
   // Returns absolute duration in microseconds between this event and other
-  // event. Returns false if has_other_event() is false.
-  bool GetAbsTimeToOtherEvent(double* duration) const;
+  // event. Must have already verified that other_event exists by
+  // Query(EVENT_HAS_OTHER) or by calling has_other_event().
+  double GetAbsTimeToOtherEvent() const;
 
   // Return the argument value if it exists and it is a string.
   bool GetArgAsString(const std::string& name, std::string* arg) const;
   // Return the argument value if it exists and it is a number.
   bool GetArgAsNumber(const std::string& name, double* arg) const;
 
+  // Check if argument exists and is string.
+  bool HasStringArg(const std::string& name) const;
+  // Check if argument exists and is number (double, int or bool).
+  bool HasNumberArg(const std::string& name) const;
+
+  // Get known existing arguments as specific types.
+  // Useful when you have already queried the argument with
+  // Query(HAS_NUMBER_ARG) or Query(HAS_STRING_ARG).
+  std::string GetKnownArgAsString(const std::string& name) const;
+  double GetKnownArgAsDouble(const std::string& name) const;
+  int GetKnownArgAsInt(const std::string& name) const;
+  bool GetKnownArgAsBool(const std::string& name) const;
+
   // Process ID and Thread ID.
   ProcessThreadID thread;
 
@@ -155,7 +169,7 @@ struct TraceEvent {
 };
 
 // Pass these values to Query to compare with the corresponding member of a
-// TraceEvent.
+// TraceEvent. Unless otherwise specfied, the usage is Query(ENUM_MEMBER).
 enum TraceEventMember {
   EVENT_INVALID,
   // Use these to access the event members:
@@ -169,20 +183,39 @@ enum TraceEventMember {
   EVENT_PHASE,
   EVENT_CATEGORY,
   EVENT_NAME,
-  EVENT_HAS_ARG,
+
+  // Evaluates to true if arg exists and is a string.
+  // Usage: Query(EVENT_HAS_STRING_ARG, "arg_name")
+  EVENT_HAS_STRING_ARG,
+  // Evaluates to true if arg exists and is a number.
+  // Number arguments include types double, int and bool.
+  // Usage: Query(EVENT_HAS_NUMBER_ARG, "arg_name")
+  EVENT_HAS_NUMBER_ARG,
+  // Evaluates to arg value (string or number).
+  // Usage: Query(EVENT_ARG, "arg_name")
   EVENT_ARG,
   // Return true if associated event exists.
   // (Typically BEGIN for END or END for BEGIN).
   EVENT_HAS_OTHER,
-  // Use these to access the associated event's members:
+
+  // Access the associated other_event's members:
   OTHER_PID,
   OTHER_TID,
   OTHER_TIME,
   OTHER_PHASE,
   OTHER_CATEGORY,
   OTHER_NAME,
-  OTHER_HAS_ARG,
-  OTHER_ARG
+
+  // Evaluates to true if arg exists and is a string.
+  // Usage: Query(EVENT_HAS_STRING_ARG, "arg_name")
+  OTHER_HAS_STRING_ARG,
+  // Evaluates to true if arg exists and is a number.
+  // Number arguments include types double, int and bool.
+  // Usage: Query(EVENT_HAS_NUMBER_ARG, "arg_name")
+  OTHER_HAS_NUMBER_ARG,
+  // Evaluates to arg value (string or number).
+  // Usage: Query(EVENT_ARG, "arg_name")
+  OTHER_ARG,
 };
 
 class Query {
diff --git a/base/test/trace_event_analyzer_unittest.cc b/base/test/trace_event_analyzer_unittest.cc
index 2047b12..a95413f 100644
--- a/base/test/trace_event_analyzer_unittest.cc
+++ b/base/test/trace_event_analyzer_unittest.cc
@@ -70,6 +70,36 @@ TEST_F(TraceEventAnalyzerTest, NoEvents) {
   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();
@@ -96,8 +126,8 @@ TEST_F(TraceEventAnalyzerTest, QueryEventMember) {
   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));
@@ -107,8 +137,8 @@ TEST_F(TraceEventAnalyzerTest, QueryEventMember) {
   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 =
@@ -121,8 +151,8 @@ TEST_F(TraceEventAnalyzerTest, QueryEventMember) {
   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 =