Allow tracing in third_party libraries

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 23 matching lines @@
       static_cast<const base::DictionaryValue*>(event_value);
 
   std::string phase_str;
   base::DictionaryValue* args = NULL;
 
   if (!dictionary->GetString("ph", &phase_str)) {
     LOG(ERROR) << "ph is missing from TraceEvent JSON";
     return false;
   }
 
-  phase = base::debug::TraceEvent::GetPhase(phase_str.c_str());
+  phase = *phase_str.data();
 
   bool require_origin = (phase != TRACE_EVENT_PHASE_METADATA);
   bool require_id = (phase == TRACE_EVENT_PHASE_START ||
                      phase == TRACE_EVENT_PHASE_FINISH);
 
   if (require_origin && !dictionary->GetInteger("pid", &thread.process_id)) {
     LOG(ERROR) << "pid is missing from TraceEvent JSON";
     return false;
   }
   if (require_origin && !dictionary->GetInteger("tid", &thread.thread_id)) {
@@ skipping 167 matching lines @@
 }
 
 Query Query::Uint(uint32 num) {
   return Query(static_cast<double>(num));
 }
 
 Query Query::Bool(bool boolean) {
   return Query(boolean ? 1.0 : 0.0);
 }
 
-Query Query::Phase(base::debug::TraceEventPhase phase) {
+Query Query::Phase(char phase) {
   return Query(static_cast<double>(phase));
 }
 
 Query Query::Pattern(const std::string& pattern) {
   Query query(pattern);
   query.is_pattern_ = true;
   return query;
 }
 
 bool Query::Evaluate(const TraceEvent& event) const {
@@ skipping 143 matching lines @@
     case OP_NEGATE:
       *num = -lhs;
       return true;
     default:
       NOTREACHED();
       return false;
   }
 }
 
 bool Query::GetAsDouble(const TraceEvent& event, double* num) const {
-  base::debug::TraceValue value;
   switch (type_) {
     case QUERY_ARITHMETIC_OPERATOR:
       return EvaluateArithmeticOperator(event, num);
     case QUERY_EVENT_MEMBER:
-      value = GetMemberValue(event);
-      if (value.type() == base::debug::TraceValue::TRACE_TYPE_DOUBLE) {
-        *num = value.as_double();
-        return true;
-      }
-      return false;
+      return GetMemberValueAsDouble(event, num);
     case QUERY_NUMBER:
       *num = number_;
       return true;
     default:
       return false;
   }
 }
 
 bool Query::GetAsString(const TraceEvent& event, std::string* str) const {
-  base::debug::TraceValue value;
   switch (type_) {
     case QUERY_EVENT_MEMBER:
-      value = GetMemberValue(event);
-      if (value.is_string()) {
-        *str = value.as_string();
-        return true;
-      }
-      return false;
+      return GetMemberValueAsString(event, str);
     case QUERY_STRING:
       *str = string_;
       return true;
     default:
       return false;
   }
 }
 
