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

base/test/trace_event_analyzer.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/test/trace_event_analyzer.h"
 
 #include <algorithm>
 #include <math.h>
 
 #include "base/json/json_reader.h"
@@ skipping 54 matching lines @@
           return false;  // Invalid trace event JSON format.
       }
     }
 
     return true;
   }
 
   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,
                                 std::string* arg) const {
   std::map<std::string, std::string>::const_iterator i = arg_strings.find(name);
   if (i != arg_strings.end()) {
     *arg = i->second;
     return true;
   }
   return false;
 }
 
 bool TraceEvent::GetArgAsNumber(const std::string& name,
                                 double* arg) const {
   std::map<std::string, double>::const_iterator i = arg_numbers.find(name);
   if (i != arg_numbers.end()) {
     *arg = i->second;
     return true;
   }
   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 {

[Paweł Hajdan Jr., 2011/11/03 10:09:20]

Are those accessors used? I'd prefer to avoid adding them before they're used.

[jbates, 2011/11/03 17:10:32]

Yeah, some are used in a pending CL (http://codereview.chromium.org/7982007/)
and the rest are there for completeness. I split them because there was other
cleanup needed in this code.

To make sure they actually work, I added a test that verifies these methods.

+  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) {
 }
 
 QueryNode::~QueryNode() {
 }
 
 // Query
 
@@ skipping 266 matching lines @@
     case OTHER_PID:
       return static_cast<double>(the_event->thread.process_id);
     case EVENT_TID:
     case OTHER_TID:
       return static_cast<double>(the_event->thread.thread_id);
     case EVENT_TIME:
     case OTHER_TIME:
       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();
       }
     case EVENT_PHASE:
     case OTHER_PHASE:
       return static_cast<double>(the_event->phase);
     case EVENT_CATEGORY:
     case OTHER_CATEGORY:
       return the_event->category;
     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:
       {
         // Search for the argument name and return its value if found.
 
         std::map<std::string, std::string>::const_iterator str_i =
             the_event->arg_strings.find(string_);
         if (str_i != the_event->arg_strings.end())
           return str_i->second;
 
@@ skipping 267 matching lines @@
       continue;
     std::map<std::string, std::string>::const_iterator string_it =
         this_event.arg_strings.find("name");
     if (string_it != this_event.arg_strings.end())
       thread_names_[this_event.thread] = string_it->second;
   }
 }
 
 }  // namespace trace_analyzer