Remove usage of using namespace, and cleanup trace_analyzer namespace

base/test/trace_event_analyzer.h

 // 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.
 
 // Use trace_analyzer::Query and trace_analyzer::TraceAnalyzer to search for
 // specific trace events that were generated by the trace_event.h API.
 //
 // Basic procedure:
 // - Get trace events JSON string from base::debug::TraceLog.
 // - Create TraceAnalyzer with JSON string.
@@ skipping 154 matching lines @@
   std::map<std::string, double> arg_numbers;
 
   std::map<std::string, std::string> arg_strings;
 
   // The other event associated with this event (or NULL).
   const TraceEvent* other_event;
 };
 
 typedef std::vector<const TraceEvent*> TraceEventVector;
 
-// Pass these values to Query to compare with the corresponding member of a
-// TraceEvent. Unless otherwise specfied, the usage is Query(ENUM_MEMBER).
-enum TraceEventMember {
-  EVENT_INVALID,
-  // Use these to access the event members:
-  EVENT_PID,
-  EVENT_TID,
-  // Return the timestamp of the event in microseconds since epoch.
-  EVENT_TIME,
-  // Return the absolute time between event and other event in microseconds.
-  // Only works for events with associated BEGIN/END: Query(EVENT_HAS_OTHER).
-  EVENT_DURATION,
-  EVENT_PHASE,
-  EVENT_CATEGORY,
-  EVENT_NAME,
-  EVENT_ID,
-
-  // 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,
-
-  // Access the associated other_event's members:
-  OTHER_PID,
-  OTHER_TID,
-  OTHER_TIME,
-  OTHER_PHASE,
-  OTHER_CATEGORY,
-  OTHER_NAME,
-  OTHER_ID,
-
-  // 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 {
  public:
-  // Compare with the given member.
-  Query(TraceEventMember member);
-
-  // Compare with the given member argument value.
-  Query(TraceEventMember member, const std::string& arg_name);
-
   Query(const Query& query);
 
   ~Query();
 
+  ////////////////////////////////////////////////////////////////
+  // Query literal values
+
   // Compare with the given string.
   static Query String(const std::string& str);
 
   // Compare with the given number.
   static Query Double(double num);
   static Query Int(int32 num);
   static Query Uint(uint32 num);
 
   // Compare with the given bool.
   static Query Bool(bool boolean);
 
   // Compare with the given phase.
   static Query Phase(base::debug::TraceEventPhase phase);
 
   // Compare with the given string pattern. Only works with == and != operators.
   // Example: Query(EVENT_NAME) == Query::Pattern("MyEvent*")
   static Query Pattern(const std::string& pattern);
 
+  ////////////////////////////////////////////////////////////////
+  // Query event members
+
+  static Query EventPid() { return Query(EVENT_PID); }
+
+  static Query EventTid() { return Query(EVENT_TID); }
+
+  // Return the timestamp of the event in microseconds since epoch.
+  static Query EventTime() { return Query(EVENT_TIME); }
+
+  // Return the absolute time between event and other event in microseconds.
+  // Only works if Query::EventHasOther() == true.
+  static Query EventDuration() { return Query(EVENT_DURATION); }
+
+  static Query EventPhase() { return Query(EVENT_PHASE); }
+
+  static Query EventCategory() { return Query(EVENT_CATEGORY); }
+
+  static Query EventName() { return Query(EVENT_NAME); }
+
+  static Query EventId() { return Query(EVENT_ID); }
+
+  // Evaluates to true if arg exists and is a string.
+  static Query EventHasStringArg(const std::string& arg_name) {
+    return Query(EVENT_HAS_STRING_ARG, arg_name);
+  }
+
+  // Evaluates to true if arg exists and is a number.
+  // Number arguments include types double, int and bool.
+  static Query EventHasNumberArg(const std::string& arg_name) {
+    return Query(EVENT_HAS_NUMBER_ARG, arg_name);
+  }
+
+  // Evaluates to arg value (string or number).
+  static Query EventArg(const std::string& arg_name) {
+    return Query(EVENT_ARG, arg_name);
+  }
+
+  // Return true if associated event exists.
+  static Query EventHasOther() { return Query(EVENT_HAS_OTHER); }
+
+  // Access the associated other_event's members:
+
+  static Query OtherPid() { return Query(OTHER_PID); }
+
+  static Query OtherTid() { return Query(OTHER_TID); }
+
+  static Query OtherTime() { return Query(OTHER_TIME); }
+
+  static Query OtherPhase() { return Query(OTHER_PHASE); }
+
+  static Query OtherCategory() { return Query(OTHER_CATEGORY); }
+
+  static Query OtherName() { return Query(OTHER_NAME); }
+
+  static Query OtherId() { return Query(OTHER_ID); }
+
+  static Query OtherHasStringArg(const std::string& arg_name) {
+    return Query(OTHER_HAS_STRING_ARG, arg_name);
+  }
+
+  static Query OtherHasNumberArg(const std::string& arg_name) {
+    return Query(OTHER_HAS_NUMBER_ARG, arg_name);
+  }
+
+  static Query OtherArg(const std::string& arg_name) {
+    return Query(OTHER_ARG, arg_name);
+  }
+
+  ////////////////////////////////////////////////////////////////
   // Common queries:
 
   // Find BEGIN events that have a corresponding END event.
   static Query MatchBeginWithEnd() {
     return (Query(EVENT_PHASE) == Query::Phase(TRACE_EVENT_PHASE_BEGIN)) &&
            Query(EVENT_HAS_OTHER);
   }
 
   // Find START events that have a corresponding FINISH event.
   static Query MatchStartWithFinish() {
@@ skipping 11 matching lines @@
     return (Query(EVENT_PID) == Query::Int(thread.process_id)) &&
            (Query(EVENT_TID) == Query::Int(thread.thread_id));
   }
 
   // Match event pair that spans multiple threads.
   static Query MatchCrossThread() {
     return (Query(EVENT_PID) != Query(OTHER_PID)) ||
            (Query(EVENT_TID) != Query(OTHER_TID));
   }
 
+  ////////////////////////////////////////////////////////////////
+  // Operators:
+
   // Boolean operators:
   Query operator==(const Query& rhs) const;
   Query operator!=(const Query& rhs) const;
   Query operator< (const Query& rhs) const;
   Query operator<=(const Query& rhs) const;
   Query operator> (const Query& rhs) const;
   Query operator>=(const Query& rhs) const;
   Query operator&&(const Query& rhs) const;
   Query operator||(const Query& rhs) const;
   Query operator!() const;
 
   // Arithmetic operators:
   // Following operators are applied to double arguments:
   Query operator+(const Query& rhs) const;
   Query operator-(const Query& rhs) const;
   Query operator*(const Query& rhs) const;
   Query operator/(const Query& rhs) const;
   Query operator-() const;
   // Mod operates on int64 args (doubles are casted to int64 beforehand):
   Query operator%(const Query& rhs) const;
 
   // Return true if the given event matches this query tree.
   // This is a recursive method that walks the query tree.
   bool Evaluate(const TraceEvent& event) const;
 
  private:
+  enum TraceEventMember {
+    EVENT_INVALID,
+    EVENT_PID,
+    EVENT_TID,
+    EVENT_TIME,
+    EVENT_DURATION,
+    EVENT_PHASE,
+    EVENT_CATEGORY,
+    EVENT_NAME,
+    EVENT_ID,
+    EVENT_HAS_STRING_ARG,
+    EVENT_HAS_NUMBER_ARG,
+    EVENT_ARG,
+    EVENT_HAS_OTHER,
+    OTHER_PID,
+    OTHER_TID,
+    OTHER_TIME,
+    OTHER_PHASE,
+    OTHER_CATEGORY,
+    OTHER_NAME,
+    OTHER_ID,
+    OTHER_HAS_STRING_ARG,
+    OTHER_HAS_NUMBER_ARG,
+    OTHER_ARG,
+  };
+
   enum Operator {
     OP_INVALID,
     // Boolean operators:
     OP_EQ,
     OP_NE,
     OP_LT,
     OP_LE,
     OP_GT,
     OP_GE,
     OP_AND,
     OP_OR,
     OP_NOT,
     // Arithmetic operators:
     OP_ADD,
     OP_SUB,
     OP_MUL,
     OP_DIV,
     OP_MOD,
     OP_NEGATE
   };
 
   enum QueryType {
     QUERY_BOOLEAN_OPERATOR,
     QUERY_ARITHMETIC_OPERATOR,
     QUERY_EVENT_MEMBER,
     QUERY_NUMBER,
     QUERY_STRING
   };
 
+  // Compare with the given member.
+  Query(TraceEventMember member);
+
+  // Compare with the given member argument value.
+  Query(TraceEventMember member, const std::string& arg_name);
+
   // Compare with the given string.
   Query(const std::string& str);
 
   // Compare with the given number.
   Query(double num);
 
   // Construct a boolean Query that returns (left <binary_op> right).
   Query(const Query& left, const Query& right, Operator binary_op);
 
   // Construct a boolean Query that returns (<binary_op> left).
@@ skipping 187 matching lines @@
 
 // Count all matches.
 static inline size_t CountMatches(const TraceEventVector& events,
                                   const Query& query) {
   return CountMatches(events, query, 0u, events.size());
 }
 
 }  // namespace trace_analyzer
 
 #endif  // BASE_TEST_TRACE_EVENT_ANALYZER_H_