trace_event: distinguish between scoped begin/end and global start/finish events

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"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 
 namespace trace_analyzer {
 
 // TraceEvent
 
 TraceEvent::TraceEvent()
     : thread(0, 0),
       timestamp(0),
-      phase(base::debug::TRACE_EVENT_PHASE_BEGIN),
+      phase(TRACE_EVENT_PHASE_BEGIN),
       other_event(NULL) {
 }
 
 TraceEvent::~TraceEvent() {
 }
 
 bool TraceEvent::SetFromJSON(const base::Value* event_value) {
   if (event_value->GetType() != base::Value::TYPE_DICTIONARY)
     return false;
   const base::DictionaryValue* dictionary =
@@ skipping 603 matching lines @@
     return false;
   std::stable_sort(raw_events_.begin(), raw_events_.end());
   ParseMetadata();
   return true;
 }
 
 void TraceAnalyzer::AssociateBeginEndEvents() {
   using namespace trace_analyzer;
 
   Query begin(Query(EVENT_PHASE) ==
-      Query::Phase(base::debug::TRACE_EVENT_PHASE_BEGIN));
+      Query::Phase(TRACE_EVENT_PHASE_BEGIN));
   Query end(Query(EVENT_PHASE) ==
-      Query::Phase(base::debug::TRACE_EVENT_PHASE_END));
+      Query::Phase(TRACE_EVENT_PHASE_END));
   Query match(Query(EVENT_NAME) == Query(OTHER_NAME) &&
               Query(EVENT_CATEGORY) == Query(OTHER_CATEGORY) &&
               Query(EVENT_TID) == Query(OTHER_TID) &&
               Query(EVENT_PID) == Query(OTHER_PID));
 
   AssociateEvents(begin, end, match);
 }
 
 void TraceAnalyzer::AssociateEvents(const Query& first,
                                     const Query& second,
@@ skipping 52 matching lines @@
 const std::string& TraceAnalyzer::GetThreadName(
     const TraceEvent::ProcessThreadID& thread) {
   // If thread is not found, just add and return empty string.
   return thread_names_[thread];
 }
 
 void TraceAnalyzer::ParseMetadata() {
   for (size_t i = 0; i < raw_events_.size(); ++i) {
     TraceEvent& this_event = raw_events_[i];
     // Check for thread name metadata.
-    if (this_event.phase != base::debug::TRACE_EVENT_PHASE_METADATA ||
+    if (this_event.phase != TRACE_EVENT_PHASE_METADATA ||
         this_event.name != "thread_name")
       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