-base::debug::TraceValue Query::GetMemberValue(const TraceEvent& event) const {
+bool Query::GetMemberValueAsDouble(const TraceEvent& event,
+                                   double* num) const {
   DCHECK(type_ == QUERY_EVENT_MEMBER);
 
   // This could be a request for a member of |event| or a member of |event|'s
   // associated event. Store the target event in the_event:
   const TraceEvent* the_event = (member_ < OTHER_PID) ?
       &event : event.other_event;
 
   // Request for member of associated event, but there is no associated event.
   if (!the_event)
-    return base::debug::TraceValue();
+    return false;
 
   switch (member_) {
     case EVENT_PID:
     case OTHER_PID:
-      return static_cast<double>(the_event->thread.process_id);
+      *num = static_cast<double>(the_event->thread.process_id);
+      return true;
     case EVENT_TID:
     case OTHER_TID:
-      return static_cast<double>(the_event->thread.thread_id);
+      *num = static_cast<double>(the_event->thread.thread_id);
+      return true;
     case EVENT_TIME:
     case OTHER_TIME:
-      return the_event->timestamp;
+      *num = the_event->timestamp;
+      return true;
     case EVENT_DURATION:
       {

[jar (doing other things), 2012/01/12 00:15:36]

nit: open curly should come at the end of line 447.
Close curly (such as on line 454) should match the indent of the "c" in "case."

To put it another way: When you use curlies, the indent of the body of teh case
does not change (it is still just two deeper than the "c" in "case."

[jbates, 2012/01/12 00:52:20]

Done.

-        if (the_event->has_other_event())
-          return the_event->GetAbsTimeToOtherEvent();
-        else
-          return base::debug::TraceValue();
+        if (the_event->has_other_event()) {
+          *num = the_event->GetAbsTimeToOtherEvent();
+          return true;
+        }
+        return false;
       }
     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_ID:
-    case OTHER_ID:
-      return the_event->id;
+      *num = static_cast<double>(the_event->phase);
+      return true;
     case EVENT_HAS_STRING_ARG:
     case OTHER_HAS_STRING_ARG:
-      return (the_event->HasStringArg(string_) ? 1.0 : 0.0);
+      *num = (the_event->HasStringArg(string_) ? 1.0 : 0.0);
+      return true;
     case EVENT_HAS_NUMBER_ARG:
     case OTHER_HAS_NUMBER_ARG:
-      return (the_event->HasNumberArg(string_) ? 1.0 : 0.0);
+      *num = (the_event->HasNumberArg(string_) ? 1.0 : 0.0);
+      return true;
     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;
-
         std::map<std::string, double>::const_iterator num_i =
             the_event->arg_numbers.find(string_);
-        if (num_i != the_event->arg_numbers.end())
-          return num_i->second;
-
-        return base::debug::TraceValue();
+        if (num_i != the_event->arg_numbers.end()) {
+          *num = num_i->second;
+          return true;
+        }
+        return false;
       }
     case EVENT_HAS_OTHER:
       {
         // return 1.0 (true) if the other event exists
-        double result = event.other_event ? 1.0 : 0.0;
-        return result;
+        *num = event.other_event ? 1.0 : 0.0;
+        return true;
       }
     default:
-      NOTREACHED();
-      return base::debug::TraceValue();
+      return false;
   }
 }
 
+bool Query::GetMemberValueAsString(const TraceEvent& event,
+                                   std::string* str) const {
+  DCHECK(type_ == QUERY_EVENT_MEMBER);
+
+  // This could be a request for a member of |event| or a member of |event|'s
+  // associated event. Store the target event in the_event:
+  const TraceEvent* the_event = (member_ < OTHER_PID) ?
+      &event : event.other_event;
+
+  // Request for member of associated event, but there is no associated event.
+  if (!the_event)
+    return false;
+
+  switch (member_) {
+    case EVENT_CATEGORY:
+    case OTHER_CATEGORY:
+      *str = the_event->category;
+      return true;
+    case EVENT_NAME:
+    case OTHER_NAME:
+      *str = the_event->name;
+      return true;
+    case EVENT_ID:
+    case OTHER_ID:
+      *str = the_event->id;
+      return true;
+    case EVENT_ARG:
+    case OTHER_ARG:
+      {

[jar (doing other things), 2012/01/12 00:15:36]

nit: indent on curlies throughout this file in case statements.

[jbates, 2012/01/12 00:52:20]

Done.

+        // 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()) {
+          *str = str_i->second;
+          return true;
+        }
+        return false;
+      }
+    default:
+      return false;
+  }
+}
+
 Query::Query(const std::string& str)
     : type_(QUERY_STRING),
       operator_(OP_INVALID),
       member_(EVENT_INVALID),
       number_(0),
       string_(str),
       is_pattern_(false) {
 }
 
 Query::Query(double num)
@@ skipping 385 matching lines @@
   size_t count = 0u;
   for (size_t i = begin_position; i < end_position; ++i) {
     if (query.Evaluate(*events.at(i)))
       ++count;
   }
   return count;
 }
 
 }  // namespace trace_analyzer